第四周第三天

结构体和类

区别1：结构的对象是值类型, 类的对象是引用类型
值类型在赋值的时候会在内存中进行对象的拷贝
引用类型在赋值的时候不会进行对象拷贝只是增加了一个引用
结论: 我们自定义新类型时优先考虑使用类而不是结构除非我们要定义的是一种底层的数据结构(保存其他数据的类型)
区别2：结构会自动生成初始化方法
在类中如果没有初始化方法会报错而在结构体中不会因为结构体中会自动生成初始化方法（依据你所定义的属性而定）
区别3: 结构中的方法在默认情况下是不允许修改结构中的属性除非加上mutating关键字
在类中我们调用类的属性不用
如果要对结构体中的属性进行修改或变动必须加关键词mutating

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)正在学习.")
    }
    
    // 区别3: 结构中的方法在默认情况下是不允许修改结构中的属性除非加上mutating关键字
     mutating func getOlder() {
        age += 1
    }
}

计算机的硬件由五大部件构成:
运算器、控制器、存储器、输入设备、输出设备
运算器 + 控制器 => CPU (中央处理器)
存储器 => 内存 (RAM - Random Access Memory)

程序员可以使用的内存大致分为五块区域:
栈 (stack) - 我们定义的局部变量/临时变量都是放在栈上

• 特点: 小、快
  堆 (heap) - 我们创建的对象都是放在堆上的
• 特点: 大、慢
  静态区 (static area)
• 数据段 - 全局量
• 只读数据段 - 常量
• 代码段 - 函数和方法

引用计数器（Automatic Reference Counting）

简称ARC
ARC只管理引用类型不管理值类型
1.当一一个对象的引用计数为0的时候，系统会自动清除对象释放内存，
一个对象赋值一次他的引用将会增加一，把值赋为nil引用计数将减一
2.一个局部变量/常量 在函数调用结束后局部变量就消失了
3.引用转移：会导致原来对象上的引用计数-1 新对象引用计数+1
Tip:创建任何子类对象的时候一定是先创建了父类对象
4.Swift的自动释放池

通过向autoreleasepool函数中传入一个闭包来实现
autoreleasepool { () -> () in
    // 自动释放池中的对象引用在池的边界会收到引用计数-1的消息
    // 将来做iOS开发时如果某个地方会创建很多的临时对象
    // 那么最好在此处设置一个自动释放池避免内存瞬时峰值过高造成闪退
     let stu1 = Student()
    let stu2 = stu1
 }
// 离开自动释放池时 stu1会收到引用计数-1消息 stu2也会收到引用计数-1消息

5.如果程序中出现了类与类之间双向关联关系 必须要将其中一端设置为weak引用
否则将会形成循环引用导致ARC无法释放内存(类和类之间相互调用引用计数始终都无法归0，在这种情况下我们让一方变为弱引用就可以了)
weak修饰的引用(弱引用)不会增加引用计数 默认是强引用(会增加引用计数)
unowned也可以接触循环引用但是不推荐因为可能形成“野指针”情况--就是调用不属于它的地址导致系统崩溃

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.指派构造器（designated）（个人理解为最原始的构造器，也就是让别个来调用的构造器）
子类调用父类的初始化方法时只能一级一级调用不能隔代调用
2.便利构造器（convenience）
3.必要构造器：指派构造器前面加上required可以将构造器指定为必要构造器
所谓的必要构造器意味着子类也要提供一模一样的构造器

4.构造器分阶段执行
初始化的第一阶段
1. 初始化自己特有的属性
2. 调用父类的初始化方法
初始化的第二阶段
此处可以调用对象的方法因为对象已经完成了初始化

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("学生对象嗝屁了!")
    }
}

异常处理机制

今天老师用的是一个分数分母为0的情况说明这个机制
1.在初始化是做一个判定如果出现异常或者错误就用关键词“throw”抛出一个必须是遵循ErrorType协议的东西
2.如果一个方法抛出了异常 那么在声明方法时必须要写上throws关键字
throws关键字是提醒方法的调用者方法可能会出状况 调用时要写try

 // 如果一个方法抛出了异常 那么在声明方法时必须要写上throws关键字
  // throws关键字是提醒方法的调用者方法可能会出状况 调用时要写try
  init(num: Int, den: Int) throws {
      _num = num
      _den = den
      if _den == 0 {
          // 如果程序中出现问题就抛出错误(异常)
          // 被throw关键字抛出的必须是遵循ErrorType协议的东西
          throw FractionError.ZeroDenominator
      }
      else {
          simplify()
          normalize()
      }
  }
  

3.写一个枚举把出现错误的状况列出来方便后面找错在哪

// 定义一个遵循ErrorType协议的枚举
// 通过不同的case定义程序中可能出现的若干种异常状况
enum FractionError: ErrorType {
    case ZeroDenominator    // 分母为0
    case DivideByZero       // 除以0
}

4.如果能够确保方法调用时不出异常那么可以在try关键字后加!
这样就可以在不写do...catch的情况下调用可能出状况的方法

func add(other: Fraction) -> Fraction {
        
        return try! Fraction(num: _num * other._den + other._num * _den, den: _den * other._den)
    }
    

不然还是要在初始化前面写一个throws表示可能出错

func div(other: Fraction) throws -> Fraction {
        if other._num == 0 {
        //这里表示如果除以一个为0的数也会抛出异常
            throw FractionError.DivideByZero
        }
        return try! Fraction(num: _num * other._den, den: _den * other._num)
    }

然后就是执行的时候
对于可能出状况的代码要放在do...catch中执行
在可能出状况的方法前还要写上try表示尝试着执行
如果在do中没有出现任何状况那么catch就不会执行
如果do中出现了状况代码就不会再向下继续执行而是转移到catch中
在do的后面可以跟上多个catch用于捕获不同的异常状况 但是最多只有一个catch会被执行
不同错误的返回不同

catch FractionError.ZeroDenominator {
    print("瓜西西的, 分母不能为0!!!")
}
catch FractionError.DivideByZero {
    print("卵球了, 除以0是不行的!!!")
}
catch {
    print("出错了! 我也不知道什么问题")
}

如果不用do...catch 可以采用以下方式
如果能够保证代码不出错可以在try后面加!
如果不确定代码是否出错可以在try后面加?
需要注意的是有?的地方会产生Optional(可空类型)
稍后可能还需要对可空类型进行拆封, 拆封方式有二:
1. 不安全的做法: xxx!
2. 安全的做法: 用if let = xxx { }进行拆封

func foo() {
    
    let f1 = try? Fraction(num: 3, den: 0)
    let f2 = try? Fraction(num: 0, den: 9)
    //安全的方式
    if let a = f1, b = f2 {
        let f3 = a + b
        print(f3.info)
    }
    else {
        print("无效的分数无法进行加法运算")
    }
}

foo()

泛型

一个可以让我们写出更通用更普遍代码的东东，一个可以不限制类型的东东
简单用法
首先你要虚拟一个类型T，让你传入的类型决定T的类型

func mySwap<T>(inout a: T, inout _ b: T) {
    let temp = a
    a = b
    b = temp
}

如果需要比较的话我们要加一个泛型限定，也就是说让虚拟类型T遵循一个协议但是呢这个协议的执行方法要写在函数或者类结构的外面---据说这是swift里面比较奇葩的东西
这是两个参数选小的参数数的函数 这里进行了泛型限定 这个T要遵循协议Comparable

func myMin<T: Comparable>(a: T, _ b: T) -> T {
    return a < b ? a : b
}

在Comparable里面有这么些个方法

func ==(one: Student, two: Student) -> Bool {
    return one.name == two.name
}

func <(one: Student, two: Student) -> Bool {
    return one.name < two.name
}

func <=(one: Student, two: Student) -> Bool {
    return one.name <= two.name
}

func >(one: Student, two: Student) -> Bool {
    return one.name > two.name
}

func >=(one: Student, two: Student) -> Bool {
    return one.name >= two.name
}

一个类它如果也遵循了Comparable这个协议

class Student: Comparable {
    var name: String
    var age: Int
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

函数myMin也可以对它的对象进行bijiao

var stu1 = Student(name: "Luo Hao", age: 35)
var stu2 = Student(name: "Wang Dachui", age: 18)

let minStu = myMin(stu1, stu2)
print(minStu.name)

当然结构体也可以使用泛型，下面是一个比较经典的列子（据说是）

struct Stack<T> {
    var data: [T] = []
   //没有初始化，结构体的初始化是默认执行的
    // 入栈
    mutating func push(elem: T) {
        data.append(elem)
    }
    // 出栈
    //在出栈这里加上一个判定看数组是否为空，如果不为空那么就执行
    mutating func pop() -> T {
        return data.removeLast()
    }
    //写一个判断数组是不是为空的计算属性
    var isEmpty: Bool {
        get { return data.count == 0 }
    }
}

var stack = Stack<String>()
stack.push("hello")
stack.push("good")
stack.push("zoo")

while !stack.isEmpty {
    print(stack.pop())
}