协议
协议是方法的集合(计算属性相当于方法)，它可以把看似不相关的对象的公共行为放到一个协议中。
- 作用
- 1.协议表能力: 遵循了协议就意味着具备了某种能力;
- 2.协议表约定: 遵循了协议就一定要实现协议中的方法;
- 3.协议中的角色: 一个类可以遵循多个协议，一个协议也可以被多个类遵循，遵循协议就意味着扮演了某种角色，遵循多个协议就意味着扮演了多种角色.
说明
1.协议中全是抽象概念(只有声明没有实现)，遵循协议的类可以各自对协议中的计算属性和方法给出自己的实现版本，这样当我们面向协议编程时就可以把多态的优势发挥到淋漓尽致了，因此可以写出更灵活通用多代码(符合开闭原则)
2.实现开闭原则最关键有两点:
- 抽象是关键(在设计系统的时候一定要设计好的协议);
- 封装可变性(桥梁模式 － 将不同的可变因素封装到不同的继承结构中)
3.借口隔离原则: 协议中的设计要小而专，切忌大而全
4.协议的设计要高度內聚
比如：定义了一个协议-->飞行，我们知道会飞的有超人、飞机、鸟，而且超人能打架，那么可以通过以下代码进行说明：
/// 飞行能力
protocol Flyable {
func fly()
}
/// 打架能力
protocol Fightable {
func fight()
}
协议的扩展 － 可以在协议的扩展中对协议中的方法给出默认实现
extension Fightable {
func fight() {
print("正在👊")
}
}
协议的继承方式同类的继承一样(协议之间的继承可以是多重继承)
protocol NiuBi: Flyable, Fightable {
func dive()
}
因此:
/// 能够飞行的三种事物
//超人
class Superman: NiuBi {
func fly() {
print("🏃使用超能力飞行.")
}
func fight() {
print("💃正在和😈势力争斗.")
}
func dive() {
print("💃正在潜水.")
}
}
//飞机
class Airplane: Flyable {
func fly() {
print("✈️依靠空气动力学原理飞行.")
}
}
//鸟
class Bird: Flyable {
func fly() {
print("🐦扇动翅膀飞行.")
}
}
创建好协议和类之后就可以创建对象调用它们了:
let x: protocol<Flyable,Fightable> = Superman()
let y: NiuBi = Superman()
// 协议的组合
let array: [protocol<Flyable, Fightable>] = [
//Bird(),
//Superman(),
//Airplane()
]
for obj in array {
obj.fly()
}
依赖倒转原则(面向协议编程)
1.声明变量的类型时应尽可能使用协议类型
2.声明方法参数类型时应尽可能使用协议类型
3.声明方法返回类型时应尽可能使用协议类型
委托回调
有的时候某个对象要做某件事情但其自身又没有能力做这件事，这个时候就可以使用委托回调的编程模式让别的对象来做这件事情
- 实现委托回调的编程模式主要有以下几个步骤：
- 1.设计一个协议(被委托方必须遵循协议才能给别的对象当委托)
- 2.委托方添加一个属性起类型是被委托方
- 3.自己做不了到事情委托给别的对象来完成
内存释放
内存是计算机中重要的部件之一，它是与CPU进行沟通的桥梁。计算机中所有程序的运行都是在内存中进行的，因此内存的性能对计算机的影响非常大。
- 程序员可以使用的内存大致分为五块区域:
- 栈 (stack) - 我们定义的局部变量、临时变量都是放在栈上
- 特点: 小、快
- 堆 (heap) － 我们创建的对象都是放在堆上面的
- 特点: 大、慢
- 静态区 (static area)
- 数据段 － 全局量
- 只读数据段 － 常量
- 代码段 － 函数和方法
- 栈 (stack) - 我们定义的局部变量、临时变量都是放在栈上
以引用类型和值类型为例：
- 类 － 引用类型
- 结构 － 值类型
- 值类型在赋值的时候会在内存进行对象的拷贝
- 引用类型在赋值的时候不会进行对象拷贝，只是增加了一个引用
- 所以我们自己定义新类型时应该优先考虑使用类而不是结构，除非我们要定义的是一种底层的数据结构(保存其他数据的类型)
- 引用类型和值类型的区别还有两点：
- 值类型的结构会自动生成初始化方法
- 结构中的方法在默认情况下不允许修改其中的属性，如果要修改的话，就要加上mutating关键字
例如：
class Student1 {
var name: String
var age: Int
init(name: String, age: Int) {
self.name = name
self.age = age
}
func study(courseName: String) {
print("\(name)正在学习.")
}
}
struct Student2 {
var name: String
var age: Int
func study(courseName: String) {
print("\(name)正在学习.")
}
mutating func getOlder() {
age += 1
}
}
通过调用我们可以明显的看到值类型和引用类型在内存管理上的区别
// 引用类型的类
let stu1 = Student1(name: "道玄", age: 650)
var stu3 = stu1 // 此处内存中仍然只有一个学生对象
stu3.name = "萧逸才"
print(stu1.name)
print(stu1.age)
// 值类型的结构
let stu2 = Student2(name: "田不易", age: 635)
var stu4 = stu2 // 此处内存中会复制一个新的学生对象
stu4.name = "万剑一"
stu4.age = 712
print(stu2.name)
print(stu2.age)
// 在Swift中同名函数只要参数列表不同是可以共存的, 这个叫函数的重载
func changeName(inout name: String) {
name = "陆雪琪"
}
func changeName(stu: Student1) {
stu.name = "青云门"
}
var name = "田灵儿"
changeName(&name)
print(name)
var stu = Student1(name: "焚音谷", age: 2000)
changeName(stu)
print(stu.name)
泛型(generic)
使用泛型让程序中的类型不再是硬代码(写死的东西)
Swift中的类、结构和枚举都可以使用泛型
例如：
数组排序：首先定义一个虚拟类型为T，调用函数时根据传入的参数类型来决定T到底是什么类型的。
特别说明
- T类型要遵循Comparable协议
func bubbleSort<T: Comparable>(array: [T]) -> [T] {
var newArray = array
for i in 0...newArray.count - 1 {
var isOk = false
for j in 0..<newArray.count - 1 - i {
if newArray[j] > newArray[j + 1] {
(newArray[j], newArray[j + 1]) =
(newArray[j + 1], newArray [j])
isOk = true
}
}
if !isOk {
break
}
}
return newArray
}
var array1 = [14,6,465,4564,435,123,84,64,25,165,64,48,654]
print(bubbleSort(array1))
print(array1)
let array2 = ["Zhang Xiaofan","Lin Jingyu","Lu Xueqi",
"Bi Yao","Tian Linger"]
print(bubbleSort(array2))
print(array2)
总结
在连续3个星期的Swift学习之下，终于基本学完了它的语法，其他零星的点点，都要在以后的实践中展现出来。通过这三周的学习，我也大致对这门编程语言有了基本的了解，相信在以后的学习中，我会逐渐加深对这门语言的掌握力度。
