Swift 面向协议编程基础篇（一）介绍

前言

好久没有写文章了，期末复习周也到了。在复习的同时顺便开了一个专题，面向协议编程，[ 基础篇 ]，[ 进阶篇 ]，[ 实践篇 ]。

介绍

首先，面向对象（OOP）大家并不陌生，苹果的很多框架都是以这种形式进行构建的，但是，苹果很矫情，2015年WWDC来，鼓励使用 Value Type 值类型，也引出了这么一个话题Protocol Oriented Programming 面向协议编程方式。关于值类型和引用类型，可以查看官方文档或者这篇博客[推荐略看一下]

OOP的发展已经很多年了，一直作为一种主流，苹果的框架也是在一层又一层的继承搭建起来的，但是在水果已经在不断地强调使用Protocol了，自然有它的原因所在。

在OOP中，不支持多继承的关系，往往定义一个BaseController，再往里面添加方法，会造成代码很难维护(资料)
因为class是引用类型，所以可能会出现一些引用计数，引用循环等问题，你必须处理好这些问题。
子类继承超类的时候，需要重写很多你并不需要的实例或者方法。

“Instead of using a class, start with a protocol”.

Paste_Image.png

认识Protocol

引用苹果官方文档的说明，Protocol定义一张蓝图，并且能被class,struct,enum 继承。而且，最重要的是支持多继承的关系。

A protocol defines a blueprint of methods, properties, and other requirements ... The protocol can then be adopted by a class, structure, or enumeration.

正好今早学校宠物节🐶，下面我们定义一个Dog的协议。

struct Person {
    var name: String
}
protocol Dog {
    var name: String { get }
    var owner: Person { get }
    var age: Int { get }
}

然后声明一个struct遵循该协议

struct Husky: Dog {
    let name: String // 实例的name不能修改
    let owner: Person 
    var age: Int 
//    不需要init( ) 也不需要override
//    init(name: String, owner: Person, age: Int) {
//        self.name = name
//        self.owner = owner
//        self.age = age
//    }
}

协议的组合，和多继承

我们的狗狗在宠物节是要去参加比赛的，所以我们定义一个Playable的协议

protocol Playable {
    var GameName: String { get }
    func playGame()
}

我们知道在OOP的世界里，是不支持多继承的关系的。Protocol的出现直接修补了这个DrawBack。

我们组合一下两个协议

protocol DogCanPlay: Dog, Playable { }

接下来声明一个struct遵循这个协议，这样这个struct就拥有了这两个协议的所有属性和方法，而且，编译器还会告诉你，你缺少哪个属性，哪个方法没有声明，非常方便。

struct PlayableDog: DogCanPlay {
    var name: String
    var owner: Person
    var age: Int
    func playGame() {
        print("biubiubiu~")
    }
    var GameName: String
}

协议的组合原理也是多继承的关系，上面的代码也可以这么写

struct PlayableDog: Dog, Playable {
    var name: String
    var owner: Person
    var age: Int
    func playGame() {
        print("biubiubiu~")
    }
    var GameName: String
}

协议的扩展

不得不说，自Swift 2.0后，协议扩展【Protocol Extension】的出现，让面向协议编程更加地powerful，强力推荐这个WWDC Session

extension DogCanPlay {
    func playGame() { //  为协议添加默认实现
        print("biubiu~~")
    }
    func loseGame() {   //添加额外方法
        print("😭😭")
    }
}

由于添加了默认实现，struct的定义就可以省去了playGame( )

struct Husky: DogCanPlay {
    var name: String
    var owner: Person
    var age: Int
    var GameName: String
}

实例一个变量试试~

var myDog = Husky(name: "小黄", owner: Person(name: "大东"), age: 4, GameName: "接飞盘")
myDog.playGame() // biubiu~
myDog.loseGame() // 😭😭

协议的多态

我们知道，OOP有多态的特征，在POP里，也支持💪

struct Dalmatian: DogCanPlay {
    var name: String
    var owner: Person
    var age: Int
    var GameName: String
}

建立两个实例

let myDog = Husky(name: "小黄", owner: Person(name: "大东"), age: 4, GameName: "接飞盘")
let otherDog = Dalmatian(name: "达尔马提亚狗", owner: Person(name: "洪**"), age: 4, GameName: "赛跑")

👉👉

var competitionDog: [DogCanPlay] = [myDog, otherDog]
for dog in competitionDog {
    print(dog.name) 
     //小黄
     //达尔马提亚狗
}

总结

基础篇就介绍到这。往后，我会介绍protocol中where语法的使用，还有POP在UIKit的实践。喜欢请点个赞👍
ARC and Memory Management in Swift
Introducing Protocol-Oriented Programming in Swift 3

Think Different

Swift 面向协议编程 基础篇 （一） 介绍

前言

介绍

认识Protocol

协议的组合，和多继承

协议的扩展

协议的多态

总结

推荐阅读更多精彩内容

Swift 面向协议编程基础篇（一）介绍