Swift基础语法（九）协议和元类型

您是不是想找：协议书范本协议离婚的程序怎么走协议书怎样写才有法律效力协议书怎么写协议离婚的协议书怎么写协议离婚怎么离最快协议书有法律效力吗协议离婚可以不用等30天冷静期吗协议离婚协议书范本通用版

Swift基础学习文章汇总

本文主要介绍了Swift中协议的使用以及几个常见协议，还有类型判断(is)和强转(as)的使用和元类型

主要内容：

协议的使用
常见协议
类型判断和强转
元类型

1. 协议的使用

协议可以用来定义方法、属性、下标的声明，但是只有声明没有实现。协议可以被枚举、结构体、类遵守（多个协议之间用逗号隔开）

1.1 基本定义

代码：

/*
 1、基本定义
 提供方法、计算属性、下标
 */
protocol Drawable {
    func draw()
    var x: Int { get set }
    var y: Int { get }
    subscript(index: Int) -> Int {get set}
}

说明：

协议只能定义，不能有任何的实现
协议中定义方法时不能有默认参数值，因为协议没有任何实现
默认情况下，协议中定义的内容必须全部实现

1.2 关键字

static:
代码：

/*
 2、关键字
 */
//static 可以看到类中可以使用static也可以使用class，struct只能使用static
protocol Drawable2 {
    static func draw()
}

class Person1 : Drawable2 {
    class func draw(){
        print("Person1 draw")
    }
}
class Person2 : Drawable2 {
    static func draw() {
        print("Person2 draw")
    }
}

struct Person3 : Drawable2 {
    static func draw() {
        print("Person3 draw")
    }
}

Person1.draw()
Person2.draw()
Person3.draw()

说明：

为了保证通用，协议中必须用static定义类型方法、类型属性、类型下标
因为协议可以被枚举、结构体、类遵守，而class只能在类中使用，所以必须使用static
当然遵守该协议的类的该类型方法依然可以使用class

mutating
代码：

//mutating 类本身就可以进行修改，不需要mutating标记，结构体需要使用mutating标记
protocol Drawable3 {
    mutating func draw()
}

class Size: Drawable3 {
    var width: Int = 0
    func draw() {
        width = 10
    }
}
struct Point : Drawable3 {
    var x: Int = 0
    mutating func draw() {
        x = 10
    }
}

说明：

同样，只有将协议中的实例方法标记为mutating才允许结构体在该方法中修改存储属性值

1.3 属性

代码：

/*
 3、属性
 协议中的属性需要指明是否可读可写，类在实现时只要能够实现可读可写就行，可以是计算属性也可以是存储属性
 */
protocol Drawable4 {
    func draw()
    var x: Int { get set}
    var y: Int { get }
    subscript(index: Int) -> Int { get set }
}

class Person31: Drawable4 {
    var x: Int = 0
    let y: Int = 0
    func draw() {
        print("Person31 draw")
    }
    subscript(index: Int) -> Int {
        set { }
        get { index }
    }
}

class Person32: Drawable4 {
    var x: Int {
        get { 0 }
        set { }
    }
    var y: Int { 0 }
    func draw() {
        print("Person32 draw")
    }
    subscript(index: Int) -> Int {
        set { }
        get { index }
    }
}

说明：

这里的属性并没有说明是存储属性还是计算属性，只是说明可读可写
可读可写的属性，既可以是存储属性，也可以是计算属性
这里对于x和y都有两种实现方式，可能是存储属性可能是计算属性
协议中定义属性时必须用var属性，因为无法预知它是存储属性还是计算属性
实现协议时的属性权限不能小于协议中定义的属性权限，也就是说协议中定义的东西我们必须要实现，在此基础上想要增加实现也是可以的

1.4 init

协议中还可以定义初始化器,遵守该协议的类以及子类都必须实现初始化器，所以需要使用required来修饰。

代码：

/*
 4、init
 Student的init既重写协议又重写父类的init，此时必须同时加上required和override
 */
protocol Livable {
    init(age: Int)
}
class Person41 {
    init(age: Int) {
        print("Person init")
    }
}
class Student: Person41, Livable {
    required override init(age: Int) {
        super.init(age: age)
        print("Student init")
    }
}
//Person init
//Student init
let stu = Student.init(age: 10)

说明：

非final类实现时必须加上required
如果从协议实现的初始化器，刚好是重写了父类的指定初始化器，那么这个初始化必须同时加required、override

init、init?、init!的区别

protocol Livable2 {
    init()
    init?(age: Int)
    init?(no: Int)
}
class Person42: Livable2 {
    required init() {
        print("Person42 init")
    }
    required init?(age: Int) {
        print("Person42 init?")
    }
    required init!(no: Int) {
        print("Person42 init!")
    }
}
let p1 = Person42.init()
let p2 = Person42.init(age: 10)
let p3 = Person42.init(no: 100)
/*
 协议.Person42
 Optional(协议.Person42)
 Optional(协议.Person42)
 */
print(p1.self)
print(p2.self)
print(p3.self)

说明：

协议中定义的init?、init!，可以用init、init?、init!去实现
协议中定义的init，可以用init、init!来实现

1.5 协议的继承

代码：

/*
 5、继承
 */
protocol Runnable {
    func run()
}
protocol Livable : Runnable {
    func breath()
}
class Person : Livable {
    func breath() {}
    func run() {}
}

1.5 协议的组合

代码：

/*
 6、协议组合
 */
protocol Livable6 {}
protocol Runnable6 {}
class Person6 {}

// 1、接收Person或者其子类的实例
func fn0(obj: Person6) {}
// 2、接收遵守Livable协议的实例
func fn1(obj: Livable6) {}
// 3、接收同时遵守Livable、Runnable协议的实例
func fn2(obj: Livable6 & Runnable6) {}
// 4、接收同时遵守Livable、Runnable协议、并且是Person或者其子类的实例
func fn3(obj: Person6 & Livable6 & Runnable6) {}

//5、也可以直接定义一下使用
typealias RealPerson = Person6 & Livable6 & Runnable6
// 接收同时遵守Livable、Runnable协议、并且是Person或者其子类的实例
func fn4(obj: RealPerson) {}

说明：

协议可以组合起来遵守，和其他语言的差不多
但是要注意写法，遵守协议的实例和类的实例写法是一样的

2. 常见协议

2.1 CaseIterable

代码：

/*
 7、CaseIterable,遍历枚举
 */
enum Season : CaseIterable {
    case spring, summer, autumn, winter
}
let seasons = Season.allCases
print(seasons.count) // 4
for season in seasons {
    print(season)
} // spring summer autumn winter

说明：

让枚举遵守CaseIterable协议，可以实现遍历枚举值

2.2 CustomStringConvertible

代码：

//CustomStringConvertible ，自定义打印字符串
//CustomDebugStringConvertible，打印debug字符串
class Person : CustomStringConvertible, CustomDebugStringConvertible {
    var age = 0
    var description: String { "person_\(age)" }
    var debugDescription: String { "debug_person_\(age)" }
}
var person = Person()
print(person) // person_0
debugPrint(person) // debug_person_0

说明：

遵守CustomStringConvertible、 CustomDebugStringConvertible协议，都可以自定义实例的打印字符串
print调用的是CustomStringConvertible协议的description
debugPrint、po调用的是CustomDebugStringConvertible协议的debugDescription

3. 类型判断和强转

3.1 任意类型认识

包括Any、AnyObject、AnyClass三种，Any表示任意类型，包括枚举、结构体、类、函数类型。AnyObject表示任意的类，AnyClass表示任意类的类型

Any实现

/*
 8、任意类型
 */
var stu81: Any = 10
stu81 = "Jack"
var stu82: AnyObject = person
stu82 = Person42()
var classType: AnyClass = Person.self

说明：

stu的类型是Any，因此可以是数值、也可以是字符串、也可以是对象
AnyObject表示任意的类
AnyClass表示任意类的类型

3.2 类型判断

代码：

/*
 9、类型判断
 */
protocol Runnable9 {
    func run()
}
class Person9 { }
class Student9 : Person9, Runnable9 {
    func run() {
        print("Student run")
    }
    func study() {
        print("Student study")
    }
}
//is
var stu9: Any = 10
print(stu9 is Int) // true
stu9 = "Jack"
print(stu9 is String) // true
stu9 = Student9()
print(stu9 is Person9) // true
print(stu9 is Student9) // true
print(stu9 is Runnable9) // true

说明：

可以看到is可以判断一个变量是否属于某个类型
is后面可以放协议、父类，编译器也是可以判断的

3.3 类型强转

代码：

//as
var stu92: Any = 10
(stu92 as? Student9)?.study() // 返回nil，不会调用study
stu92 = Student9()
(stu92 as? Student9)?.study() // 解包，Student study
(stu92 as! Student9).study() // 自动解包 ，可能会报错 Student study
(stu92 as? Runnable9)?.run() // 解包，Student run

说明：

as用来进行类型强转的
如果可以确定这个类型没有nil，那么可以用as
如果强化失败就会返回nil
如果有可能是nil，那么类型是可选项。就需要用as? 和 as！
我们尽量用as?，这样可以避免报错，如果用as!自动解包的话如果是nil就会报错

4. 元类型

4.1 元类型的认识

代码：
元类型其实就是类的类型

/*
 10、元类型
 */
class Person10 {}
class Student10 : Person10 {}
var perType: Person10.Type = Person10.self//拿到Person10的类型赋值给perType变量
var stuType: Student10.Type = Student10.self
perType = Student10.self//因为是继承关系，所以可以这样赋值
var anyType: AnyObject.Type = Person10.self
anyType = Student10.self//任意类型

public typealias AnyClass = AnyObject.Type
var anyType2: AnyClass = Person10.self
anyType2 = Student10.self
var per = Person10()
var perType2 = type(of: per) // Person.self
print(Person10.self == type(of: per)) // true

说明：

x.Type属于类类型，X.self是类型指针，类型指针赋值给类类型的
这里可以看到Person是类，Person.Type是类的类型
这个type()并不是函数调用
type(of:p)得到的其实就是Person.self。也就是元类型的地址
因此pType的类型是Person.Type。

4.2 元类型应用

这里通过类类型可以同时对类进行处理
代码：

//应用
class Animal { required init() {} }
class Cat : Animal {}
class Dog : Animal {}
class Pig : Animal {}

func create(_ clses: [Animal.Type]) -> [Animal] {
    var arr = [Animal]()
    for cls in clses {
        arr.append(cls.init())
    }
    return arr
}

print(create([Cat.self, Dog.self, Pig.self]))

4.3 Self关键字

Self表示当前类型，self表示当前对象，需要注意区分
代码：

protocol Runnable {
    func test() -> Self
}
class Person : Runnable {
    required init() {}
    func test() -> Self { type(of: self).init() }
}
class Student : Person {}

说明：
1、因继承关系中都可以使用，必须使用required
2、返回类型为了在继承中匹配使用Self
3、type(of: self).init()这种方式也是为了继承中匹配类型