本條目聚焦 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)。required,以確保子類若自訂構造方法便必須覆寫它。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 版本為準。