方法

类、结构体和枚举都能定义成实例方法和类方法

Swift与C和Objective-C的主要区别就是结构体和枚举可以定义方法。在Objective-C中，只有类才能定义方法。而在Swift中，你可以有选择性的在类、结构体或枚举中定义方法，并且使得在你创建的类中定义方法时更具有灵活性。

实例方法

实例方法是属于一个特定的类、结构体或枚举的实例的函数,一个实例方法具有隐式访问所有其他的实例方法和属性类型

class Counter {
    var count = 0
    func increment() {
        ++count
    }
    func incrementBy(amount: Int) {
        count += amount
    }
    func reset() {
        count = 0
    }
}
//Counter类里定义了三个实例方法:
//increment 计数器增量加1
//incrementBy(amount: Int)计数器由特定的整数作为增量
//reset 重置计数器的值为0

创建类的实例调用方法

let counter = Counter()
// the initial counter value is 0
counter.increment()
// the counter's value is now 1
counter.incrementBy(5)
// the counter's value is now 6
counter.reset()
// the counter's value is now 0

方法的局部和外部参数名

函数的参数可以拥有局部名称(在函数体内使用)和一个外部名称(在调用函数时使用)。

方法的参数也是如此，因为方法是与类型相关的函数。然而，局部名称和外部名称的默认行为是不同于函数和方法的。

Swift在方法中默认的将第一个参数名作为方法的局部参数名，也默认的将第二个和后续的参数名同时作为局部参数和外部参数名

class Counter2 {
    var count: Int = 0
    func incrementBy(amount: Int,numberOfTimes: Int) {
        count += amount * numberOfTimes
    }
}

这个incrementBy方法有两个参数amount 和 numberOfTimes.默认情况下，Swift将amount视为唯一的局部名称，但将numberOfTimes同时视为局部名称和外部名称。调用方法如下：

let counter2 = Counter2()
counter2.incrementBy(5,numberOfTimes: 3)
// counter value is now 15
//若在参数名前加#则表示使用与OC相同的语法风格,将参数名同时作为外部参数名和内部参数名
func incrementBy(#amount: Int,numberOfTimes: Int) {
    int count += amount * numberOfTimes
}
//counter2.incrementBy(amount:5,numberOfTimes: 3)
//方法的外部参数名称修饰行为
//有时为方法的第一个参数提供一个外部参数名是非常有用的。尽管这不是默认的行为。你可以添加一个你自己明确的外部名称，或者你也可以使用局部名称作为外部名称并在参数名前加一个散列符号作为参数名的前缀
//相反的，如果你不想为一个方法的第二个参数或后续参数提供外部参数名，可通过使用下划线符号（_）作为该参数的显式外部参数名称来覆盖默认行为。

self属性

每一个类型的实例都有一个称为 self 的隐式属性，它是完全等同于该实体本身的。你可以使用这个隐式的self属性饮用当前实例的实例方法。

主要的异常发生在一个实例方法的参数名和实例的属性名相同。在这种情况下，参数名优先，有必要参考属性更多的合格方式。你可以使用隐式的self属性区分参数名和属性名

在这里，使用了self来区分名称同为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) {
 println("This point is to the right of the line where x == 1.0")
}
 prints "This point is to the right of the line where x == 1.0"

修改值类型的实例方法

结构体和枚举都是值类型。默认情况下，值类型的属性不能从它的内部实例方法修改。

如果你需要在一个特定的方法中修改你的结构体或枚举的属性，你可以在这个方法中选择加入变异行为

struct Point {
    var x = 0.0,y = 0.0
//    mutating关键字添加到方法的定义上，使它能够修改它的属性
    mutating func moveByX(deltaX: Double,y deltaY: Double) {
        x += deltaX
        y += deltaY
    }
}
var somePoint = Point(x: 1.0,y: 1.0)
somePoint.moveByX(2.0,y: 3.0)
println("The point is now at ((somePoint.x),(somePoint.y))")
// prints "The point is now at (3.0,4.0)"

由变异方法分配self

变异方法可以分配一个全新的实例给隐式的self属性。

struct Point {
    var x = 0.0,y = 0.0
    mutating func moveByX(deltaX: Double,y deltaY: Double) {
        self = Point(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 is now equal to .High
ovenLight.next()
// ovenLight is now equal to .Off

类型方法

由类型自身调用的方法,称为类型方法

你可以通过在func 关键字前写上class 关键字来声明类的类型方法，而在结构体或枚举内定义类型方法则需在func关键字前书写static 关键字来声明

class SomeClass {
    class func someTypeMethod() {
        // type method implementation goes here
    }
}
SomeClass.someTypeMethod()

在类型方法体内，隐式的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
        }
    }
}