Swift 扩展

在 Swift 中，我们可以为现有的类型添加新功能。我们可以通过使用 **扩展** 来实现这一点。

我们使用 `extension` 关键字来声明一个扩展。例如，

// class definition 
class Temperature {
  ...
}

// extension of Temperature class
extension Temperature {

  // add new methods 
} 

在这里，我们使用 `extension` 关键字创建了一个 `Temperature` 类的扩展。

现在，在扩展内部，我们可以为 `Temperature` 添加新功能。

示例：Swift 扩展

// class definition
class Temperature {
  var celsius: Double = 0

  func setTemperature(celsius: Double) {
    self.celsius = celsius
    print("Celsius:", celsius)
  }
}

// declare an extension
extension Temperature {

  // add a new method to Temperature class
  func convert() {
    var fahrenheit = (celsius * 1.8) + 32
    print("Fahrenheit:", fahrenheit)
  }
}

// class initialization
let temp1 = Temperature()
temp1.setTemperature(celsius: 16)

// access extension method using class object
temp1.convert()

输出

Celsius: 16.0
Fahrenheit: 60.8

在上面的示例中，我们创建了 `Temperature` 类的扩展。

extension Temperature {

  // add a new method to Temperature class
  func convert() {
    var fahrenheit = (celsius * 1.8) + 32
    ...
  }

此扩展为 `Temperature` 添加了以下功能：

• `convert()` - 一个将温度从摄氏度转换为华氏度的方法。
• fahrenheit - 在 `convert()` 中声明的一个变量，用于存储转换结果。

然后，我们创建了一个名为 temp1 的 `Temperature` 对象，并使用它来访问在 `extension` 中创建的方法。

// access extension method using class object
temp1.convert()

**注意：** 类内部定义的属性（如 celsius）也可以在扩展中使用。

扩展中的计算属性

在 Swift 中，我们不能在扩展中添加 **存储属性**。例如，

extension Circle {
  // stored property
  var radius: Int // error code
}

但是，Swift 允许我们在扩展中添加计算属性。例如，

extension Circle {

  // computed property
  var area: Double {
    ...
  }
}

这里，area 是在 `extension` 主体中定义的计算属性。

示例：扩展中的计算属性

class Circle {
  var radius: Double = 0
}

extension Circle {
  // define computed property 
  var area: Double {
    return 3.14 * radius * radius
  }
}

let circle1 = Circle()
circle1.radius = 5
print("Area:", circle1.area)

输出

Area: 78.5

在上面的示例中，我们创建了一个 `Circle` 类的 `extension`，并在其中定义了一个名为 area 的计算属性。

此属性根据 `radius` 的值计算圆的面积。

var area: Double {
  return 3.14 * radius * radius
}

协议扩展

在 Swift 中，我们也可以扩展 *协议*。例如，

// protocol definition
protocol Brake {
  func applyBrake()
}

// extend protocol
extension Brake {
  func applyBrake() {
    print("Brake Applied")
  }
}

// define class that conforms Brake
class Car: Brake {
  var speed: Int = 0
}

let car1 = Car()
car1.speed = 61
print("Speed:", car1.speed)

// access extended protocol
car1.applyBrake()

输出

Speed: 61
Brake Applied

在上面的示例中，我们创建了 `Brake` 协议，该协议定义了 `applyBrake()` 函数。

我们扩展了 `Brake` 协议，并在其中定义了 `applyBrake()` 函数的主体。

// extend protocol
extension Brake {
  func applyBrake() {
    print("Brake Applied")
  }
}

现在，由于 `Car` 类符合 `Brake` 协议，

class Car: Brake {
  ...
}

我们可以通过 car1 对象访问扩展的协议。

// access extended protocol
car1.applyBrake()