Swift 方法

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

实例方法(Instance Methods)

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

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

下面的例子,定义一个简单的Counter类,Counter能被用类对一个动作发生的次数进行计数:

class Counter{
    var count = 0;
    func increment(){
        count+=1;
    }
    func increment(by amount: Int){
        count+=amount;
    }
    func reset (){
        count = 0;
    }
}

Counter类定义了三个实例方法:

  • increment让计数器按一递增
  • increment(by : Int)让计数器按一个指定的值递增
  • reset将计数器重制为0

Counter这个类型还声明了一个可变属性count,用它来保持对当前计数器的追踪。

和调用属性一样,用点语法(dot syntax)调用实例方法:

let counter = Counter();
//count = 0;
counter.increment();
//count = 1;
counter.increment(by: 3);
//count = 4;
counter.reset();
//count = 0;

函数参数可以同时有一个局部名称(在函数体内部使用)和一个外部名称(在调用函数时使用)。方法参数也一样,因为方法就是函数,只是这个函数与某个类型相关联了。

self 属性

类型的每一个实例都会有一个隐含属性叫做self,self完全等同于实例本身。你可以在一个 实例的实例方法中使用这个隐含的self属性来引用当前实例。

上例的increment方法还可以写成

func increment (){
	self.count+=1;
}

实际上,你不必在你的代码里面经常写self。不论何时,只要在一个方法中使用一个已知的属性或者方法名称,如果你没有明确地写 self,Swift 假定你是指当前实例的属性或者方法。这种假定在上面的 Counter 中已经示范了:Counter 中的三个实例方法中都使用的是 count(而不是 self.count)。

使用这条规则的主要场景是实例方法的某个参数名称与实例的某个属性名称相同的时候。在这种情况下,参数名称享有优先权,并且在引用属性时必须使用一种更严格的方式。这时你可以使用 self 属性来区分参数名称和属性名称。

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

struct Point {
    var x = 0.0,y=0.0;
    func isToTheRightOf(by x:Double)-> Bool{
        return self.x>x;
    }
}

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

if somePoint.isToTheRightOf(by: 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

如果不使用 self 前缀,Swift会认为 x 的两个用法都引用了名为 x 的方法参数。

在实例方法中修改值类型

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

但是,如果你确实需要在某一个热定的方法中修改结构体或者枚举的属性,你可以为这个方法选择一个可变(mutating)行为,然后就可以从其方法内部改变它的属性值;并且这个方法做的任何改变都会在方法执行结束时写回到原始结构中。方法还可以给它隐含的self属性赋予一个全新的实例,这个新实例在方法结束时会替换现存在实例。

要使用可变方法,将关键字mutating放到方法func关键字之前就可以了:

struct Point {
    var x  = 0.0 , y = 0.0;
    mutating func moveBy(x deltax:Double , y deltay:Double){
        x += deltax;
        y += deltay;
    }
}

var some_point = Point (x: 1.0, y: 1.0)
some_point.moveBy(x: 2.0, y: 3.0)
print("The point is now at (\(some_point.x),\(some_point.y))")

//The point is now at (3.0,4.0)

上面的 Point 结构体定义了一个可变方法 moveBy(x:y :) 来移动 Point 实例到给定的位置。该方法被调用时修改了这个点,而不是返回一个新的点。方法定义时加上了 mutating 关键字,从而允许修改属性。

注意,不能在结构体类型的常量(a constant of structure type)上调用可变方法,因为其属性不能被改变,即使属性是变量属性,详情参见 常量结构体的存储属性:

let fixedPoint = Point(x: 3.0, y: 3.0)
fixedPoint.moveBy(x: 2.0, y: 3.0)
//Cannot use mutating member on immutable value: 'fixedPoint' is a 'let' constan

在可变方法中给 self 赋值

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

struct Point {
    var x = 0.0 , y = 0.0;
    mutating func moveBy(x deltax: Double , y deltay: Double){
        self = Point (x: x+deltax, y: y+deltay)
    }
}

新版的可变方法 moveBy(x:y:) 创建了一个新的结构体实例,它的 x y 的值都被设定为目标值。调用这个版本的方法和调用上个版本的最终结果是一样的。

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

enum TriStateSwitch{
    case off , low , heigh
    mutating func next(){
        switch self {
        case .off:
            self = .low
        case .low:
            self = .heigh
        default:
            self = .off
        }
    }
}

var over_light  = TriStateSwitch.low
over_light.next()
//over_light.height
over_light.next()
//over_light.off

上面的例子中定义了一个三态切换的枚举。每次调用 next() 方法时,开关在不同的电源状态(off, low, high)之间循环切换。

类型方法

实例方法是被某个类型的实例调用的方法。你也可以定义在类型本身上调用的方法,这种方法就叫做类型方法。在方法的func 关键字之前加上关键字 static,来指定类型方法。类还可以用关键字 class 来指定,从而允许子类重写父类该方法的实现。

注意:在 Objective-C 中,你只能为 Objective-C 的类类型(classes)定义类型方法(type-level methods)。在 Swif 中,你可以为所有的类、结构体和枚举定义类型方法。每一个类型方法都被它所支持的类型显式包含。

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

class SomeClass {
    class func someTypeMethod() {
        // 在这里实现类型方法
    }
}

SomeClass.someTypeMethod()

在类型方法的方法体(body)中,self 属性指向这个类型本身,而不是类型的某个实例。这意味着你可以用 self 来消除类型属性和类型方法参数之间的歧义(类似于我们在前面处理实例属性和实例方法参数时做的那样)。

一般来说,在类型方法的方法体中,任何未限定的方法和属性名称,可以被本类中其他的类型方法和类型属性引用。一个类型方法可以直接通过类型方法的名称调用本类中的其它类型方法,而无需在方法名称前面加上类型名称。类似地,在结构体和枚举中,也能够直接通过类型属性的名称访问本类中的类型属性,而不需要前面加上类型名称。

下面的例子定义了一个名为 LevelTracker结构体。它监测玩家的游戏发展情况(游戏的不同层次或阶段)。这是一个单人游戏,但也可以存储多个玩家在同一设备上的游戏信息。

游戏初始时,所有的游戏等级(除了等级 1)都被锁定。每次有玩家完成一个等级,这个等级就对这个设备上的所有玩家解锁。LevelTracker 结构体用类型属性和方法监测游戏的哪个等级已经被解锁。它还监测每个玩家的当前等级。

struct LevelTracker{
    static var heghest_unlocked_level = 1;
    var current_level = 1;
    
    static func unlock(_ level:Int){
        if level > heghest_unlocked_level{
            heghest_unlocked_level  = level
        }
    }
    
    static func isUnlocked(_ level : Int)-> Bool{
        return level<=heghest_unlocked_level
    }
    
    @discardableResult
    mutating func advance(to level: Int)-> Bool{
        if LevelTracker.isUnlocked(level){
            current_level = level;
            return true;
        }else{
            return false;
        }
    }
}

LevelTracker 监测玩家已解锁的最高等级。这个值被存储在类型属性 highest_unlocked_level 中。

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

除了类型属性和类型方法,LevelTracker 还监测每个玩家的进度。它用实例属性 current_level 来监测每个玩家当前的等级。

为了便于管理 current_level属性,LevelTracker 定义了实例方法 advance(to:)。这个方法会在更新 current_level 之前检查所请求的新等级是否已经解锁。advance(to:) 方法返回布尔值以指示是否能够设置 current_level。因为允许在调用 advance(to:) 时候忽略返回值,不会产生编译警告,所以函数被标注为 @discardableResult 属性。

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

class Player {
    var tracker = LevelTracker()
    let player_name:String
    func complete(level:Int){
        LevelTracker.unlock(level+1)
        tracker.advance(to: level+1)
    }
    init(name: String) {
        player_name = name
    }
}

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

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

var playertwo = Player(name: "Holmes")
if playertwo.tracker.advance(to: 6) {
    print("player is now on level 6")
} else {
    print("level 6 has not yet been unlocked")
    print("highest unlocked level is now \(LevelTracker.heghest_unlocked_level)")
}
//level 6 has not yet been unlocked
//highest unlocked level is now 2

发表评论

电子邮件地址不会被公开。 必填项已用*标注