您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發綜合

Swift 語言核心筆記(三):協議、擴充套件、列舉與結構體

編輯:iOS 開發綜合

本條目聚焦 Swift 中四個彼此緊密相連的語言特性:協議(protocol)、擴充套件(extension)、列舉(enum)與結構體(struct)。理解它們的關鍵在於一件事——在 Swift 裡,這些語法並不是類的附屬品,而是與類並肩的一等公民。

協議:對行為的約束

協議約束的是「行為」,而非「繼承血緣」。與 Objective-C 類似,Swift 協議可以宣告屬性與方法(Objective-C 之所以能宣告屬性,是因為 @property 的本質就是 setter 與 getter)。但 Swift 走得更遠:協議不只適用於類,同樣可以用在列舉與結構體上。若確實只想讓某個協議被類採用,可在宣告時加上 class 關鍵字來限制範圍。

protocol Named {
    // 定義一個執行個體屬性
    var name: String { get set }
    // 定義一個型別屬性
    static var className: String { get }
    // 定義構造方法
    init(name: String)
    // 定義一個執行個體方法
    func showName()
    // 定義一個型別方法
    static func showClassName()
}

protocol Scored {
    var score: Double { get set }
}

// Person 遵從 Named 協議
class Person: Named {
    // 注意:協議無法得知 name 究竟是儲存屬性還是計算屬性,此處以儲存屬性實作
    var name: String
    var age: Int = 0

    static var className: String {
        return "Person"
    }

    // 協議中規定的構造方法,必須以 required 修飾(除非類被 final 修飾)
    required init(name: String) {
        self.name = name
    }

    func showName() {
        print("name=\(name)")
    }

    static func showClassName() {
        print("Class name is \"Person\"")
    }
}

// Student 繼承 Person 並實作 Scored 協議
class Student: Person, Scored {
    var score: Double = 0.0

    init(name: String, score: Double) {
        self.score = score
        super.init(name: name)
    }

    // 既然自訂了構造方法,就必須實作協議要求的構造方法
    required init(name: String) {
        super.init(name: name)
    }

    func test() {
        print("\(self.name) is testing.")
    }
}

var p = Person(name: "Kenshin Cui")
p.showName()                    // name=Kenshin Cui
print("className=\(Person.className)")   // className=Person
Person.showClassName()          // Class name is "Person"
p.age = 28

// 雖然靜態型別是 Named,執行期仍能正確解析(多型)
// 但編譯器並不知道 s 有 test 方法,呼叫 test() 會報錯
var s: Named = Student(name: "Kaoru", score: 100.0)
s.showName()

// 要求參數同時實作兩個協議
func showMessage(stu: protocol<Named, Scored>) {
    print("name=\(stu.name), score=\(stu.score)")
}

var s2 = Student(name: "Tom", score: 99.0)
showMessage(s2)                 // name=Tom, score=99.0

// 檢測協議
let b1 = s is Scored            // 判斷 s 是否遵從 Scored
if b1 {
    print("s has score property.")
}

// 型別轉化
if let s3 = s as? Scored {
    print("s3' score is \(s3.score)")   // 100.0
}

let s4 = s as! Scored           // 強制轉換,失敗則執行期報錯
print("s4' score is \(s4.score)")       // 100.0

幾個容易忽略的細節:

  • 協議可以指定屬性的讀寫,但即使協議規定唯讀,實作時仍可寫成可讀寫。
  • 協議能約定屬性是執行個體還是型別、可讀寫還是唯讀,卻無法約束它究竟是儲存屬性還是計算屬性。
  • 協議中的型別屬性與型別方法以 static 修飾(而在類中實作型別成員時可用 class)。
  • 協議方法支援可變參數,但不支援預設參數。
  • 協議約定的構造方法,在非 final 類中實作時必須加上 required,以確保子類若自訂構造方法便必須覆寫它。
  • 一個協議可以繼承多個協議;一個類只能繼承一個類,但可以實作多個協議。
  • 協議本身就是一種型別,這正是多型的體現;還可以把多個協議合成起來約束單一參數。

擴充套件:比 Objective-C 的分類強大得多

Swift 的擴充套件對應 Objective-C 的分類(在其他高階語言中,人們更常稱之為 extension)。差別在於適用範圍:擴充套件不只能用於類,還能擴充協議、列舉與結構體;內容也不侷限於方法,還包括便利構造方法、計算屬性、下標腳本與巢狀型別。

class Person {
    var firstName: String, lastName: String
    var age: Int = 0

    var fullName: String {
        get {
            return firstName + " " + lastName
        }
    }

    init(firstName: String, lastName: String) {
        self.firstName = firstName
        self.lastName = lastName
    }

    func showMessage() {
        print("name=\(fullName), age=\(age)")
    }
}

extension Person {
    // 只能擴充便利構造方法,不能擴充指定構造方法
    convenience init() {
        self.init(firstName: "", lastName: "")
    }

    // 只能擴充計算屬性,無法擴充儲存屬性
    var personInfo: String {
        return "firstName=\(firstName), lastName=\(lastName), age=\(age)"
    }

    // 擴充執行個體方法
    func sayHello() {
        print("hello world.")
    }

    // 巢狀型別
    enum SkinColor {
        case Yellow, White, Black
    }

    // 擴充型別方法
    static func skin() -> [SkinColor] {
        return [.Yellow, .White, .Black]
    }
}

var p = Person()
p.firstName = "Kenshin"
p.lastName = "Cui"
p.age = 28
print(p.personInfo)     // firstName=Kenshin, lastName=Cui, age=28
p.sayHello()            // hello world.
Person.skin()

結構體:與類平起平坐,本質卻是值型別

在多數語言中,結構體是類的簡化版,內部只能放一些簡單成員。Swift 則把兩者拉得極近:結構體一樣能定義屬性、方法、下標腳本、構造方法,支援擴充套件,也能實作協議。但底層有個無法迴避的本質差異——類是參考型別,結構體是值型別。

struct Person {
    var firstName: String
    var lastName: String

    var fullName: String {
        return firstName + " " + lastName
    }

    var age: Int = 0

    // 若定義了構造方法,系統就不再自動生成預設的逐一構造方法
    func showMessage() {
        print("firstName=\(firstName), lastName=\(lastName), age=\(age)")
    }

    // 類中的型別方法用 class 修飾,結構體則用 static
    static func showStructName() {
        print("Struct name is \"Person\"")
    }
}

// 未自訂構造方法時,系統會自動生成無參數與全員逐一兩個構造方法
var p = Person(firstName: "Kenshin", lastName: "Cui", age: 28)
print(p.fullName)           // Kenshin Cui
p.showMessage()             // firstName=Kenshin, lastName=Cui, age=28
Person.showStructName()     // Struct name is "Person"

// 結構體是值型別,賦值與傳參時會複製一份
// 因此 p2 改名並不影響 p(若换成類則不然)
var p2 = p
p2.firstName = "Tom"
print(p2.fullName)          // Tom Cui
print(p.fullName)           // Kenshin Cui

補充幾點:

  • 若不自訂構造方法,系統會自動提供無參數構造方法與全員逐一構造方法。
  • 結構體是值型別,因此有構造方法但沒有解構方法,記憶體由系統自動管理,開發者無需過度關注。
  • 類的型別方法用 class 修飾以便子類覆寫;結構體與列舉則用 static。可以這樣記:class 只在類中宣告型別方法或型別計算屬性時使用,其餘情況(結構體、列舉、協議、型別儲存屬性)一律用 static。
  • 類的執行個體慣稱「物件」,而結構體同樣有執行個體,因此本文多以「執行個體」通稱。

列舉:不再只是整型的代名詞

在其他語言裡,列舉的本質就是整型,只是替一堆相關數值取了個有意義的名字。Swift 的列舉不要求成員對應整型值(需要時當然仍可指定),而且型別可以是整型、浮點數、字元或字串。

// Swift 列舉預設沒有對應的整型值
// case 用來宣告新成員,多個成員也可寫在同一行以逗號分隔
enum Season {
    case Spring
    case Summer
    case Autumn
    case Winter
}

var s = Season.Spring
// 一旦型別確定,賦值時可省略型別名稱
s = .Summer

switch s {
case .Spring:
    print("spring")
case .Summer:
    print("summer")
case .Autumn:
    print("autumn")
default:
    print("winter")
}

當然也可以指定原始值(raw value),而且不侷限於整型;但同一個列舉的原始值必須是單一型別。若原始值為整型,會像其他語言一樣自動遞增。

enum Season: Int {
    case Spring = 10   // 其餘成員自動遞增,Summer 即為 11
    case Summer
    case Autumn
    case Winter
}

let summer = Season.Summer
// 以 rawValue 取得原始值
print("summer=\(summer), rawValue=\(summer.rawValue)")

// 也可由原始值反construct列舉,注意回傳的是可選型別
var autumn = Season(rawValue: 12)
if let newAutumn = autumn {
    print("autumn=\(newAutumn), rawValue=\(newAutumn.rawValue)")
}

更有意思的是「相關值」(associated value):一個列舉成員可以攜帶與之關聯的其他型別資料,讓你能在列舉中額外儲存資訊。這在其他語言裡幾乎不可能優雅地做到。要特別區分:原始值必須事先定義、型別統一;相關值則是在建立列舉變數或常數時才指定,且各成員型別可以不同。

enum Color {
    case RGB(String)              // 為簡化示範,這裡用十六進位字串而非三個 Int
    case CMYK(Float, Float, Float, Float)
    case HSB(Int, Int, Int)
}

var red = Color.RGB("#FF0000")
var green = Color.CMYK(0.61, 0.0, 1.0, 0.0)
var blue = Color.HSB(240, 100, 100)

switch red {
case .RGB(let colorStr):
    print("colorStr=\(colorStr)")
case let .CMYK(c, m, y, k):
    print("c=\(c), m=\(m), y=\(y), k=\(k)")
case let .HSB(h, s, b):
    print("h=\(h), s=\(s), b=\(b)")
}

列舉也具備若干類與結構體的特性:計算屬性(含型別屬性,但列舉只能有計算屬性,不能宣告儲存屬性)、構造方法、方法與下標腳本。

enum Season: Int {
    case Spring = 0, Summer, Autumn, Winter

    // 計算屬性
    var tag: Int {
        return self.rawValue
    }

    // 型別屬性
    static var enumName: String {
        return "Season"
    }

    // 可失敗構造方法:以 nil 表示構造失敗
    // 這比用 default 硬塞一個值合理得多,因為呼叫方可能傳入任何字串
    init?(prefix: String) {
        switch prefix.lowercased() {
        case "sp": self = .Spring
        case "su": self = .Summer
        case "au": self = .Autumn
        case "wi": self = .Winter
        default:   return nil
        }
    }

    // 執行個體方法
    func showMessage() {
        print("rawValue=\(self.rawValue)")
    }

    // 型別方法
    static func showEnumName() {
        print("Enum name is \"Season\"")
    }
}

var summer = Season.Summer
print(summer.tag)           // 1
print(Season.enumName)      // Season
Season.showEnumName()       // Enum name is "Season"
summer.showMessage()        // rawValue=1

// 可選綁定,因為構造方法可能回傳 nil
if let spring = Season(prefix: "au") {
    print(spring.tag)       // 2
}

需要留意的是,列舉的構造方法必須保證 self 已有值——正如類的構造方法必須保證所有儲存屬性都有值一樣。

註:本文範例採用早期 Swift 語法(如 println、大写初始的列舉成員),目的是保留原始語法教學脈絡;實際開發請以當前 Swift 版本為準。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved