swift方法学习

/**

1.实例方法

2.类型方法

类型方法和OC中的类方法相似

结构体和枚举能够定义方法是swift与OC/C的主要区别之一。在OC中，类是唯一能定义方法的类型。但在swift中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型（类/结构体/枚举）上定义方法。

*/

//实例方法

/**

实例方法的语法和函数完全一致

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

*/

class Counter {

var count = 0;

func increment() {

count++;

}

func incrementBy(amount:
Int) {

count += amount;

}

func reset() {

count = 0;

}

}

//用点语法调用

let counter = Counter();

print("init:\(counter.count)");

counter.increment();

print("increment:\(counter.count)");

counter.incrementBy(10);

print("incrementBy:\(counter.count)");

counter.reset();

print("reset:\(counter.count)");

//方法的局部参数名称和外部参数名称

/**

方法和函数的局部名称和外部名称的默认行为是不一样的

swift默认仅给方法的第一个参数名称一个局部参数名称，默认同事给第二个和后续的参数名称局部参数名称和外部参数名称

*/

//修改方法的外部参数名称,用_可以不显示外部名称

class Counter1 {

var count: Int =
0;

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

count += amount * numberOfTimes;

}

}

var newCounter = Counter1();

newCounter.incrementBy(5, time:
2);

print(newCounter.count);

//self属性

/**

用来区分参数名称和属性名称

*/

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");

}

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

/**

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

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

不能再结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行

*/

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
\(somePoint.x),\(somePoint.y)");

//let somePoint3 = Point2(x: 3.0, y: 3.0);

//somePoint3.moveByX(4.0, y: 2.0);不能运行

//在变异方法中给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);

}

}

//三态开关例子

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();

//类型方法

/**

类型本身调用的方法叫做类型方法

声明类的类型方法，在方法的func关键字之前加上关键字class

声明结构体和枚举的类型方法，在方法的func关键字之前加上关键字static

在swift中，你可以为所有的类、结构体和枚举定义类型方法：每一个类型方法都被它所支持的类型显式包含

static用于静态存储

*/

class SomeClass2 {

class func someTypeMethod() {

print("类型方法创建成功");

}

}

SomeClass2.someTypeMethod();

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 currenLevel =
1;

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

if LevelTracker.levelIsUnlocked(level) {

currenLevel = 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 player1 = Player(name:
"xiaoming");

player1.completedLevel(1);

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

//player1.completedLevel(6);

var player2 = Player(name:
"Nick");

if player2.tracker.advanceToLevel(6)
{

print("player is now on level 6");

}else{

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

}