//实例方法
    //实例方法是属于某个特定类，结构体或者枚举类型实例的方法，实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能
    
    class Counter {
    
        var count = 0
        func increment() {
            count += 1
        }
        func increment(by amount: NSInteger)  {
            count += amount
        }
        func reset() {
            count = 0
        }
        
    }
    
    let counter = Counter() // 初始计数值是0 
    counter.increment()// 计数值现在是1
    counter.increment(by: 5) // 计数值现在是6 
    counter.reset()// 计数值现在是0
    
    
    //self属性 :类型的每一个实例都有一个隐含属性叫做 self , self 完全等同于该实例本身。你可以在一个实例的实例方法中 使用这个隐含的 self 属性来引用当前实例。

 //        func increment() {
 //        
 //            self.count += 1
 //        }
    
    //在实例方法中修改类型
    //要使用可变方法,将关键字mutating 放到方法的func关键字之前就可以了:
    struct Point {
    
        var x = 0.0 , y = 0.0
        mutating func moveByX(deltaX:Double , y deltaY: Double) {
        
            x += deltaX
            y += deltaY
        }
        
    }
    
    var somePoint = Point(x: 1.0, y: 1.0)
    somePoint.moveByX(deltaX: 2.0, y: 3.0)
    print("The point is now at (\(somePoint.x), \(somePoint.y))")
    
    //注意,不能在结构体类型的常量(a constant of structure type)上调用可变方法,因为其属性不能被改 变,即使属性是变量属性,
    
    //在可变方法中给self赋值
    struct Points {
    
        var x = 0.0, y = 0.0
        mutating func moveBy(x deltaX: Double, y deltaY: Double) {
        
            self = Points(x: x + deltaX , y:y + deltaY)
        }
        
    }
    //枚举的可变方法可以把 self 设置为同一枚举类型中不同的成员:
    enum TriStateSwitch {
    
        case Off , Low, High
        mutating func next() {
        
            switch self {
            case .Off:
                self = .Low
            case .Low:
                self = .High
            case .High:
                self = .Off

            }
        }
    }
    
    var ovenLight = TriStateSwitch.Low
    ovenLight.next()
    // ovenLight 现在等于 .High 
    ovenLight.next()
    // ovenLight 现在等于 .Off
    
    //类型方法:实例方法是被某个类型的实例调用的方法，也可以定义在类型本身上调用的方法，这种方法就叫做类型方法.在方法的func关键字之前加上关键字static，来指定类型方法。类还可以用关键字class来允许子类重写父类的方法实现
    
    class SomeClass {
    
        class func someTypeMedthod() {
            //实现类型方法
        }
    }
    SomeClass.someTypeMedthod()
    
    
    struct LevelTracker {
        static var highestUnlockedLevel = 1
        var currentLevel = 1
        static func unlock(_ level: Int) {
            if level > highestUnlockedLevel { highestUnlockedLevel = level }
        }
        static func isUnlocked(_ level: Int) -> Bool {
            return level <= highestUnlockedLevel
        }
        @discardableResult
        mutating func advance(to level: Int) -> Bool {
            if LevelTracker.isUnlocked(level) {
                currentLevel = level
                return true
            } else {
                return false
            } }
    }