《swift2.0 官方教程中文版》 第2章-11方法

import Foundation

//方法是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法;实例方法为给定类型的实例封装 了具体的任务与功能。类、结构体、枚举也可以定义类型方法;类型方法与类型本身相关联。类型方法与 Objecti ve-C 中的类方法(class methods)相似。

/*实例方法************************************************************/

//实例方法是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能,并以此来支撑实例的功能。

//实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。

class Counter {

    var count = 0

    func increment() {

        ++count

    }

    func incrementBy(amount: Int){

        count += amount

    }

    func reset() {

        count = 0

    }

}

let counter = Counter()

print("\(counter.count)")

// 初始计数值是0 

counter.increment()

print("\(counter.count)")

// 计数值现在是1 

counter.incrementBy(5)

print("\(counter.count)")

// 计数值现在是6 

counter.reset()

print("\(counter.count)")

// 计数值现在是0

class Counter2 {

    var count: Int = 0

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

        count += amount * numberOfTimes

    }

}

let counter2 = Counter2()

counter2.incrementBy(5, numberOfTimes: 3);

print("\(counter2.count)")

//下面的例子中, self 消除方法参数 x 和实例属性 x 之间的歧义:

struct Point {

    var x = 0.0, y = 0.0

    func isToTheRightOfX(x: Double) -> Bool {

        return self.x > x

    }

}

let somePoint = Point(x: 4.0, y: 5.0)

if somePoint.isToTheRightOfX(1.0) {

    print("This point is to the right of the line where x == 1.0")

}

// 打印输出: This point is to the right of the line where x == 1.0

//如果你确实需要在某个具体的方法中修改结构体或者枚举的属性,你可以选择 变异(mutating) 这个方 法,然后方法就可以从方法内部改变它的属性;并且它做的任何改变在方法结束时还会保留在原始结构中。方法 还可以给它隐含的 self 属性赋值一个全新的实例,这个新实例在方法结束后将替换原来的实例。

struct Point2 {

    var x = 0.0, y = 0.0

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

        x += deltaX

        y += deltaY

    }

}

var somePoint2 = Point2(x: 1.0, y: 1.0)

somePoint2.moveByX(2.0, y: 3.0)

print("The point is now at (\(somePoint2.x), \(somePoint2.y))")

// 打印输出: "The point is now at (3.0, 4.0)"

//变异方法能够赋给隐含属性 self 一个全新的实例。上面 Point 的例子可以用下面的方式改写:

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)

    }

}

//枚举的变异方法可以把 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 来允许子类 重写父类的实现方法。

//类型方法和实例方法一样用点语法调用。但是,你是在类型层面上调用这个方法,而不是在实例层面上调用。下 面是如何在 SomeClass 类上调用类型方法的例子:

class SomeClass {

    class func someTypeMethod() {

        // type method implementation goes here 

        print("someTypeMethod()")

    }

}

SomeClass.someTypeMethod()

//在类型方法的方法体(body)中, self 指向这个类型本身,而不是类型的某个实例。对于结构体和枚举来说,这意味着你可以用 self 来消除静态属性和静态方法参数之间的歧义

struct LevelTracker {

    static var highestUnlockedLevel = 1

    static func unlockLevel(level: Int) {

        if level > highestUnlockedLevel { highestUnlockedLevel = level }

    }

    static func levelIsUnlocked(level: Int) -> Bool {

        return level <= highestUnlockedLevel

    }

    var currentLevel = 1

    mutating func advanceToLevel(level: Int) -> Bool {

        if LevelTracker.levelIsUnlocked(level) {

            currentLevel = level

            return true

        } else {

            return false

        }

    }

}

//LevelTracker 监测玩家的已解锁的最高等级。这个值被存储在静态属性 highestUnlockedLevel 中。

//LevelTracker 还定义了两个类型方法与 highestUnlockedLevel 配合工作。第一个类型方法是 unlockLevel :一旦新等级被解锁,它会更新 highestUnlockedLevel 的值。第二个类型方法是 levelIsUnlocked :如果某个 给定的等级已经被解锁,它将返回 true 。(注意:尽管我们没有使用类似 LevelTracker.highestUnlockedLeve l 的写法,这个类型方法还是能够访问静态属性 highestUnlockedLevel )

//为了便于管理 currentLevel 属性, LevelTracker 定义了实例方法 advanceToLevel 。这个方法会在更新 curre ntLevel 之前检查所请求的新等级是否已经解锁。 advanceToLevel 方法返回布尔值以指示是否能够设置 curren tLevel 。

//下面, Player 类使用 LevelTracker 来监测和更新每个玩家的发展进度:

class Player {

    var tracker = LevelTracker()

    let playerName: String

    func completedLevel(level: Int) {

        LevelTracker.unlockLevel(level + 1)

        tracker.advanceToLevel(level + 1)

    }

    init(name: String) {

        playerName = name

    }

}

//Player 类创建一个新的 LevelTracker 实例来监测这个用户的进度。它提供了 completedLevel 方法:一旦玩家 完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级,并且将当前玩家的进度更新为下一等级。(我们忽略了 advanceToLevel 返回的布尔值,因为之前调用 LevelTracker.unlockLevel 时就知道了这个等级已经被解锁了)。

//你还可以为一个新的玩家创建一个 Player 的实例,然后看这个玩家完成等级一时发生了什么:

var player = Player(name: "Argyrios")

player.completedLevel(1)

print("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")

// 打印输出:highest unlocked level is now 2

//如果你创建了第二个玩家,并尝试让他开始一个没有被任何玩家解锁的等级,那么这次设置玩家当前等级的尝试将会失败:

player = Player(name: "Beto")

if player.tracker.advanceToLevel(6) {

    print("player is now on level 6")

} else {

    print("level 6 has not yet been unlocked")

}

// 打印输出:level 6 has not yet been unlocked