方法是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法；实例方法为特定类型的实例封装具体的任务与功能。类、结构体、枚举也可以定义类型方法；类型方法与类型本身相关联。类型方法与OC中的类方法类似。
 结构体和枚举能够定义方法是swift与C/OC主要区别之一。OC中，类是唯一能定义方法的类型。

一、实例方法

---

实例方法是属于某个特定类、结构体、枚举类型实例对象的方法。实例方法提供访问和修改实例属性的方法，另外实例方法的语法与函数完全一致(参考函数)。
 实例方法要写在它所属的类型的大括号内。实例方法能够隐式访问它所属类型的所有的实例方法以及属性。实例方法只能够被它所属类的实例对象调用。

• 实例方法基本使用

// 定义一个学生类
class Student {
    // 学习次数
    var count = 1;
    // 实例方法1 - 说
    func speak() {
        print("hello");
    }
    // 实例方法2 - 学习
    func study() {
        // 每学习一次就加一
        count += 1;
    }
    // 实例方法3 - 重置
    func reset() {
        count = 0;
    }
}
// 调用实例方法，与调用属性一样，都是通过点语法
let liming = Student();
// 调用实例方法1
liming.speak();
// 调用实例方法2
liming.study();
// 调用实例方法3
liming.reset();
输出结果:
hello
count:2
count:0

• 方法的局部参数名称和外部参数名称。swift的方法和OC中的方法类似，通常用一个介词指向方法的第一个参数，例如with、for、by等。swift中默认仅给方法的第一个参数是局部参数名称，默认同时给第二个和后续参数名称局部参数名称和外部参数名称:

class Student {
    // 实例方法 - 学习(具体学科，谁学习)
    func studyWith(subjectStr:String, studentName:String) {
        print("\(studentName)正在学习\(subjectStr)...");
    }
}
// 调用实例方法，与调用属性一样，都是通过点语法
let student = Student();
// 方法调用student.studyWith(subjectStr: String, studentName: String)
student.studyWith("英语", studentName: "张三");
输出结果:
张三正在学习英语...

注意: 不必为第一个参数值再定义一个外部变量名: 从方法名studyWith(_, studentName:)可看出其作用。但第二个参数，就要被一个外部参数名称所限定，以便在方法调用时明确作用。

• self属性。类型的每个实例都隐含着一个self，self即表示是实例本身:

class Student {
    var name:String?;
    func studyWith(name:String) {
        // self表示实例本身，即访问实例中的name属性
        self.name = name;
        print("\(name)正在学习...");
    }
}
let student = Student();
student.studyWith("张三");
输出结果:
张三正在学习...

• self属性消除方法参数和实例属性之间的歧义:

struct Point {
    var x=0.0, y=0.0;
    // 判断x是否在点(x,y)的右边
    func isToRightOfX(x:Double) -> Bool {
        // 传入参数与属性x相比较
        // self.x表示是实例属性，x表示是方法参数
        if self.x < x {
            // 表在右边
            return true;
        } else {
            // 表在左边
            return false;
        }
    }
}
// 实例化结构体
// 所有结构体都有一个自动生成的成员逐一构造器，用于初始化结构体实例中的成员属性
var somePoint = Point(x:1.0, y:1.0);
if (somePoint.isToRightOfX(5.0)) {
    print("右边");
} else {
    print("左边");
}
输出结果:
右边

• 在实例方法中修改值类型。结构体和枚举是值类型，一般情况下，值类型的属性不能再它的实例方法中被修改。如果想要修改实例中的结构体或枚举的属性，可以选择变异这个方法，即方法就可以从方法内部改变它的属性，请求修改完结束后，还会保留在原始结构体中:

struct Point {
    var x=0.0, y=0.0;
    // 判断x是否在点(x,y)的右边
    mutating func moveToPoint(newX newX:Double, newY:Double) {
        // 修改结构体中的属性
        // 如果没有'mutating'关键字，则会报错
        x = newX;
        y = newY;
    }
}
// 注意不能再定义为常量，因为常量的属性不能被修改
var somePoint = Point();
print("x:\(somePoint.x)  y:\(somePoint.y)");
somePoint.moveToPoint(newX: 30, newY: 30);
print("x:\(somePoint.x)  y:\(somePoint.y)");
输出结果:
x:0.0  y:0.0
x:30.0  y:30.0

• 结构体，在可变方法中给self赋值。可变方法是能够给隐含属性self赋值的:

struct Point {
    var x=0.0, y=0.0;
    // 判断x是否在点(x,y)的右边
    mutating func moveToPoint(newX newX:Double, newY:Double) {
        // 写法二，直接给本实例赋值
        self = Point(x:newX, y:newY);
    }
}
var somePoint = Point();
print("x:\(somePoint.x)  y:\(somePoint.y)");
somePoint.moveToPoint(newX: 30, newY: 30);
print("x:\(somePoint.x)  y:\(somePoint.y)");
输出结果:
x:0.0  y:0.0
x:30.0  y:30.0

• 枚举的可变方法可以把self设置为相同的枚举类型中不同成员:

// 定义一个三态开关的枚举
enum StatuSwitch {
    // 关闭的、暗的、高亮的
    case Off, Low, High;

    // 实例方法
    mutating func next() {
        switch self {
        case Off:
            self = Low;
        case Low:
            self = High;
        case High:
            self = Off;
        }
    }
}
// 默认是关闭
var someStatu = StatuSwitch.Off;    // Off
someStatu.next();   // Low
someStatu.next();   // High

二、类型方法

---

通过类型本身调用的方法称为类型方法。声明结构体和枚举的类型方法，在方法的func关键字前面加上static。类可以用关键字class来允许子类重写父类方法。类型方法和实例方法一样用点语法调用。

• 类型方法基本使用:

class someClass {
    // 类型方法
    static func speak() {
        print("hello Swift");
    }
}
// 调用someClass类型方法
someClass.speak();
输出结果:
hello Swift

在OC中，只能为类定义类型方法。在swift中，可以为类、结构体、枚举定义类型方法。

• 类型方法，只能调用本类中另外的类型方法，直接就是类型方法名即可调用，不需要加上类型的名称。另外，可以直接通过静态属性名来访问静态属性，而不需要类型名称(结构体和枚举也同样):

// 该结构体用于检测玩家的等级，以及等级限制的解锁操作
struct LevelTracker {
    // 已经解锁的最高等级，静态属性
    // 默认所有玩家解锁的最高等级都是1
    static var highestUnlockLevel = 1;

    // 类型方法，改变最高等级
    static func unlockLevel(level:Int) {
        if level > highestUnlockLevel {
            highestUnlockLevel = level;
        }
    }

    // 类型方法，判断最高等级是否解锁
    static func unlockLevelStauts(level:Int) -> Bool {
        return highestUnlockLevel >= level;
    }

    // 玩家当前等级，默认是1级
    var currentLevel = 1;
    // 实例方法 - 更新当前等级
    mutating func advanceLevel(level:Int) -> Bool {
        // 检查新等级是否解锁成功
        if LevelTracker.unlockLevelStauts(level) {    // 类型方法的调用
            currentLevel = level;
            return true;    // 表当前等级更新成功
        } else {
            return false;
        }
    }
}
// 玩家类
class Player {
    // 检测和更新玩家等级
    var playerLevelTracker = LevelTracker();
    // 玩家名
    var playerName:String = "";
    // 实例方法 - 玩家完成任务，解锁下一个等级
    func completedTask(level:Int) {
        // 解锁最高等级
        LevelTracker.unlockLevel(level);
        // 更新当前等级
        playerLevelTracker.advanceLevel(level);
    }
    // 构造方法
    init(name:String) {
        playerName = name;
    }
}
// 实例化玩家1
var player1 = Player(name: "EndEvent");
// 玩家完成‘等级1’的任务
player1.completedTask(1);
// 玩家解锁的最高等级
print("玩家解锁的最高等级: \(LevelTracker.highestUnlockLevel)");
// 玩家2
var player2 = Player(name: "zhangsan");
// 尝试直接更新到"等级6"
if player2.playerLevelTracker.advanceLevel(6) {
    print("更新成功");
} else {
    print("更新失败");
}
输出结果:
玩家解锁的最高等级: 1
更新失败

注：xcode7.3环境

作者：西门奄
链接：https://www.jianshu.com/u/77035eb804c3
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。