Swift语法 -- [19 - 访问控制]

在访问权限控制这块，Swift提供了5个不同的访问级别:

• open: 允许在定义实体的模块、其他模块中访问，允许其他模块进行继承、重写(open只能用在类、类成员上)
• public: 允许在定义实体的模块、其他模块中访问，不允许其他模块进行继承、重写
• internal: 只允许在定义实体的模块中访问，不允许在其他模块中访问
• fileprivate: 只允许在定义实体的源文件中访问
• private: 只允许在定义实体的封闭声明中访问

访问级别的使用准则 ：一个实体不可以被更低访问级别的实体定义。

• 变量/常量类型 >= 变量/常量
• 参数类型、返回值类型 >= 函数
• 父类 >= 子类
• 父协议 >= 子协议
• 原类型 >= typealias
• 原始值类型、关联值类型 >= 枚举类型
• 定义类型A时用到的其他类型 >= A

1. 元组类型的访问级别

/*元组类型的访问级别是所有成员类型最低的那个*/
internal struct Dog {}
fileprivate class Person {}

// (Dog, Person)的访问级别是fileprivate
fileprivate var data1: (Dog, Person)
private var data2: (Dog, Person)

2. 泛型类型的访问级别

/*泛型类型的访问级别是 类型的访问级别 以及 所有泛型类型参数的访问级别 中最低的那个*/
internal class Car {}
fileprivate class Dog {}
public class Person<T1, T2>{ }

// Person<Car, Dog>访问级别是fileprivate
fileprivate var p = Person<Car, Dog>()

3. 成员、嵌套类型

/*
类型的访问级别会影响成员(属性、方法、初始化器、下标)、嵌套类型的默认访问级别.
    一般情况下, 类型为private或fileprivate, 那么成员/嵌套类型默认也是private或fileprivate
    一般情况下, 类型为internal或public, 那么成员/嵌套类型默认是internal
*/
public class PublicClass {
    public var p1 = 0
  fileprivate func f1() {} //fileprivate
  private func f2() {} //private
}
class InternalClass {//internal
  var p = 0 //internal
  fileprivate func f1() {}//fileprivate
  private func f2() {} //private
}

fileprivate class FilePrivateClass { // fileprivate
  func f1() {} //fileprivate
    private func f2() {} //private
}
private class PrivateClass { // private
  func f() {} //private
}
/*子类重写的成员访问级别必须 >= 父类的成员访问级别*/

/// 下面代码能否编译通过?
private class Person {}
fileprivate class Student : Person {} //场景不同,决定是否报错

private struct Dog { //此时private相当于fileprivate,里面的成员也相当于fileprivate
  var age: Int = 0
  func run() {}
}
fileprivate struct Person {
  var dog: Dog = Dog()
  mutating func walk() {
    dog.run()
    dog.age = 1
  }
}

private Struct Dog {
    private var age: Int = 0
  private func run() {}
}
fileprivate struct Person {//报错
  var dog: Dog = Dog()
  mutating func walk() {
    dog.run()
    dog.age = 1
  }
}
/*直接在全局作用域下定义的private等价于fileprivate*/

4. 成员的重写

/*
    ①子类重写成员的访问级别必须 >= 子类的访问级别, 或者 >= 父类被重写成员的访问级别

    ②父类的成员不能被成员作用域外定义的子类重写
*/

// ②
public class Person {
  private var age: Int = 0
}
public class Student : Person {
  override var age : Int{//报错
    set {}
    get {10}
  }
}
// 改为下面这样写👇
public class Person {
  private var age: Int = 0
  public class Student : Person {
    override var age: Int {
      set {}
      get {10}
    }
  }
}

// ① 成员访问级别跟协议很像 , 访问级别 >= 子类访问级别或在父类所重写成员 两个中最小的一个就行了
class Person {
  internal func run() { }
}
fileprivate class Student : Person {
  fileprivate override func run() { }
}

5. getter、setter

/*getter、setter默认自动接收他们所属环境的访问级别
    可以给setter单独设置一个比getter更低的访问级别, 用以限制写的权限
*/
fileprivate(set) public var num = 10
class Person {
  private(set) var age = 0
  fileprivate(set) public var weight: Int {
    set {}
    get { 10 }
  }
  internal(set) public subscript(index: Int) -> Int {
    set {}
    get { index }
  }
}

6. 初始化器

/*
    ①如果一个public类想在另一个模块调用编译生成的默认无参初始化器, 必须显示提供public的无参初始化器
        因为public类的默认初始化器是internal级别
    ②required初始化器 >= 它的默认访问级别
    ③如果结构体有private/fileprivate的存储实例属性,那么它的成员初始化器也是private/fileprivate
        否则默认就是internal
*/

// ①
// 在动态库xxx.dylib中
public class Person {
  //如果这个类型默认是public,那么内部的所有成员默认都是internal
  public init() { //这里要写public,才能被其他模块调用
  }
} 
// 在TestSwift中
var p = Person() //报错

7. 枚举类型的case

/*不能给enum的每个case单独设置访问级别
    每个case自动接收enum的访问级别
    public enum定义的case也是public
*/
public enum Season {
    case spring, summer, autumn winter//public
}

8. 协议

/*
①协议中定义的要求自动接收协议的访问级别, 不能单独设置访问级别
    public协议定义的要求也是public

②协议实现的访问级别必须 >= 类型的访问级别, 或者 >= 协议的访问级别
*/

//①
public protocol Runnable {
    func run() //public
}

//②
fileprivate protocol Runnable {
  func run()
}
public class Person : Runnable {
  fileprivate func run() {
    
  }
}

/*下面代码能不能编译通过?*/
public protocol Runnable {
  func run() // public
}
public class Person : Runnable {
  func run() {}//internal 编译报错
}

9. 扩展

/*如果有显示设置扩展的访问级别, 扩展添加的成员自动接收扩展的访问级别*/
class Person {}
fileprivate extension Person {
  func run() {}
}
/*如果没有显示设置扩展访问级别,扩展添加的成员默认的访问级别, 跟直接在类型中定义的成员一样*/
/*可以单独给扩展添加的成员设置访问级别*/
/*不能给用于遵守协议的扩展显式设置扩展的访问级别*/

/*
在同一文件的扩展, 可以写成类似多个部分的类型声明
    在原本的声明中声明一个私有成员, 可以在同一文件的扩展中访问它
    在扩展中声明一个私有成员, 可以在同一文件的其他扩展中、原本声明中访问它
*/
// 在同一个文件中
public class Person {
  private func run0()
  private func eat0() {
    run1()
  }
}
extension Person {
  private func run1() {}
  private func eat1() {
    run0()
  }
}
extension Person {
  private func eat2() {//相当于直接写在了类型里
    run1()
  }
}