由于种种原因，简书等第三方平台博客不再保证能够同步更新，欢迎移步 GitHub：https://github.com/kingcos/Perspective/。谢谢！
Access Control in Swift 3.0
- Info:
- macOS 10.12.1 Beta 4
- Xcode 8.1 Beta 3
- Swift 3.0
前言
学习过 Java 等面向对象语言的同学对访问控制一定不陌生，Swift 3 相较于之前的版本，新加了两个关于访问控制修饰符，open 和 fileprivate。因此，是时候总结一下这四个关键字的基本用法，因为暂未涉及到复杂的访问控制，故为浅谈。
另外，由于 Apple.com 的所有文档均无权翻译，所以取消之前的翻译，转为自己的理解和代码，权当给自己做个笔记。
Demo
访问控制修饰符的限制性 高->低 排序为下：
open > public > internal(默认) > fileprivate > private
访问控制的使用原则：不允许将实体定义在限制性更强的实体内。所以，以下代码均为错误用法，并注明了错误信息：
class Cat: NSObject {
var name: String?
}
public var cat = Cat()
// Error: Variable cannot be declared public because its type 'Cat' uses an internal type
// public 变量不能为 internal，fileprivate，private 类型
public func testAccessControl(_ cat: Cat) {
return cat
}
// Error: Function cannot be declared public because its parameter uses an internal type
// 函数或方法的访问限制级别不能高于其参数类型
public func testAccessControl() -> Cat {
return Cat()
}
// Error: Function cannot be declared public because its result uses an internal type
// 函数或方法的访问限制级别不能高于其返回值类型
open & public
open 是 Swift 3 新增的访问控制符，相较于 public 更加开放。open 和 public 都是可以跨 Module 访问的，但 open 修饰的类可以继承，修饰的方法可以重写（此时，open 需同时修饰该方法以及所在类），而 public 不可以。
至于 public final 与 public，前者在任何地方均不可重写，而后者可在本 Module 内重写。
Demo
ModuleA: Person.swift
// open 修饰的类可以为其他 Module 所访问和继承
open class Person: NSObject {
// 属性：
// 子类可访问，不可重写
public var note = "maimieng.com"
// 方法：
// 子类可访问，可重写
open func work() {
print("Work")
}
// 子类可访问，不可重写
public func eat() {
print("Eat it")
}
// 子类可访问，不可重写
public final func walk() {
print("Take a walk")
}
}
ModuleB: Programmer.swift
import ModuleA
class Programmer: Person {
// 只可重写 open 方法
override func work() {
// 可访问父类 public 和 public final 方法
eat()
walk()
print("Writing \\(note)")
}
}
错误信息汇总
重写父类 public 方法
ModuleA: Person.swift
open class Person: NSObject {
public func eat() {
print("Eat it")
}
}
ModuleB: Programmer.swift
import ModuleA
class Programmer: Person {
override func eat() {
print("Hamburger!!")
}
}
Overriding non-open instance method outside of its defining module
重写父类 public 属性
ModuleA: Person.swift
open class Person: NSObject {
public var note = "maimieng.com"
}
ModuleB: Programmer.swift
import ModuleA
class Programmer: Person {
override var note: String {
return "v1024.cn"
}
}
Overriding non-open var outside of its defining module
重写 public 父类
ModuleA: Animal.swift
public class Animal: NSObject {}
ModuleB: Programmer.swift
import ModuleA
class Dog: Animal {}
Cannot inherit from non-open class 'Animal' outside of its defining module
internal
internal 是 Swift 中默认／缺省的访问控制级别。网上对于其他修饰符的解释有很多，而 internal 却很少。internal 对自身 Module 开放所有源文件，而对外界源代码屏蔽。
Demo
ModuleA: Person.swift
class Person: NSObject {
var name = "Person Name"
}
ModuleA: Designer.swift
class Designer: Person {
func test() {
print("test internal")
}
}
错误信息汇总
在 ModuleB 访问 ModuleA
ModuleA: Person.swift
class Person: NSObject {
var name = "Person Name"
}
ModuleB: Programmer.swift
import ModuleA
class Programmer: Person {}
Use of undeclared type 'Person'
fileprivate & private
Swift 3 新增的另一个访问修饰符是 fileprivate。
Demo
main.swift
class Animal: NSObject {
// 默认／缺省 internal
var name: String?
// private 仅可在本类中访问
private var privateProp = "Private Property"
private func privateMethod() {}
// fileprivate 可在当前文件内所有类访问
fileprivate var filePrivateProp = "File Private Property"
fileprivate func filePrivateMethod() {}
}
class Cat: Animal {
func test() {
filePrivateMethod()
print("\\(filePrivateProp)")
}
fileprivate override func filePrivateMethod() {}
}
错误信息汇总
子类访问父类 private 成员
class Animal: NSObject {
private func privateMethod() {}
}
class Cat: Animal {
func test() {
privateMethod()
}
}
'privateMethod' is inaccessible due to 'private' protection level
其他文件的子类访问 fileprivate 成员
main.swift
class Animal: NSObject {
fileprivate var filePrivateProp = "File Private Property"
}
Cat.swift
class Cat: Animal {
func test() {
print("\\(filePrivateProp)")
}
}
'filePrivateProp' is inaccessible due to 'fileprivate' protection level
总结
在 Swift 3 中新增的访问控制修饰符，使得 Swift 的访问控制更加灵活。使用不同的访问修饰符，可以使得程序耦合性降低，对外界屏蔽内部的实现细节。但是，Objective-C 是一门允许动态处理的语言，private 只是所谓的私有，而不是真正的私有，通过 KVC 还是可以获取到内部的细节，而 Swift 由于性能的考虑，默认关闭了动态处理，下一篇谈谈 Swift 中的 KVC & KVO。
