Swift十五(1: 访问控制2: 内存管理 3 闭包循环引用&

1 访问控制 open& public& internal
2 内存管理 自动释放池 Autoreleasepool
3 闭包循环引用 [weak self]
4 逃逸闭包 @escaping 逃走

一: 访问控制 (共五种)

1. open: 允许在定义在实体模块, 其他模块中访问, 允许其他模块继承, 重写(open只能用在类, 类成员上)

// Target是个模块, Pod算是另一个模块, 动态库也是另一个模块, 只有类是可以继承的

2. public: 允许在定义在实体模块, 其他模块中访问, 不允许其他模块继承, 重写

3. internal: 只允许在定义实体模块中访问, 不允许在其他模块中访问 (绝大部分实体默认级别)

4. fileprivate: 只允许在定义的源文件中访问

// 当前.swift文件

5. private: 只允许在定义实体封闭声明中访问

// private定义在方法内部, 作用域就是当前方法
// 访问类型以上五种由高到低

1.1 访问级别使用原则

1 变量/常量类型 >= 变量/常量
2 参数类型 >= 函数
3 父类 >= 子类
4 原类型 >= Typealise
5 原始值类型/ 关联值类型 >= 枚举类型
6 定义类型A 用到其他类型 >= A类型

例子:

1 变量/常量类型 >= 变量/常量
// 变量类型的访问级别, 需要大于变量的访问级别

2 元祖访问级别要比所有成员类型都低

3 泛型访问级别

二: 内存管理

跟OC一样，Swift也是采取基于引用计数的ARC内存管理方案(针对堆空间)

Swift的ARC中有3种引用
1. 强引用（strongreference）：默认情况下，引用都是强引用

2. 弱引用（weakreference）：通过weak定义弱引用
必须是可选类型的var，因为实例销毁后，ARC会自动将弱引用设置为nil ARC自动给弱引用设置nil时，不会触发属性观察器

3. 无主引用（unownedreference）：通过unowned定义无主引用
不会产生强引用，实例销毁后仍然存储着实例的内存地址（类似于OC中的unsafe_unretained）ü试图在实例销毁后访问无主引用，会产生运行时错误（野指针）

1.1 Autoreleasepool

定义publicfuncautoreleasepool<Result>(invokingbody:()throws->Result)rethrows->Result** // 参数是一个闭包

autoreleasepool {
    let p = person(age:20,name:"Jack")p.run()
}

三: 闭包的循环引用

**闭包表达式, 默认会对用到的外层对象产生额外的强引用（对外层对象进行了retain操作）

例如:

class FTLearnEnumViewController: FTBaseViewController {
    var fn: (()->())? // 声明函数 无参数, 无返回值
    func run() {
        print("跑起来了")
    }
    deinit{
        print("类销毁了~")
    }
}

    override func viewDidLoad() {
        super.viewDidLoad()
        self.fn = {
            self.run()
        }
        if let fnFunc = self.fn {
            fnFunc()
        }  
   }

存在内存泄漏 self 强引用闭包fn, 闭包fn内部强引用self, 导致内存泄漏
打印: 跑起来了

 override func viewDidLoad() {
        super.viewDidLoad()   
        self.fn = { [weak self] in
            self?.run()
        }
        // self 引用闭包fn, 闭包fn引用self
        if let fnFunc = self.fn {
            fnFunc()
        }
    }

不存在内存泄漏 self 强引用闭包fn, 闭包fn内部若引用self
打印:
跑起来了
类销毁了~

四: @escaping 非逃逸闭包 & 逃逸闭包

1. 非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数
2. 非逃逸闭包：闭包调用发生在函数结束前，闭包调用在函数作用域内
3. 逃逸闭包：闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过@escaping声明
   备注: 非逃逸闭包: 闭包执行在方法内部
   逃逸闭包: 闭包执行在方法外面, 例如做个闭包赋值传递

import Dispatch 
typealias Fn=()->()

// fn是非逃逸闭包
func test1(_fn: Fn){ fn() }

// fn是逃逸闭包
var gFn: Fn?
func test2(_fn: @escaping Fn) { gFn = fn }

// fn是逃逸闭包
func test3(_fn: @escaping gFn) {
  DispatchQueue.global().async {  
    fn() // 开启线程, 会导致方法结束, fn()闭包才执行
  }
}

class Person {
  var fn: Fn 
  //fn是逃逸闭包
  init(fn: @escaping Fn) {
      self.fn = fn
  }
  func run() {
  // DispatchQueue.global().async参数是传递一个逃逸闭包
  // 它用到了实例成员（属性、方法）, 编译器会强制要求明确写出self 
       DispatchQueue.global().async{
           self.fn()
       }
  }
}

注意: 逃逸闭包不可以捕获inout参数