Swift-OOP-权限控制

访问控制（Access Control）

• 在访问权限控制这块，Swift提供了5个不同的访问级别（以下是从高到低排列），实体指被访问级别修饰的内容
• open:允许在定义实体的模块、其他模块中访问，允许其他模块进行继承、重写（open只能用在类、类成员上）
• public：允许在定义实体的模块、其他模块中访问，不允许其他模块进行继承、重写
• internal(内部的)：只允许在定义实体的模块中访问，不允许在其他模块中访问（绝大部分实体默认都是internal级别）
• fileprivate：只允许在定义实体的源文件中访问
• private：只允许在定义实体的封闭声明中访问

访问级别的使用准则

• 一个实体不可以被更低访问级别的实体定义，比如
• 变量类型、常亮类型 >= 变量、常量
• 参数类型、返回值类型 >= 函数
• 父类 >= 子类
• 父协议 >= 子协议
• 原类型 >= typealias
• 原始值类型、关联值类型 >= 枚举类型
• 定义类型A时用到的其他类型 >= 类型A

元组类型

internal struct Dog {
    
}
fileprivate class Person {
    
}
fileprivate var data1:(Dog,Person)

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

泛型类型

internal class Car {}
fileprivate class Doga {}
public class Persona {}
//Persona 的访问级别是fileprivate
fileprivate var p = Persona()

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

成员、嵌套类型

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 fn1 () {}//fileprivate
}
fileprivate class FilePrivateClass {//fileprivate
    func f1()  {
        
    } //fileprivate
}
private class PrivateClass {//private
    func f() {}//private
}

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

成员的重写

public class Personb {
    var age = 0
    private var height = 1.88
}
class Studentb: Personb {
    override var age: Int {
        set {}
        get {20}
    }
    /**
     //报错
     override var height: Double {
         set {}
         get {20.0}
     }
     */
}
/**
 * 子类重写成员的访问级别必须 >= 子类的访问级别，或者 >= 父类被重写成员的访问级别
 * 父类的成员不能被成员作用域外定义的子类重写
 */
public class Personc {
    private var height = 1.88
    class Studentb: Personc {
        override var height: Double {
            set {}
            get {20.0}
        }
    }
}

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

getter、setter

fileprivate(set) public var num = 0

class Persond {
    private(set) var age = 0
    fileprivate(set) public var weight: Int {
        set {}
        get {10}
    }
}

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

初始化器

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

枚举类型的case

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

协议

public protocol runablex {
     func run()
    
}

public class Persone: runablex {
    /**
     //Method 'run()' must be declared public because it matches a requirement in public protocol 'runablex'
     //方法“run（）”必须声明为public，因为它符合公共协议“runablex”中的要求
     func run() {
         print("run")
     }
     */
    public func run() {
        
    }
}

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

扩展

public class Personf {
    private func run0 () {
        run1()
        run2()
        eat2()
    }
    private func eat0 () {
        
    }
}
extension Personf {
    private func run1 () {
        
    }
    private func eat1 () {
        
    }
}
extension Personf {
    private func run2 () {
        
    }
    private func eat2 () {
        
    }
}

• 在同一文件中的扩展，可以写成类似多个部分的类型声明
• 在原本的声明中声明一个私有成员，可以在同一文件的扩展中访问他
• 在扩展中声明一个私有成员，可以在同一文件的其他扩展中、原本声明中访问
• 如果有显式设置扩展的访问级别，扩展添加的成员自动接收扩展的访问级别
• 如果没有显式设置扩展的访问级别，扩展添加的成员的默认访问级别，跟直接在类型中定义的成员一样
• 可以单独给扩展添加的成员设置访问级别
• 不能给用于遵守协议的扩展显式设置扩展的访问级别