class Person {
var firstName: String
var lastName: String
init(firstName:String, lastName:String){
self.firstName = firstName
self.lastName = lastName
}
init?(fullName:String) {
guard let spaceIndex = fullName.rangeOfString(" ")?.startIndex
else{
return nil
}
self.firstName = fullName.substringToIndex(spaceIndex)
self.lastName = fullName.substringFromIndex(spaceIndex.successor())
}
func fullName() ->String{
return firstName + " " + lastName
}
}
let person1 = Person(firstName: "aaaa", lastName: "bbbb")
let person2 = Person(fullName: "full name")
person1.fullName()
类是引用类型
class Person {
var firstName: String
var lastName: String
var career: String?
init(firstName:String, lastName:String, career:String){
self.firstName = firstName
self.lastName = lastName
self.career = career
}
init(firstName:String, lastName:String){
self.firstName = firstName
self.lastName = lastName
}
func fullName() ->String{
return firstName + " " + lastName
}
}
let person1 = Person(firstName: "aaa", lastName: "sss", career: "doctor")
let person2 = person1
person2.firstName = "www"
person2.lastName = "rrr"
person2.career = "ceo"
//person2改变之后，person1也改变了－－－他们指向的是同一块内存空间（结构体是值类型，指向不同的内存空间，改变一个不会影响另一个）
person2
person1
class Person {
let firstName: String
let lastName: String
var career: String?
init(firstName:String, lastName:String, career:String){
self.firstName = firstName
self.lastName = lastName
self.career = career
}
init(firstName:String, lastName:String){
self.firstName = firstName
self.lastName = lastName
}
func fullName() ->String{
return firstName + " " + lastName
}
}
let person1 = Person(firstName: "aaa", lastName: "sss", career: "doctor")
//person1.firstName = "sss"不可修改
person1.career = "ceo"//person1的let类型不会限制内存空间中career的类型，但是person1已经指向了一块内存空间，而且是let类型，不可以再指向另一块
class Person {
let firstName: String
let lastName: String
var career: String?
init(firstName:String, lastName:String, career:String){
self.firstName = firstName
self.lastName = lastName
self.career = career
}
init(firstName:String, lastName:String){
self.firstName = firstName
self.lastName = lastName
}
func fullName() ->String{
return firstName + " " + lastName
}
func changeCareer(newCareer: String) {
self.career = newCareer
}
}
let person1 = Person(firstName: "aaa", lastName: "sss", career: "doctor")
person1.changeCareer("CEO")
结构体和枚举是值类型，改变自身要加mutating
struct Location {
var x = 0
var y = 0
mutating func goEast() {
self.x += 1//本来不可改变，加上mutating
}
}
var location = Location()
location.goEast()
enum Switch {
case On
case Off
mutating func click(){
switch self {
case On:
self = .Off
case Off:
self = .On
}
}
}
var button = Switch.Off
button.click()
类的等价
class Person {
var firstName: String
var lastName: String
var career: String?
init(firstName:String, lastName:String, career:String){
self.firstName = firstName
self.lastName = lastName
self.career = career
}
init(firstName:String, lastName:String){
self.firstName = firstName
self.lastName = lastName
}
func fullName() ->String{
return firstName + " " + lastName
}
}
let person1 = Person(firstName: "aaa", lastName: "sss", career: "doctor")
let person2 = person1
person1 === person2
let person3 = Person(firstName: "aaa", lastName: "sss", career: "doctor")
person1 === person3
person1 !== person3
//什么时候使用类，什么时候使用结构体
/*
1.一般位置，坐标，温度等等用结构体。人，动物，车，商店等等用类
2.类是引用类型，可以被继承。结构体是值类型
3.结构体比类更“轻量级”
*/
类的继承
class Avatar{
var name: String
var life = 100{
didSet{
if self.life <= 0{
self.isAlive = false
}
if self.life > 100{
self.life = 100
}
}
}
var isAlive: Bool = true
var description: String{
return "I'm avatar \(name)"
}
//指定构造函数
init(name : String){
self.name = name
}
convenience init(firstName: String, lastName: String){
self.init(name: firstName + " " + lastName)
}
func beAttacked(attack: Int) {
life -= attack
if life <= 0 {
isAlive = false
}
}
}
class User:Avatar{
var score = 0
var level = 0
//重载---重写父类的方法／属性
override var description: String{
return "I'm user \(name)"
}
//两段式构造
var group: String
init(name: String,group: String = "" ) {
//1.构造初值
self.group = group
super.init(name: name)
//2.进一步完善
if group == ""{
self.getScore(-10)
}
}
//convenience便利构造函数---没有最终把整个对象构造出来，而是执行了一些逻辑之后，把构造的任务交给了它本身的另外一个构造函数
//与之相对应的就是指定构造函数designated
convenience init(group: String = ""){
let name = User.generateUserName()
self.init(name: name, group: group)
}
/*
子类构造函数
1.如果子类没有实现任何父类的指定构造函数，则自动继承父类的所有指定构造函数
2.如果子类实现了父类的所有的指定构造函数，则自动继承父类的所有便利构造函数
*/
override convenience init(name: String) {
self.init(name: name, group: "")
}
func getScore(score: Int) {
self.score += score
if score > level*100 {
level += 1
}
}
static func generateUserName() -> String{
return "Player" + String(rand()%1_000_000)
}
}
final class Magician: User {
var magic = 0
override var description: String{
return "I'm magician \(name)"
}
override init(name: String, group: String) {
let defaultGroups = ["Gryffindor","Hufflrpuff","Ravenclaw","Slytherin"]
for theGroup in defaultGroups {
if group == theGroup {
super.init(name: name, group: group)
return
}
}
let group = defaultGroups[random()%4]
super.init(name: name, group: group)
}
func heal(user: User) {
user.life += 10
}
}
final class Warrior: User {
var weapon: String
init(name: String, group: String, weapon: String ) {
self.weapon = weapon
super.init(name: name, group: group)
}
override var description: String{
return "I'm Warrior \(name)"
}
override func beAttacked(attack: Int) {
self.life -= attack/2
}
}
class Monster: Avatar {
override var description: String{
return "I'm monster \(name)"
}
func attack(user: User, amount: Int) {
user.beAttacked(amount)
}
}
final class Zombie: Monster{
var type = "Default"
override var description: String{
return "I'm zombie \(name)"
}
}
let player = User(name: "aaa")
player.name
player.life
player.isAlive
player.score
player.beAttacked(10)
player.life
player.getScore(30)
player.level
//不希望再有子类，在前面加final
//类的多态
let player1 = Magician(name: "Harry Potter")
let player2 = Warrior(name: "liuyubobobo")
let zombie = Zombie(name: "default zombie1")
let monster = Monster(name: "monster")
func printBasicInfo(avatar:Avatar) {
print("The avatar's name is \(avatar.name)")
print("The life is \(avatar.life). He is \( (avatar.isAlive) ? "still alive" : "dead")" )
print("======")
}
printBasicInfo(player1)
printBasicInfo(player2)
printBasicInfo(zombie)
printBasicInfo(monster)
let avatarArr:[Avatar] = [player1, player2, zombie, monster]
for avatar in avatarArr{
//avatar.life -= 10
print(avatar.description)
}
player1.heal(player2)
player1.heal(player1)
//print(player1.description)
//print(player2.description)
//print(zombie.description)
//print(monster.description)
monster.attack(player1, amount: 20)
player1.life
monster.attack(player2, amount: 20)
player2.life
两段式构造
let user = User(name: "aaa", group: "ddd")