/**
1.协议的语法
2.属性要求
3.方法要求
4.突变方法要求
5.协议类型
6.委托代理模式
7.在扩展中添加协议成员
8.通过延展补充协议声明
9.集合中的协议类型
10.协议的继承
11.协议合成
12.检验协议的一致性
13.可选协议要求
Protocol(协议)用于统一方法和属性的名称,而不实现任何功能。协议能够被类、枚举、结构体实现,满足协议要求的类,枚举,结构体被称为协议的遵循者
遵循者需要提供协议指定的成员,如属性,方法,操作符,下标等
*/
//协议语法
/**
协议的定义与类、结构体、枚举的定义非常相似
protocol SomeProtocol {
// 协议内容
}
在类,结构体,枚举的名称后加上协议名称,中间以冒号(:)分隔即可实现协议;实现多个协议是,各协议之间用逗号(,)分隔
struct SomeStructure: FirstProtocol, AnotherProtocol
{
// 结构体内容
}
当某个类含有父类的同时并实现了协议,应当把父类放在所有的协议之前
class SomeClass: SomeSuperClass, FirstProtocol,
AnotherProtocol {
// 类的内容
}
*/
//属性要求
/**
协议能够要求其遵循者必须含有一些特定名称和类型的实例属性(instance property)或类属性(type property),也能够要求属性的(设置权限)settable和(访问权限)gettable,但它不要求属性是存储型属性(stored property)还是计算属性(calculate property)
通常前置var关键字将属性声明为变量。在属性声明后写上{get set}表示属性为可读写的。{get}用来表示属性为可读的。即使你为可读属性实现了setter方法,它也不会出错
protocol SomeProtocol {
var musBeSettable : Int { get set }
var doesNotNeedToBeSettable: Int { get }
}
用类来实现协议时,使用class关键字来表示该属性为类成员,用结构体或枚举实现协议时,则使用static关键字来表示
protocol AnotherProtocol {
class var someTypeProperty: Int { get set }
}
*/
protocol FullyNamed {
var fullName: String { get };
}
struct Person: FullyNamed {
var fullName: String;
}
let john = Person(fullName: "john mike");
/**
FullyNamed协议含有fullName属性,因此其遵循者必须有一个名为fullName,类型为String的可读属性
*/
print(john.fullName);
class Starship: FullyNamed {
var prefix: String?;
var name: String;
init(name: String, prefix: String? = nil) {
self.name = name;
self.prefix = prefix;
}
var fullName: String {
return (prefix != nil ? prefix! + " " : " ") + name;
}
}
var ncc1701 = Starship(name: "Enterprise", prefix: "USS");
/**
Starship类将fullName实现为可读的计算型属性。它的每一个实例都有一个名为name的必备属性和一个名为prefix的可选属性。当prefix存在时,将prefix插入到name之前来为Starship构建fullName
*/
print(ncc1701.fullName);
//方法要求
/**
协议能够要求其遵循着必备某些特定的实例方法和类方法。协议方法的声明与普通方法声明相似,但它不需要方法内容
协议方法支持变长参数(variadic parameter),不支持默认参数(default parameter)
前置class关键字表示协议中的成员为类成员,当协议用于被枚举或结构体遵循时,则使用static关键字
protocol SomeProtocol {
class func someTypeMethod()
}
*/
protocol RandomNumberGenerator {
func random() -> Double;
}
class LinearCongruentialGenerator: RandomNumberGenerator {
var lastRandom = 42.0;
let m = 139968.0;
let a = 3877.0;
let c = 29573.0;
func random() -> Double {
lastRandom = ((lastRandom * a + c) % m);
return lastRandom / m;
}
}
let generator = LinearCongruentialGenerator();
print(generator.random());
print(generator.random());
//突变方法要求
/**
能在方法或函数内部改变实例类型的方法称为突变方法。在值类型中的函数前缀加上mutating关键字来表示该函数允许改变该实例和其属性的类型。
类中的成员为引用类型,可以方便修改实例及其属性的值而无需改变类型,而结构体和枚举中的成员为值类型,修改变量的值就相当于修改变量的类型,而swift默认不允许修改类型,因此需要前置mutating关键字用来表示该函数中能够修改类型
在class实现协议中的mutating方法时,不用写mutating关键字,用结构体,枚举实现协议中的mutating方法时,必须写mnutating关键字
*/
protocol Togglable {
mutating func toggle();
}
enum OnOffSwitch: Togglable {
case Off, On;
mutating func toggle() {
switch self {
case .Off:
self = On;
case .On:
self = Off;
}
}
}
var lightSwitch = OnOffSwitch.Off;
lightSwitch.toggle();
print(lightSwitch.hashValue);
//协议类型
/**
协议本身不实现任何功能,但可以将它当做类型来使用
1.作为函数,方法或构造器中的参数类型,返回值类型
2.作为常量,变量,属性的类型
3.作为数组,字典或其他容器中的元素类型
协议类型应与其他类型(Int, Double, String)的写法相同,使用驼峰式
*/
class Dice {
let sides: Int;
let generator: RandomNumberGenerator;
init(sides: Int, generator: RandomNumberGenerator) {
self.sides = sides;
self.generator = generator;
}
func roll() -> Int {
return Int(generator.random() * Double(sides)) + 1;
}
}
//var d6 = Dice(sides: 6, generator: LinearCongruentialGenerator());
//for _ in 1...5 {
// print("Random dice roll is \(d6.roll())");
//}
//委托是一种设计模式,它允许类或结构体将一些需要他们负责的功能交由(委托)给其他的类型
/**
委托模式的实现很简单,定义协议来封装那些需要被委托的函数和方法,使其遵循者拥有这些被委托的函数方法
委托模式可以用来响应特定的动作或接受外部数据源提供的数据,而无需要知道外部数据源的类型
*/
protocol DiceGame {
var dice: Dice { get };
func play();
}
protocol DiceGameDelegate {
func gameDidStart(game: DiceGame);
func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int);
func gameDidEnd(game: DiceGame);
}
class SnakesAndLadders: DiceGame {
let finalSquare = 25;
let dice = Dice(sides: 6 , generator: LinearCongruentialGenerator());
var square = 0;
var board: [Int];
init() {
board = [Int](count: finalSquare + 1, repeatedValue: 0);
board[3] = 8;
board[6] = 11;
board[9] = 9;
board[10] = 2;
board[14] = -10;
board[19] = -11;
board[22] = -2;
board[24] = -8;
}
var delegate: DiceGameDelegate?
func play() {
square = 0;
delegate?.gameDidStart(self);
gameLoop: while square != finalSquare {
let diceRoll = dice.roll();
delegate?.game(self,didStartNewTurnWithDiceRoll: diceRoll);
switch square + diceRoll {
case finalSquare:
break gameLoop;
case let newSquare where newSquare > finalSquare:
continue gameLoop;
default:
square += diceRoll;
square += board[square];
}
}
delegate?.gameDidEnd(self);
}
}
class DiceGameTracker: DiceGameDelegate {
var numberOfTurns = 0;
func gameDidStart(game: DiceGame) {
numberOfTurns = 0;
if game is SnakesAndLadders {
print("Started a new game of snakes and Ladders");
}
print("the game is using a \(game.dice.sides) - sided dice");
}
func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int) {
numberOfTurns++;
print("Rolled a \(diceRoll)");
}
func gameDidEnd(game: DiceGame) {
print("the game lasted for \(numberOfTurns) turns");
}
}
let tracker = DiceGameTracker();
let game = SnakesAndLadders();
game.delegate = tracker;
game.play();
//扩展中添加协议成员
/**
即便无法修改源代码,依然可以通过扩展(Extension)来扩充已存在类型。扩展可以为已存在的类型添加属性,方法,下标,协议等成员
通过扩展为已存在的类型遵循协议时,该类型的所有实例也会随之添加协议中的方法
*/
protocol TextRepresenTable {
func asText() -> String;
}
extension Dice: TextRepresenTable {
func asText() -> String {
return "A \(sides)-sided dice";
}
}
let d12 = Dice(sides: 12, generator: LinearCongruentialGenerator());
print(d12.asText());
extension SnakesAndLadders: TextRepresenTable {
func asText() -> String {
return "A game of Snakes and Ladders with \(finalSquare) square";
}
}
print(game.asText());
//通过延展补充协议声明
/**
当一个类型已经实现了协议中的所有要求,却没有声明时,可以通过扩展来补充协议声明
即使满足了协议的所有要求,类型也不会自动转变,因此必须为它做出明显的协议声明
*/
struct Hamster {
var name: String;
func asText() -> String {
return "A hamster named \(name)";
}
}
extension Hamster: TextRepresenTable {};
let simonTheHamster = Hamster(name: "Simon");
let somethingTextRepresentable: TextRepresenTable = simonTheHamster;
print(somethingTextRepresentable.asText());
//集合中的协议类型
/**
协议类型可以被集合使用,表示集合中的元素均为协议类型
*/
let things: [TextRepresenTable] = [game,d12,simonTheHamster];
for thing in things {
//thing被当做TextRepresenTable类型而不是Dice,DiceGame,Hamster等类型,因此只能调用asText()方法
print("===\(thing.asText())===");
}
//协议的继承
/**
协议能够继承一到多个其他协议。语法与类的继承相似,多个协议间用逗号(,)分隔
protocol InheritingProtocol: SomeProtocol,
AnotherProtocol {
// 协议定义
}
*/
protocol PrettyTextRepresentable: TextRepresenTable {
func asPrettyText() -> String;
}
//遵循PrettyTextRepresentable协议的同时,也需要遵循TextRepresenTable的协议
extension SnakesAndLadders: PrettyTextRepresentable {
func asPrettyText() -> String {
var output = asText() + ":\n";
for index in 1...finalSquare {
switch board[index] {
case let ladder where ladder > 0:
output += "正三角";
case let snake where snake < 0:
output += "倒三角";
default:
output += "圆圈";
}
}
return output;
}
}
print(game.asPrettyText());
//协议合成
/**
一个协议可由多个协议采用protocol<SomeProtocol,AnptherProtocol>这样的格式进行组合,称为协议合成(protocol composition)。
*/
protocol Named {
var name: String { get };
}
protocol Aged {
var age: Int { get };
}
struct Person2: Named, Aged {
var name: String;
var age: Int;
}
/**
Named协议包含string类型的name属性,Aged协议包含Int类型的age属性,person2结构体遵循了这两个协议。
wishHappyBirthday函数的形参celebrator的类型为protocol<Named,Aged>。可以传入任意遵循这两个协议的类型的实例
协议合成并不会生成一个新协议类型,而是将多个协议合成为一个临时的协议,超出范围后立即失效
*/
func wishHappyBirthday(celebrator: protocol<Named,Aged>) {
print("Happy birthday \(celebrator.name), you're \(celebrator.age)!");
}
let birthdayPerson = Person2(name: "SB", age: 20);
wishHappyBirthday(birthdayPerson);
//检验协议的一致性
/**
使用is检验协议一致性,使用as将协议类型向下转换(downcast)为的其他协议类型。检验与转换的语法和之前相同
1.is操作符用来检查视力是否遵循了某个协议
2.as?返回一个值,当实例遵循协议时,返回该协议类型;否则返回nil
3.as用以强制向下转换型
@objc用来表示协议是可选的,也可以用来表示暴露给OC的代码,此外,@objc型协议只有对类有效,因此只能在类中检查协议的一致性
*/
protocol HasArea {
var area: Double { get };
}
class Circle: HasArea {
let pi = 3.1415927;
var radius: Double;
var area: Double = 0;
init(radius: Double) {
self.radius = radius;
}
}
class Country: HasArea {
var area: Double;
init(area: Double) {
self.area = area;
}
}
class Animal {
var legs: Int;
init(legs: Int) {
self.legs = legs;
}
}
let objects: [AnyObject] = [Circle(radius: 2.0), Country(area: 343.23), Animal(legs: 4)];
for obj in objects {
/**
当数组中的元素遵循HasArea协议时,通过as?操作符将其可选绑定(optional binding)到objectWithArea常量上
objects数组中元素的类型并不会因为向下转型而改变,当它们被赋值给objectWithArea时只被视为HasArea类型,因此只有area属性能够被访问
*/
if let objectWithArea = obj as? HasArea {
print("Area is \(objectWithArea.area)");
}else{
print("Something that doesn't have an area");
}
}
//可选协议要求
/**
可选协议含有可选成员,其遵循者可以选择是否实现这些成员。在协议中使用@optional关键字作为前缀来定义可选成员
可选协议在调用时使用可选链
可选协议只能在含有@objc前缀的协议中生效
*/
@objc protocol CounterDataSource {
optional func incrementForCount(count: Int) -> Int;
optional var fixedIncrement: Int { get };
}
class Counter {
var count = 0;
var dataSource: CounterDataSource?;
func increment() {
if let amount = dataSource?.incrementForCount?(count) {
count += amount;
}else if let amount = dataSource?.fixedIncrement {
count += amount;
}
}
}
class ThreeSource: CounterDataSource {
@objc let fixedIncrement = 3;
}
var counter = Counter();
counter.dataSource = ThreeSource();
for _ in 1...4 {
counter.increment();
print(counter.count);
}
class TowardsZeroSource: CounterDataSource {
@objc func incrementForCount(count: Int) -> Int {
if count == 0 {
return 0;
} else if count < 0 {
return 1;
} else {
return -1;
}
}
}
counter.count = -4;
counter.dataSource = TowardsZeroSource();
for _ in 1...5 {
counter.increment();
print(counter.count);
}