- 在访问权限控制中,Swift提供了5种不同的访问级别
1.open:允许在定义实体的模块,其他模块中访问,允许其他模块进行继承,重写(open只能用在类,类成员上)
2.public:允许在定义实体的模块,其他模块中访问,不允许其他模块进行继承,重写
3.internal:只允许在定义实体的模块中访问,不允许其他模块中访问.
4.fileprivate:只允许在定义实体的源文件中访问
5.private只允许在定义实体的封闭声明中访问 - 绝大多数实体默认都是
internal级别
访问级别的使用准则
- 一个实体不可以被更低级别的实体定义,比如:
元祖类型
- 元祖类型的访问级别是所有成员类型中访问级别最低的那个.
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 {}
//泛型Person<T1,T2>的访问级别为fileprivate
public class Person<T1,T2>{}
成员,嵌套类型
- 类型的访问级别会影响成员(属性 方法 初始化器 下标),嵌套类型的默认访问级别.
- 一般情况下,类型为
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{//private
func f() {}//private
}
成员的重写
- 子类重写成员的访问级别必须
>=子类的访问级别,或者>=父类被重写成员的访问级别. - 父类的成员不能被成员作用域外定义的子类重写
public class Person {
private var age = 0
}
//age的访问权限 只能在Person中,子类Student不能重写age属性
public class Student : Person{
override var age: Int {
set {}
get { return 10 }
}
}
public class Person {
private var age = 0
public class Student : Person{
override var age: Int {
set {}
get { return 10 }
}
}
}
以下代码是否编译通过
- 在全局作用域下定义的
private和filefrivate等价
private class Person {}
fileprivate class Student : Person {}
private struct Dog {
var age = 0
func run() { }
}
fileprivate struct Person {
var dog = Dog()
mutating func walk(){
dog.run()
dog.age = 1
}
}
编译不通过
private struct Dog {
private var age = 0
private func run() { }
}
fileprivate struct Person {
var dog = Dog()
mutating func walk(){
//run() 和 age 权限为private
//只能在定义他们的作用域使用
dog.run()
dog.age = 1
}
}
getter setter
- 默认自动接收他们所属环境的访问级别
- 可以给
setter单独设置一个比getter更低的访问级别,用以限制写的权限
fileprivate(set) public var num = 0
class Person {//internal
private(set) var age = 0 //age internal.set方法private
fileprivate(set) public var weight: Int{
set {}
get { return 10 }
}
internal(set) public subscript(index: Int) -> Int {
set {}
get { return index}
}
}
初始化器
- 如果一个
public类想在另一个模块调用编译生成的默认无参初始化器,必须显示提供public的无参初始化器,因为public类的无参初始化器是internal级别. -
required初始化器>=它的默认访问级别internal,否则默认就是internal
枚举类型的case
- 不能给
enum的每个case单独设置访问级别 - 每个case自动接收enum的访问级别
-
public enum定义的case也是public
协议
- 协议中定义的要求自动接收协议的访问级别,不能单独设置访问级别,
public协议定义的要求也是public - 协议实现的访问级别必须
>=类型的访问级别,或者>=协议的访问级别
public protocol Runnable {
func run()
}
//要添加public,默认是internal
public class Person : Runnable{
func run() {
}
}
扩展
- 如果有显式设置扩展的访问级别,扩展添加的成员自动接收扩展的访问级别.
- 如果没有显式设置扩展的访问级别,扩展添加的成员的默认访问级别,跟直接在类型中定义的成员一样.
- 可以单独给扩展添加的成员设置访问级别.
- 不能给用于遵守协议的扩展显示设置扩展的访问级别.
- 在同一文件中的扩展,可以写成类似多个部分的类型声明
- 在原本的声明中声明一个私有成员,可以在同一文件的扩展中访问他
- 在扩展中声明一个私有成员,可以在同一个文件的其他扩展中,原本声明中访问他.
public class Person {
private func run0() {}
private func eat0() {
run0()
}
}
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)
}
static func run(_ v: Int){
print("static func run",v)
}
}
let fn1 = Person.run
fn1(10)//static func run 10
let fn2: (Int) -> () = Person.run
fn2(20)//static func run 20
let fn3: (Person) -> ((Int) -> ()) = Person.run
fn3(Person(age: 18))(30)//func run 30
网友评论