十六、访问控制

访问控制

访问控制

在访问权限控制这块，Swift提供了5个不同的访问级别(以下从高到低排列)

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

绝大部分实体默认都是 internal 级别

访问级别的使用准则

一个实体不可以被更低访问级别的实体定义，比如：

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

元组类型

• 元组类型的访问级别是所有成员类型最低的那个

internal struct Dog{ }
fileprivate class Car { }

fileprivate var data1:(Dog,Car)
private var data2:(Dog,Car)
//internal var data3:(Dog,Car)//Car的访问级别低于data3 报错
//public var data3:(Dog,Car)//Dog Car的访问级别均低于data3 报错

泛型类型

• 泛型类型的访问级别是类型的访问级别以及所有泛型类型参数的访问级别中最低的那个

internal struct Dog{ }
fileprivate class Car { }
public class Person<T1,T2>{}
fileprivate var p1 = Person<Car,Dog>()
private var p2 = Person<Car,Dog>()
//internal var p3 = Person<Car,Dog>()//p3的访问级别高于Car 报错

成员嵌套类型

• 类型的访问级别会影响成员(属性、方法、初始化器、下标)、嵌套类型的默认访问级别
• 一般情况下，类型为private或fileprivate，那么成员、嵌套类型默认也是private或fileprivate
• 一般情况下，类型为internal或public，那么成员、嵌套类型默认是internal

public class PublicClass{
    public var p1 = 0//public
    var p2 = 0//internal
    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{
    func f1(){}//fileprivate
    private func f2(){}//private
}

private class privateClass{
    func f1(){}//private
}

成员的重写

• 子类重写成员的访问级别必须 >= 子类的访问级别，或者 >= 父类被重写的成员的访问级别
• 父类的成员不能被成员作用域外定义的子类重写

class Person {
    internal func run(){}
}

fileprivate class Student : Person{
    fileprivate override func run() {//至少>=子类的访问级别或者>=重写方法的访问级别
        
    }
}

//如果不是定义在全局则会报错
private class Person{//因为private在全局定义  作用域即为该文件 其实定义的是fileprivate
}
fileprivate class Student :Person{ }


private struct Dog{////因为private在全局定义  作用域即为该文件 其实定义的是fileprivate
    var age = 0 //属性为fileprivate
    func run() {//方法为fileprivate
    }
}
private struct Woman{
    var dog:Dog = Dog()
    mutating func walk() {
        dog.run()//所以此处可以访问
        dog.age = 1
    }
}

直接在全局作用域下定义的private等价于fileprivate

getter、setter

• getter、setter默认自动接收它们所属环境的访问级别
• 可以给setter单独设置一个比getter更低的访问级别，用以限制写的权限

fileprivate(set) public var num = 10//访问权限为public 写权限为fileprivate

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 }
    }
}

var p = Person()
//p.age = 10 报错
print(p.age)//输出：0

初始化器

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

枚举类型的case

• 不能给enum的每个case单独设置访问级别
• 每个case自动接收enum的访问级别

协议

• 协议中定义的要求自动接收协议的访问级别，不能单独设置访问级别
• 协议实现的访问级别必须 >= 类型的访问级别，或者 >= 协议的访问级别

fileprivate protocol Runnable{
    func run()
}

internal class Person : Runnable{
    //访问权限至少要大于 Person 的访问级别 或协议的访问级别
    fileprivate func run() {//private修饰则报错
        
    }
}

扩展

• 如果有显示设置扩展的访问级别，扩展添加的成员自动接收扩展的访问级别
• 如果没有显示设置扩展的访问级别，扩展添加的成员的默认访问级别，跟直接在类型中定义的成员一样
• 可以单独给扩展添加的成员设置访问级别
• 不能给用于遵守协议的扩展显示设置扩展的访问级别（如下例）

fileprivate protocol Runnable{
    func run()
}

class Person{
    
}

internal extension Person : Runnable{//报错：不能修饰任何访问控制关键字
    func run() {
        
    }
}

• 在同一文件中的扩展，可以写成类似多个部分的类型声明
• 在原本的声明中声明一个私有成员，可以再同一文件的扩展中访问它
• 在扩展中声明一个私有成员，可以在同一文件的其他扩展中、原本声明中访问它

//可以看做扩展中的成员都是在类中定义
public class Person{
    private func run0(){}
    private func eat0(){
        run1()//可以相互调用
        eat2()
    }
    
}

extension Person{
    private func run1(){}
    private func eat1(){
        run0()
        eat2()
    }
}

extension Person{
    private func eat2(){
        run1()
        eat0()
    }
}

将方法赋值类var/let

• 方法也可以像函数那样，赋值给一个let或者var

//实例方法
struct Person {
    var age: Int
    func run(_ v: Int) {
        print("func run",age,v)
    }
}

var fn1 = Person.run//fn1类型: (Person) -> ((Int) -> ())
var fn2 = fn1(Person(age: 10))//fn2类型:(Int) -> ()  先传Person实例 返回函数 再传10
fn2(10)

//类型方法
struct Person {
    var age: Int
    static func run(_ v: Int) {
        print("func run",v)
    }
}

var fn1 = Person.run//fn1类型: (Int) -> ()
fn1(10)

struct Person {
    var age: Int
    func run(_ v: Int) {
        print("Obj func run",v)
    }
    static func run(_ v: Int) {
        print("Class func run",v)
    }
}

//如果类型方法与实例方法重名 则声明类型进行区分
var fn1:(Person) -> ((Int) -> ()) = Person.run
var fn2 = fn1(Person(age: 10))
fn2(20)

var fn3:(Int) -> () = Person.run
fn3(30)