目录

一、泛型引入
二、泛型写法
三、类型约束
四、关联类型

打印机案例

func myPrintInt(arg:Int){
    print(arg)
}
func myPrintDouble(arg:Double){
    print(arg)
}
func myPrintString(arg:String){
    print(arg)
}

【思考】如果此时我们打印其他类型的值,就需要针对不同的类型写类似的方法，但是这些方法仅仅只是参数类型不同。
解决方案：能不能让这个类型暂定，等我传的时候再定。一个函数解决所有类型，如何解决？—— 泛型
知识点一 泛型写法
1、给参数类型选择一个代号，并用<>包裹，放在函数名后面，如上面例子中的<T>，用它来指定参数类型， Array<String>
2、真正调用的时候会被实际的类型替代，如传递的是Int，就替换为Int，如果传入的是Double类型就替换为Double等等

func myPrint<T>(arg:T){
    print(arg)
}
myPrint(arg:1)
myPrint(arg:3.3)
myPrint(arg:"xixi")
myPrint(arg:[1,2,3,4])

知识点二 类型约束
类型约束，即给类型添加约束
上面的函数可以用于任意类型。但是，有时在用于泛型函数需要遵循特定的类型,比如是某个类型或者必须遵循某个协议
类型约束直接在类型参数后面指明约束条件；
案例一：遵循某个类型

func myPrint2<T:UIView>(arg:T){//传过来的类型必须是UIView类
    print(arg)
}
myPrint2(arg:1)

案例二：遵循某个协议

protocol ProtocolA{
    func work()
}
func myPrint3<T:ProtocolA>(arg:T){//传进来的类型必须遵循ProtocolA协议
    print(arg)
}
myPrint3(arg:1)

知识点三 关联类型
在协议中怎么使用泛型
示范错误案例
在协议中，某个类型不确定，我需要使用一个类型占位符，按照上面的写法，直接写报错。

protocol SomeProtocol<T>{
    func method1(arg:T)
    func method2(arg:T)
}

关联类型正确案例
关联类型通过 associatedtype 关键字指定

protocol SomeProtocol{
    associatedtype T
    //associatedtype T:UIView  给关联类型添加约束
    func method1(arg:T)
    func method2(arg:T)
}
class A:SomeProtocol{
    func method1(arg:String){//只要参数传进来，立马和T关联--关联类型
        <#code#>
    }
    func method2(arg:String){//第二个方法参数自动变为String
        <#code#>
    }
}

给关联类型添加约束
扩展协议实现方法可选
import Foundation
需求：希望把playBasketball()设计为可选，可以实现也可以不实现
方案：通过扩展协议实现方法可选
步骤：
把协议扩展，把不想实现的方法在扩展中实现。

protocol Protocol1{
    func playBasketball()//希望这个方法可选
    func playFootball()
}
//扩展协议，那即通过扩展可以给可选方法一个默认实现，后面实不实现无所谓
extension Protocol1{
    func playBasketball(){
        print("打篮球")
    }
}
class Student:Protocol1{
    func playFootball(){
        
    }
}

面向协议编程思想
面向协议编程思想
1、开店的例子——面向过程(过程)，面向对象（哪些对象）
2、面向协议编程考虑的重点是协议，一般思路：
1）把某些功能抽象出来，先定好协议
2）进行协议扩展
3）遵循者实现协议

protocol SleepProtocal{
    func sleep()
}

class Bird:SleepProtocal{
    func sleep() {
        print("闭着眼睛睡")
    }
}

class Person:SleepProtocal{
    func sleep() {
        print("闭着眼睛睡")
    }
}

思考：很多生物都是闭着眼睡，也就是sleep方法的实现是一样的，造成了大量的重复，每次都要写一遍。
怎么改进?把重复的代码抽出来
方案改进
扩展协议，在扩展中给出一个默认实现

extension SleepProtocal{
    func sleep()  {
        print("闭着眼睛睡")
    }
}

class Snake:SleepProtocal{
    
}
var s1 = Snake()
s1.sleep()

//如果某个遵循着需要单独的实现，重新实现即可。
class Fish:SleepProtocal{
    func sleep() {
        print("睁着眼睛睡")
    }
}
var f1 = Fish()
f1.sleep()

访问控制
参考官方文档
前置知识：模块和源文件
创建一个iOS项目来对比学习
模块
独立的单元构建和发布单位，实现某个特定功能的代码集合
创建的一个项目就是一个模块
import 导入别人的模块(本质是别人写好的项目，直接拿过来用),演示查看UIKIT源代码，导入了很多模块
注意：模块不是目录，更不是文件夹，而是某个功能的集合，比如UIKit、第三方框架(snapkit)等
源文件
是一个模块中的单个 Swift 源代码文件。
访问权限
访问权限可以修饰 类、方法、属性等。
open 和 public :允许实体被自己定义的模块中的任意源文件访问，也可以被另一模块的源文件通过导入该定义模块来访问。在指定框架的公共接口时，通常使用 open 或 public。
【演示】查看UIKIT源代码，里面的方法几乎都是public
internal:——不能出模块(项目)
允许实体被定义模块中的任意源文件访问，但不能被该模块之外的任何源文件访问。通常在定义应用程序或是框架的内部结构时使用。(默认级别)
【演示】随便创建一个类SecVC，可以在ViewController中访问到。
fileprivate——不能出当前源文件
将实体的使用限制于当前定义源文件中。
【演示】

 // 1、新定义一个Woker类，其中fileprivate修饰的name，在另一个文件VC中无法访问
    class Worker{  
          fileprivate var name:String
          override init() {
              self.salary = 6000
              self.name = "miao"
          }
      }
//2、在woker类的源文件中新定义一个Company类，可以访问name属性
        class Company{
            var mishu:Worker
            init(mishu:Worker) {
                self.mishu = mishu
            }
            func printInfo(){
                print(mishu.name)  //可访问name
            }
        }

private : ——不能出当前作用域
将实体的使用限制于封闭声明中，比fileprivate更严格。
【演示】
在woker类的新增属性salary,同文件Company类中也访问不了

   class Worker: {
       
       fileprivate var name:String
       private var salary:Int
       init() {
           self.salary = 6000
           self.name = "miao"
       }
   }

   class Company{
       var mishu:Worker
       init(mishu:Worker) {
           self.mishu = mishu
       }
       func printInfo(){
           print(mishu.name)  //可访问name
           //print(mishu.salary)  //不可访问salary
       }
   }

访问原则
Swift 中的访问级别遵循一个基本原则：实体不能定义在具有更低访问级别（更严格）的实体中。
错误处理
异常处理：
一、引入
二、异常表示
三、异常处理-4种方式
四、指定清理操作
涉及关键字：Error throw throws try do catch
引入
比如你设计的程序需要读取电脑中的某个文件，以下代码当访问文件出现问题时，当前没法清楚的描述异常，无法定位错误的原因。所以如何来描述异常呢？

 func readFileContent(filePath : String) -> String? {
     // 1.filePath为""
     if filePath == "" {
         return nil
     }

     // 2.filepath有值,但是没有对应的文件
     if filePath != "/User/Desktop/123.plist" {
         return nil
     }

     // 3.取出其中的内容
     return "123"
 }

 readFileContent(filePath: "abc")

描述异常
参考官网
在Swift里，错误用遵循 Error 协议的类型的值来表示;
Error是一个空的protocol，它唯一的功能，就是告诉Swift编译器，某个类型用来表示一个错误。
通常，我们使用一个enum来定义各种错误的可能性
抛出一个错误用throw
通过合理定义异常，改进上述代码

// 1.定义异常
enum FileReadError : Error {
    case FileISNull
    case FileNotFound
}

// 2.改进方法,让方法抛出异常
func readFile(filePath : String) throws -> String {
    // 1.filePath为""
    if filePath == "" {
        throw FileReadError.FileISNull
    }
    // 2.filepath有值,但是没有对应的文件
    if filePath != "/User/Desktop/123.plist" {
        throw FileReadError.FileNotFound
    }
    // 3.取出其中的内容
    return "123"
}

异常处理
抛出异常后，也就是异常出现后，怎么处理呢？
用throwing 函数传递错误
try?方式
最终返回结果为一个可选类型。如果出现了异常,则返回一个nil.没有异常,则返回对应的值——》不处理异常
try!方式
告诉系统该方法没有异常,一旦如果出现了异常,则程序会直接崩溃

do catch（建议）
var result = try? readFile(filePath: "abc")

var result = try! readFile(filePath: "abc")

do{
    try readFile(filePath: "abc")
}catch{//内置变量error
    print(error)
}

指定清理
在java中，我们处理异常使用 try catch finally 。不管有没有出错，我们一般把必须要执行的代码放在finally里。比较典型的一个场景是数据库的操作，不管是否操作成功，最后要close 释放资源。
在swift中，如果想要defer语句来实现。
defer语句调用时机：将离开当前代码块时执行，可以用它在异常中进行扫尾工作，比如关闭IO流，释放资源等
案例一：掌握defer执行时机

do{
   defer{
       print("释放资源11")
       print("释放资源12")
   }
   print("test1")
   try readFile(filePath: "/User/Desktop/123.plist") //如果路径为空，执行顺序如何？
   print("test2")
}catch{//内置变量error
   print(error)
}

案例二：多个defer语句执行顺序

do{
    defer{
        print("释放资源11")
        print("释放资源12")
        print("释放资源13")
    }
    defer{
        print("释放资源21")
    }
    defer{
        print("释放资源33")
    }
    try readFile(filePath: "/User/Desktop/123.plist")
}catch{//内置变量error
    print(error)
}