Swift——第三周的爬坑之路

协议

1.定义：协议是方法的集合，可以把看似不相关的对象的公共行为放到一个协议中。
2.协议自身的意义：Swift中的继承是单一继承(一个类只能有一个父类), 如果希望让一个类具备多重能力可以使用协议来实现。
3.协议在Swift开发中大致有三种作用:

• 能力 - 遵循了协议就意味着具备了某种能力。
• 约定 - 遵循了协议就一定要实现协议中的方法。
• 角色 - 一个类可以遵循多个协议, 一个协议可以被多个类遵循, 遵循协议就意味着扮演了某种角色, 遵循多个协议就意味着可以扮演多种角色。

4.实例：

//首先进行协议的创建
protocol Flyable {
    
    func fly()
}

protocol Fightable {
    
    func fight()
}

//再进行实体类的创建并继承协议
class Bird: Flyable {

    func fly() {
        print("鸟儿扇动翅膀飞行.")
    }
}

class Boxer: Fightable {
    
    func fight() {
        print("正在进行格斗.")
    }
}

而此时想要建立一个超人类，却发现协议不“够”用了，那么可以进行协议的扩展和协议之间的继承

//协议的扩展 - 可以在协议扩展中给协议中的方法提供默认实现
// 也就是说如果某个类遵循了协议但是没有实现这个方法就直接使用默认实现
// 那么这个方法也就相当于是一个可选方法(可以实现也可以不实现)
extension Fightable {
    
    func fight() {
        print("正在打架")
    }
}


// 协议的继承
protocol Super: Flyable, Fightable {
    
    func dive()
}



//创建超人类
class Superman: Super {
    
    func fly() {
        print("超人使用超能力飞行.")
    }
    
//    func fight() {
//        print("超人正在和邪恶势力干仗.")
//    }
    
    func dive() {
        print("超人正在潜水.")
    }
}

协议的总结：

1.依赖倒转原则(面向协议编程)

• 声明变量的类型时应该尽可能使用协议类型
• 声明方法参数类型时应该尽可能使用协议类型
• 声明方法返回类型时应该尽可能使用协议类型

2.协议的开闭原则:

• 协议中全是抽象概念(只有声明没有实现) 遵循协议的类可以各自对协议中的计算属性和方法给出自己的实现版本 这样当我们面向协议编程时就可以把多态的优势发挥到淋漓尽致 可以写出更通用更灵活的代码(符合开闭原则)

3.接口(协议)隔离原则: 协议的设计要小而专不要大而全

结构

1.定义：用于保存基层数据的数据结构；与类相似，只是将定义的关键字改为了struct。
2.与类的区别

• 区别 1: 结构的对象是值类型, 类的对象是引用类型
• 值类型在赋值的时候会在内存中进行对象的拷贝
• 引用类型在赋值的时候不会进行对象拷贝只是增加了一个引用
• 区别 2: 结构会自动生成初始化方法
• 区别 3: 结构中的方法在默认情况下是不允许修改结构中的属性除非加上mutating关键字
  3.代码演示：

class Student1 {
    var name: String
    var age: Int
    var tel: String?
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
    
    func getOlder() {
        age += 1
    }
    
    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: "Xyk_", age: 18)
var stu3 = stu1     // 此处内存中仍然只有一个学生对象
stu3.name = "-kyX"
stu3.age = 15
print(stu1.name)
print(stu1.age)

// 值类型的结构
let stu2 = Student2(name: "Xyk_kyX", age: 18)
var stu4 = stu2     // 此处内存中会复制一个新的学生对象
stu4.name = "Xyk_kyX_Xyk"
stu4.age = 15
print(stu2.name)
print(stu2.age)

//打印结果：
            -kyX
            15
            Xyk_kyX
            18

//这里的打印结果可以看出：
//1：用struct创建的学生在被“赋值”给学生的以后，没有被更改姓名和年龄
//2：用类创建的学生在被“赋值”给学生的以后，被更改姓名和年龄

释放内存

代码演示1：

class Person {
    var name: String
    var age: Int
    
    // 指派构造器前面加上required可以将构造器指定为必要构造器
    // 所谓的必要构造器意味着子类也要提供一模一样的构造器
    // 指派构造器(designated)
    required init(name: String, age: Int) {
        print("创建一个人!")
        self.name = name
        self.age = age
    }
    
    // 便利构造器(convenience)
    convenience init() {
        self.init(name: "无名氏", age: 20)
    }
    
    deinit {
        print("人嗝屁了!")
    }
}

class Student: Person {
    var major: String
    
    required init(name: String, age: Int) {
        major = "未知"
        super.init(name: name, age: age)
    }
    
    convenience init(name: String, age: Int, major: String) {
        // 下面的语句必须写在调用自己的初始化方法之后否则major属性会被赋上不正确的值
        // self.major = major
        self.init(name: name, age: age)
        self.major = major
        // 初始化的第一阶段
        //  1. 初始化自己特有的属性
//        self.major = major
//        子类只能调用直接父类的构造器
//        子类构造器必须调用父类的非便利构造器(指派构造器)
//        super.init()    // compiler error
//        2. 调用父类的初始化方法
//        super.init(name: name, age: age)
//        初始化的第二阶段
//        此处可以调用对象的方法因为对象已经完成了初始化
//        study()
    }
    
    func study() {
        print("\(name)正在学习.")
    }
    
    deinit {
        print("学生对象嗝屁了!")
    }
}

class Teacher: Person {
    
    
    deinit {
        print("老师对象嗝屁了!")
    }
}

// 创建一个学生对象 然后用stu1去引用它 所以此时学生对象引用计数为1
var stu1: Student? = Student()
// 此处没有创建新的学生对象 原来的学生对象的引用计数+1
var stu2 = stu1
// 同上 原来的学生对象的引用计数+1
var stu3 = stu2

// 学生对象引用计数-1
stu1 = nil
// 学生对象引用计数-1
stu2 = nil
// 学生对象引用计数-1
// 当学生对象引用计数为0时 ARC会自动清理内存释放学生对象
// ARC即时性的内存清理 优于Java中的Garbage Collection(垃圾回收)
stu3 = nil

代码演示2：

class Emp {
    // 推荐使用
    // 如果允许使用可空类型通常使用weak来破除循环引用
    // 如果员工关联的部门对象被释放了那么dept会被赋值为nil
    // 如果要继续给dept对象发消息程序不会崩溃
    // weak var dept: Dept?
    
    // 谨慎使用
    // 如果不允许使用可空类型就必须使用unowned来破除循环引用
    // 需要注意的是如果员工对象关联的部门对象被释放了
    // 如果还要通过员工对象去操作它所关联的部门对象将导致程序崩溃
    // EXC_BAD_ACCESS
    unowned var dept: Dept
    
    init(dept: Dept) {
        print("创建一个员工")
        self.dept = dept
    }
    
    deinit {
        print("销毁一个员工")
    }
}

class Dept {
    var manager: Emp?
    
    init() {
        print("创建一个部门")
    }

    deinit {
        print("销毁一个部门")
    }
}

func bar() {
    // let person = Person()
    let dept = Dept()
    let emp = Emp(dept: dept)
    dept.manager = emp
}

bar()

泛型：

1.定义一个虚拟类型T, 调用函数时根据传入的参数类型来决定T到底是什么
2.泛型限定：<T: Comparable>限定T类型必须是遵循了Comparable协议的类型
3.让类型不再是程序中的硬代码

func bubbleSort<T: Comparable>(array: [T]) -> [T] {
    var newArray = array
    for i in 0..<newArray.count - 1 {
        var swapped = false
        for j in 0..<newArray.count - 1 - i {
            if newArray[j] > newArray[j + 1] {
                mySwap(&newArray[j], &newArray[j + 1])
                swapped = true
            }
        }
        if !swapped {
            break
        }
    }
    return newArray
}