方法

1. 类外叫做函数，它没和其他类型关联。
2. 类内叫做方法，它和特定类型关联了。
3. 方法分为类型方法和实例方法。
4. 每个实例方法都有一个隐士的属性self，不必去特意使用self，但是有时候为了避免歧义要用self。
5. 枚举体，结构体中的实例方法改变属性值
   1. 默认枚举体，结构体中的方法是不能改变自身属性值的。
   2. 如果枚举体或者结构体中的方法要改变自身的值那就在方法前用mutating关键字

struct Point {
    var x = 0.0, y = 0.0
    mutating func moveBy(x: Double, y: Double) {
//        self.x += x
//        self.y += y
        self = Point(x: self.x + x, y: self.y + y)
    }
}

var point = Point(x: 1, y: 1)
point.moveBy(x: 3, y: 4)
print(point)


enum ChangeSwitch: String {
    case off, low, high
    
    mutating func change(){
        switch self {
        case .off:
            self = .low
        case .low:
            self = .high
        case .high:
            self = .off
        }
    }
}

var changeSwitch = ChangeSwitch.off
changeSwitch.change()
print(changeSwitch)
changeSwitch.change()
print(changeSwitch)

6. 类型方法
   1. 实例方法可以重写
   2. 用static关键字修饰的方法变为类型方法，但是不可以被重写
   3. 用class关键字修饰的方法变为类型方法，可以被重写
   4. struct，enum类型内部的方法如果要用类型方法，只能考虑用static关键字

struct LevelTracker {
    static var heightLevelUnlock = 1
    var curLevel = 1
    
    static func unlock(level: Int){
        if level > heightLevelUnlock {
            heightLevelUnlock = level
        }
    }
    
    static func isUnlock(level: Int) -> Bool{
        return level <= heightLevelUnlock
    }
    
    @discardableResult
    mutating func advance(level: Int) -> Bool {
        if level <= LevelTracker.heightLevelUnlock {
            curLevel = level
            return true
        }else{
            return false
        }
    }
}

class Player {
    var tracker = LevelTracker()
    let name: String
    
    func complete(level:Int) {
        LevelTracker.unlock(level: level + 1)
        tracker.advance(level: level + 1)
    }
    
    init(name: String) {
        self.name = name
    }
}

var a = Player(name: "小明")
a.complete(level: 1)
print(a.tracker)

var b = Player(name: "小王")
if  b.tracker.advance(level: 5){
    print("可以玩第5级")
}else{
    print("不可以玩第5级")
}

属性和方法总结

1. @discardableResult关键字可以让它下边的方法忽略返回值，就是说调用方法的时候不用变量接收也不会有警报。
2. 一个方法如果是单纯的就是为了返回一个值，那么就不能用@discardableResult。
3. 如果一个方法不仅仅可以返回一个值还有其他功能这时候在这个方法的上边写@discardableResult关键字会更好

class MyClass {
    //存储属性都不能被重写，前边加上static变成类类型属性，延时属性不能有类类型，也不能被重写。
    static var a = 4
    static let b = 4
    lazy var c = 5
    static var d = 5{
        willSet{
            
        }
    }
    
    //计算类型属性和方法实例类型本身就支持重写，加上static变成类类型不支持重写，加上class变成类类型支持重写。
    //static修饰计算属性变成类类型不支持重写，class修饰变成类类型计算属性，支持重写
    class var e:Int{
        return 8
    }
    
    //static修改一个方法变成类类型方法，不支持重写。class修饰一个方法变成类类型支持重写。
    class func test() {
        
    }
}

class MySubClass: MyClass {
    override class func test() {
        
    }
}