Swift-访问控制

用户王建国
196 阅读7分钟

访问控制（Access Control）

在访问权限控制这块，Swift提供了5个不同的访问级别（以下是从高到低排列，实体指被访问级别修饰的内容）

这里的模块可以理解为第三方组件

  • open：允许在定义实体的模块，其他模块中访问，允许其他模块进行继承、重写（open只能用在类class、类成员上，不能用在结构体struct）
  • public：允许在定义实体的模块、其他模块中访问，不允许其他模块进行继承、重写
  • internal:只允许在定义实体的模块中访问，不允许在其他模块中访问
  • fileprivate:只允许在定义实体的源文件中访问
  • private:只允许在定义实体的封闭声明中访问
绝大部分实体默认都是internal级别（在本模块中使用）

访问级别的使用准则

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

  • 变量类型、常量类型 >= 变量、常量
fileprivate class Person {}
internal var person:Person // 变量的级别（internal） 大于了 类型的 级别（fileprivate）
  • 参数类型、返回值类型 >= 函数
  • 父类 >= 子类
  • 父协议 >= 子协议
  • 原类型 >= typealias
  • 原始值类型、关联值类型 >= 枚举类型
  • 定义类型A时用到的其他类型 >= 类型A

元祖类型

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

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

泛型类型

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

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

成员、嵌套类型

成员的重写

子类重写成员的访问级别必须 >= 子类的访问级别，或者>=父类被重写成员的访问级别

class Person {
    func run(){}
}
fileprivate class Student:Person {
    fileprivate override func run(){}
}
  • 父类的成员不能被成员作用域外定义的子类重写（私有的属性，方法）
public class Person {
    private var age:Int = 0
}
public class Student :Person {
    override var age:Int {
        set {}
        get {10}
    }
}

image.png

//在同一作用域下
public class Person {
    private var age:Int = 0
    public class Student:Person {
        override var age :Int {
            set {}
            get {10}
        }
    }
}
  • 成员、嵌套类型的访问级别会影响（属性、方法、初始化器、下标）、嵌套类型的默认访问级别
  1. 一般情况下，类型为private或fileprivate,那么成员、嵌套类型默认也是private或fileprivate
fileprivate class Person {
    var age = 0 // 默认是 fileprivate var age = 0
    func run() {} // 默认是fileprivate func run(){}
    enum Season{case spring,summer}
    //默认是 fileprivate enum Season{case spring,summer}
}

2. 一般情况下，类型为interal或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 {// fileprivate
    func f1() {} // fileprivate
    private func f2(){} // private
}
private class PrivateClass {
    func f(){} // private
}
下面代码能否编译通过

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


private class Person {}
fileprivate class Student : Person {}
/*
    如果两者在同一个文件夹下，那是可以的，private 代表声明的整一个作用域内有效，就相当于是fileprivate，满足父类的访问级别大于子类的级别
*/


/*
    private 代表声明的整一个作用域内有效，如果
    func test() {
         private class Person {} // Person 只在当前func有效
          fileprivate class Student : Person {}
    }
    这里就不满足父类的访问级别大于子类的级别，这里就会报错
*/


Dog 声明在全局作用域下是fileprivate，age，run 也是fileprivate
private struct Dog {
    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() //private 私有变量，函数
        dog.age = 1
    }
}

getter、setter

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

初始化器

  • 如果一个public类想在另一个模块调用编译生成的默认无参初始化器，必须显示提供public的无参初始化器（引入的动态库在当前模块使用）
  1. 因为public类的默认初始化器是internal级别
public class Person {
    // 这是第三方的动态库，
    /*
        这里编译器会生成一个默认无参初始化器，它是internal,internal是不能在其他模块调用，必须显示声明为public的无参初始化器
        internal init(){}
    */
}

// 这是我自己项目模块中的引入Person，这是不通过的
var p = Person()
  • required初始化器 >= 它的默认访问级别
class Person {
    fileprivate required init(){}// 默认访问级别internal
}

image.png

  1. 如果结构体有private、fileprivate的存储实例属性，那么它的成员初始化器也是private、fileprivate
struct Point {
   fileprivate var x = 0
    var y = 0
}
var p = Point(x:10,y:20) // 这个初始化器只能在当前文件下访问，不能在别的文件下访问

image.png

一旦成员是private，那么所带有的成员的初始化器就不能访问 image.png

枚举类型的case

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

image.png

  • 每个case 自动接收enum的访问级别
  1. public enum定义的case也是public

协议

  • 协议中定义的要求自动接收协议的访问级别，不能单独设置访问级别

image.png

  1. public协议定义的要求也是public ，协议是啥级别，里面也是啥级别，不能单独设置
internal protocol Runnable {
    func run()
}
  • 协议实现的访问级别必须 >= 类型的访问级别，或者 >= 协议的访问级别
internal protocol Runnable {
     func run()
}
fileprivate class Person : Runnable {
    private func run() 
    /*
        协议实现的访问级别必须 >= 类型的访问级别（Person），或者 >= 协议的访问级别（internal）
    */
}

下面编码能通过吗

public protocol Runnable {
    func run()
}
public class Person : Runnable {
    func run(){}
    /*
        func run(){} 访问级别为internal小于Person级别，小于Runnable级别
    */
}

扩展

  • 如果有显示设置扩展的访问级别，扩展添加的成员自动接收扩展的访问级别
class Person {}

fileprivate extension Person {
    func run(){} // 这里的访问级别fileprivate，是自动接收扩展的访问级别
}
  • 如果没有显示设置扩展的访问级别，扩展添加的成员的默认访问级别，跟直接在类型中定义的成员一样(相当于写在类中)
  • 可以单独给扩展添加的成员设置访问级别

image.png

  • 不能给用于遵守协议的扩展显示设置扩展的访问级别

image.png

  • 在同一文件中的扩展，可以写成类似多个部分的类型声明（将一个类写在不同的地方）
  1. 在原本的声明中声明一个私有成员，可以在同一文件的扩展中访问它
  2. 在扩展中声明一个私有成员，可以在同一文件的其他扩展中、原本声明中访问它
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()
    }
}
  • 将方法赋值给var、let
  1. 方法也可以像函数那样，赋值给一个let或者var
struct Person {
    var age:Int
    func run(_ v:Int){print('func run',age,v)}
}

var p = Person(age:10)
p.run(20)// func run',10,20

//可以理解为js 中的bind
var fn1 = Person.run // 实例方法赋值给fn1
var fn2 = fn1(Person(age:10))
fn2(20)
avatar
文章
阅读
粉丝