swift面向协议编程 基础篇(一)介绍

Author Avatar
大朕东 12月 19, 2016

前言

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

介绍

首先,面向对象(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的协议。

1
2
3
4
5
6
7
8
struct Person {
    var name: String
}
protocol Dog {
    var name: String { get }
    var owner: Person { get }
    var age: Int { get }
}

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

1
2
3
4
5
6
7
8
9
10
11
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的协议

1
2
3
4
protocol Playable {
    var GameName: String { get }
    func playGame()
}

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

我们组合一下两个协议

1
protocol DogCanPlay: Dog, Playable { }

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

1
2
3
4
5
6
7
8
9
struct PlayableDog: DogCanPlay {
    var name: String
    var owner: Person
    var age: Int
    func playGame() {
        print("biubiubiu~")
    }
    var GameName: String
}

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

1
2
3
4
5
6
7
8
9
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

1
2
3
4
5
6
7
8
extension DogCanPlay {
func playGame() { // 为协议添加默认实现
        print("biubiu~~")
    }
    func loseGame() { //添加额外方法
        print("😭😭")
    }
}

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

1
2
3
4
5
6
struct Husky: DogCanPlay {
    var name: String
    var owner: Person
    var age: Int
    var GameName: String
}

实例一个变量试试~

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

协议的多态

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

1
2
3
4
5
6
struct Dalmatian: DogCanPlay {
    var name: String
    var owner: Person
    var age: Int
    var GameName: String
}

建立两个实例

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

👉👉

1
2
3
4
5
6
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