swift学习笔记之-方法部分

//方法部分

import UIKit

//方法（Methods）

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

实例方法(Instance Methods):

1.属于某个特定类、结构体或者枚举类型的实例的方法，提供访问和修改实例属性的方法或提供与实例目的相关的功能

2.只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。

类型方法(Type Methods):通过类型本身调用的方法（static func ...）

1.声明结构体和枚举的类型方法，在方法的func关键字之前加上关键字static。类可能会用关键字class来允许子类重写父类的方法实现

2.在类型方法的方法体（body）中，self指向这个类型本身，而不是类型的某个实例

3.在类型方法的方法体中，任何未限定的方法和属性名称，将会指代本类中的类型方法和类型属性，即：一个类型方法中可以直接通过类型方法、类型属性的名称调用本类中的类型方法、类型属性，而无需在方法、属性名称前面加上类型名称前缀(无需通过点语法调用)，而非类型方法则需要加类型名称前缀

方法的局部参数名称和外部参数名称 (Local and External Parameter Names for Methods)：

1.默认仅给方法的第一个参数名称为局部参数；默认同时给第二个和后续的参数名称为局部参数名称和外部参数名称

2.可以为一个参数添加一个显式的外部名称，可以通过"_"省略第二个和之后的参数的外部名称

self属性：

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

2.实例方法的某个参数名称与实例的某个属性名称相同的时候，参数名称享有优先权，并且在引用属性时必须使用"self.属性"来区分属性名称和参数名称。

变异方法(mutating methods):(类class类型为引用类型，默认的方法即为可变方法，为值类型定义的变异方法其实就是将该方法定义为可以像类class类型方法一样使用)

1.定义在结构体和枚举等的值类型中，因为结构体和枚举是值类型，不能通过普通方法更改值类型的实例的属性

2.通过加关键字mutating定义变异方法，可以在方法内部改变它的属性；并且它做的任何改变在方法结束时还会保留在该实例结构中。

3.方法还可以给它隐含的self属性赋值一个全新的实例，这个新实例在方法结束后将替换原来的实例*/

class Counter {

var count: Int = 0

func incrementBy(count:Int) {    //使用"self.属性"来区分属性名称和参数名称

self.count += count

}

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

count += amount * numberOfTimes

}

func incrementBy2(number amount: Int,_ numberOfTimes: Int) {  //为第一个参数添加一个显式的外部名称，通过"_"调用时可以省略参数的外部名称

count += amount * numberOfTimes

}

}

let counter1 = Counter()

let counter2 = counter1  //此处counter2 === counter1 ,引用了同一个类的实例

counter1.incrementBy1(5,numberOfTimes:3)  //默认第一个参数为局部参数，第二和之后的参数为局部和外部参数(必须带参数名字)

print(counter1.count)

counter2.incrementBy2(number: 4, 6)

//执行计算：15+4*6

print(counter2.count)

//=============结构体和枚举的变异方法（mutating methods）======

struct Point {

var x = 0.0, y = 0.0

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

x += deltaX

y += deltaY

}

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

self = Point(x: x + deltaX, y: y + deltaY)      //通过给实例的self属性赋值，来改变原实例

}

}

var somePoint1 = Point(x: 1.0, y: 1.0)

var somePoint2 = somePoint1    //因为是结构体，somePoint2接收的值是somePoint1的值的拷贝,之后修改somePoint1不影响somePoint2

somePoint1.moveByX1(2.0, y: 3.0)   //调用变异方法moveByx1更改了实例somePoint1的属性值(调用mutating方法时，将结构体struct当着类class来处理)

var somePoint3 = somePoint1

somePoint1.createBy(8.0, y: 9.0)  //变异方法通过给实例的self属性赋值一个全新的实例，并用该新实例替换了旧实例

print("point1 ＝ (\(somePoint1.x), \(somePoint1.y)) , point2 ＝ (\(somePoint2.x), \(somePoint2.y)) , point3 ＝ (\(somePoint3.x), \(somePoint3.y))"

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

//=========类型方法=============

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

}

}

}

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

}

}

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