swift2.0 学习笔记eight

class ViewController: UIViewController {

    

    override func viewDidLoad() {

        super.viewDidLoad()

        //方法(Methods)实例方法和类型方法

        //方法是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法

        //结构体和枚举能够定义方法是swift与oc的主要区别之一，oc中类是唯一能定义方法的类型

        

        //实例方法

        //实例方法是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或与实例目的相关的功能，实例方法的语法与函数完全一致

        //实例方法只能被它所属的类的某个特定实例调用

        class Counter{

            var count = 0{

                didSet{

                    NSLog("当前的count＝%i",count)

                }

            }

            func increment(){

                ++count

            }

            func incrementBy(amount : Int){

                count += amount

            }

            func reset()

            {

                count = 0

            }

        }

        let ccc = Counter()

        print(ccc.count)//0

        ccc.increment()//当前的count＝1

        ccc.incrementBy(5)//当前的count＝6

        ccc.reset()//当前的count＝0

        

        //Swift 默认仅给方法的第一个参数名称一个局部参数名称;默认同时给第二个和后续的参数名称局部参数名称和外部参数名称

        

        let ccc2 = Counter2()

        ccc2.incrementBy(ccc2.addFunc, numberOfTimes: 6)

        print("===\(ccc2.count)")//===36

        

        

        //self 属性(The self Property)

        //类型的每一个实例都有一个隐含属性叫做self，self完全等同于该实例本身

        //可以在一个实例的实例方法中使用隐含的self属性来引用当前实例

        struct Point {

            var x = 0.0, y = 0.0

            func isToTheRightOfX(x: Double) -> Bool {

            return self.x > x

            }

        }

        

        

        //在实例方法中修改值类型

        //结构体和枚举是值类型。一般情况下，值类型的属性不能在他的实例方法中被修改

        //除非选择变异(mutating)这个方法，然后方法就可以从方法内部改变它的属性，并且所做的任何修改会保留在原始结构中

        struct Point2 {

            var x = 0.0 ,y = 0.0

            mutating func moveByX(deltaX : Double , deltaY: Double){

               x += deltaX

               y += deltaY

            }

        }

        var myPoint = Point2 (x: 1, y: 1)

        myPoint.moveByX(4, deltaY: 4)

        print("The Point is now at\(myPoint.x),\(myPoint.y)")//The Point is now at 5.0,5.0

        

        //不能在结构体类型常量上调用可变方法,因为常量的属性不能被改变

        let myPoint2 = Point2 (x: 1, y: 1)

        //myPoint2.moveByX(4, deltaY: 4)//会报错

       

        //在可变方法中给 self赋值

        //可变方法能够给隐含属性self一个全新的实例

        struct Point3{

             var x = 0.0 , y = 0.0

             mutating func moveByX(deltaX :Double,y deltaY :Double){

             self = Point3(x: x + deltaX, y: y + deltaY)

            }

        }

        var myPoint3 = Point3(x: 1, y: 1)

        myPoint3.moveByX(4, y: 4)

        print("The Point is now at\(myPoint3.x),\(myPoint3.y)")//The Point is now at 5.0,5.0

        

        

        enum StateSwitch{

            case Off , Low, High

            mutating func next(){

            switch self{

        case Off:

                self = Low

        case Low:

                self = High

        case High:

                self = Off

            }

            }

        }

        var test = StateSwitch.Low

        test.next()

        print(test) //High

        test.next()

        print(test) //Off

        

        

        //类型方法

        //实例方法是被类型的某个实例调用的方法，也可以定义类型本身调用的方法，这种方法叫做类型方法

        //在 Objective-C里面,你只能为 Objective-C的类定义类型方法(type-level methods)。在 Swift中,你可以为所有的类、结构体和枚举定义类型方法

        class SomeClass{

            var aaaa = 0.0

            static func TypeMethod(){

               //静态方法只能调用静态变量

               print("++++++")

            }

        }

        SomeClass.TypeMethod()//++++++

        

        

    }

}

class Counter2{

    var count: Int = 0

    var addFunc: (Int,Int)->Int = {

        (a:Int,b:Int)in return a + b

    }

    

    func incrementBy( amount : (Int,Int)->Int ,numberOfTimes:Int){

       

        count += amount(2,4) * numberOfTimes

        

    }

    

}