扩展（Extension）
-
Swift的扩展，优点类似于OC中的分类（Category）
-
扩展可以为枚举、结构体、类、协议添加新功能
- 可以添加方法、计算属性、下标、（便捷）初始化器、嵌套类型、协议等等
-
扩展不能办到的事情（改变内存了结构）
- 不能覆盖原有的功能（OC可以覆盖）
- 不能添加存储属性(改变了内存结构)，不能向已有的属性添加属性观察器
- 不能添加父类
- 不能添加指定初始化器，不能添加反初始化器
计算属性、下标、方法、嵌套类型
extension Double {
// 添加计算属性
var km:Double {self * 1_000.0}
var m:Double {self}
var dm:Double {self / 10.0}
var cm:Double {self / 100.0}
var mm:Double {self / 1_000.0}
}
var d = 100.0
print(d.km) // 100000.0
print(d.m) // 100.0
print(d.dm) // 10.0
// 判断数组的越界行为
extension Array {
subscript(nullable idx:Int) -> Element? {
if (startIndex..<endIndex).contains(idx){
return self[idx]
}
return nil
}
}
print(arr[nullable:10] ?? 0)
extension Int {
func repetitions(task:()-> Void){
for _ in 0..< self {task()}
}
mutating func square() -> Int{
self = self * self
return self
}
enum Kind{ case negative,zero,positive}
var kind : Kind {
switch self {
case 0:return .zero
case let x where x > 0 : return .positive
default:return .negative
}
}
// 获取num的每一位的数字
subscript(digitIndex:Int) ->Int {
var decimalBase = 1
for _ in 0..digitIndex {decimalBase *= 10 }
return (self / decimalBase) % 10
}
}
协议、初始化器
class Person {
var age:Int
vat name :String
init (age:Int,name:String){
self.age = age
self.name = name
}
}
// 扩展协议
extension Person:Equtable {
static func == (left:Person,right:Person) -> Bool {
left.age == right.age && left.name == right.name
}
// 扩展便捷初始化器
convenience init(){
self.init(age:0,name:"")
}
}
- 如果希望自定义初始化器的同时，编译器也能够生成默认初始化器（既能保留之前的初始化器，又能扩展现在的初始化器）
- 可以在扩展中编写自定义初始化器
struct Point {
var x:Int = 0
var y:Int = 0
}
extension Point {
// 指定初始化器和便捷初始化器是类里面的概念
init(_ point:Point){
self.init(x:point.x,y:point.y)
}
}
var p1 = Point()
var p2 = Point(x:10)
var p3 = Point(y:20)
var p4 = Point(x:10,y:20)
var p5 = Point(p4)
- 类遵守协议实现的required初始化器，不能写在扩展中
protocol Runnable {
init(age:Int)
}
class Person{
required init(age:Int){}
}
extension Person : Runnable {
// 类遵守协议实现的required初始化器，不能写在扩展中,必须要写在类里面，要确保
//required init(age:Int){}
}
协议
- 如果一个类型已经实现了协议的的所有要求，但是还没有声明它遵守了这个协议
- 可以通过扩展来让它遵守这个协议
protocol TestProtocol {
func test()
}
class TestClass {
func test(){
print("test")
}
}
extension TestClass : TestProtocol {}
- 编写一个函数，判断一个整数是否为奇数？
func isOdd<T:BinaryInteger>(_ i:T) -> Bool {
i % 2 != 0
}
// 判断一个整数是否为奇数的函数，在必须遵守BinaryInteger，那么扩展协议方法也就实现了此功能
extension BinaryInteger {
func isOdd() -> Bool{self % 2 != 0}
}
print(10.isOdd())
print((-3).isOdd())
- 扩展可以给协议提供默认实现，也间接实现【可选协议】的效果
- 扩展可以给协议扩充「协议中从未声明过的方法」
protocol TestProtocol {
func test1()
}
extension TestProtocol {
// 扩展中给了默认实现，在遵守协议的类，可以不用实现此功能（可选协议）
func test1() {
print("TestProtocol test1")
}
//扩展可以给协议扩充「协议中从未声明过的方法」
func test2(){
print("TestProtocol test2")
}
}
class TestClass : TestProtocol {
//如果类中实现了协议，优先考虑类的方法
//func test1() {print("TestClass test1")}
//func test2() {print("TestClass test2")}
}
var cls = TestClass()
cls.test1() // TestProtocol test1
cls.test2() // TestProtocol test2
var cls2:TestProtocol = TestClass() // 指向了TestProtocol，在调用方法时应该调用TestProtocol 中的方法，及其扩展协议
cls2.test1() // TestProtocol test1
cls2.test2() // TestProtocol test2
//如果类中实现了协议，优先考虑类的方法，这是优先考虑协议的时候，但是协议中可选协议，编译器是不知道，你有没有实现这个可选协议，是还会打印可选协议中的方法
泛型
class Stack<E> {
var elements = [E]()
func push(_ element:E){
elements.append(element)
}
func pop() -> E {elements.removeLast()}
func size() -> Int {elements.count}
}
// 扩展中依然可以使用原类型中的泛型类型
extension Stack {
func top() -> E {elements.last!}
}
// 符合条件才扩展
extension Stack : Equatable Where E :Equatable {
static func === (left:Stack,right:Stack) -> Bool {
left.elements == right.elements
}
}
