func functionExplain(){
    
    /**
     枚举、结构体、类都可以定义实例方法、类型方法
         实例方法（Instance Method）：通过实例对象调用
         类型方法（Type Method）：通过类型调用，用static或者class关键字定义
     
     
     self的作用
         在实例方法中代表实例对象
         在类型方法中代表类型
     */
    class Car {
        //存储类型属性 相当于全局变量
        static var count = 0
        
        //类型方法
        static func getCount()->Int{
            //此处的count 与 self.count 效果相同
            //self在类型方法中代表类型
            count
        }
        
        //存储实例属性
        var number = 0
        //实例方法
        func getNumber()->Int{
            //此处number+=1 与 self.number += 1 效果相同
            //self在实例方法中代表实例
            //self.number += 1
            number += 1
            return number
        }
        
        
        init() {
            Car.count += 1
        }
    }
    
    let c = Car()
    print(c.getNumber())//1
    print(Car.getCount())//1
}

func mutatingUse() -> Void {
    
    /**
     结构体和枚举是值类型，默认情况下，值类型的属性不能被自身的实例方法修改
     在 func关键字前加 mutating 可以允许这种修改行为
     */

    do{
        print("------1---------")
        class Size{
            var width = 0
            var height = 0
            func add() -> Void {
                width += 10
                height += 10
            }
        }
        let s = Size()
        s.add()
        print(s.width,s.height)//10 10
    }
   
    
    do{
        print("------2---------")
        struct Point{
            var x = 0
            var y = 0
            mutating func moveBy(deltaX:Int,deltaY:Int) -> Void {
                x += deltaX
                y += deltaY
            }
        }
        var p = Point()
        p.moveBy(deltaX: 10, deltaY: 10)
        print(p.x,p.y)//10 10
    }
    
    
    do{
        print("------3---------")
        enum StateSwich {
            case low,middle,high
            mutating func next() -> Void {
                switch self {
                case .low:
                    self = .middle
                case .middle:
                    self = .high
                case .high:
                    self = .low
                }
            }
        }
        var st = StateSwich.low
        st.next()
        print(st)//middle
    }
   
}

func discardableResultUse() -> Void {
    /**
     在func前面加个@discardableResult 可以消除：函数调用后返回值未被使用的警告
     */

    struct Point {
        var x = 0,y = 0
        @discardableResult mutating func moveBy(deltaX:Int) -> Int {
            x += deltaX
            return x
        }
    }
    
    var p = Point()
    p.moveBy(deltaX: 10)
}

func gather() -> Void {
    
    //以结构体为例（枚举少一个实例存储属性其它一致）
    struct Point{
        
        //存储实例属性 可以是let var
        let x:Int = 0
        
        //存储实例属性 带属性观察器 必须是var
         var y:Int = 0{
            willSet{
                print(newValue)
            }
            didSet{
                print(oldValue)
            }
        }
        
        //计算实例属性 必须是var
        var z:Int{
            set{
                print(newValue)
            }
            get{
                return 5
            }
        }
        
        
        
        
        
        //存储类型属性 可以是let var
        static var j:Int = 0
        
        //存储类型属性 带属性监听器必须是var 否则报错
        //'let' declarations cannot be observing properties
        static var k:Int = 0{
            willSet{
                print(newValue)
            }
            didSet{
                print(oldValue)
            }
        }
        
        //计算类型属性 必须是var
        static var z:Int{
            set{
                print(newValue)
            }
            get{
                return 10
            }
        }
        
        
        
        
        //实例方法
        func pointFunction() -> Void {
            
        }
        
        //类型方法
        public func PointFunction()->Void{
            
        }
    }
}