对于每个语言都有属于自己的访问控制权限
对于Java来说:OC中提供了4个访问控制符： @private @package @protected @public 。
对于iOS开发工程师使用OC语言的来说:OC中提供了4个访问控制符： @private @package @protected @public 。
而对于iOS开发工程师还有一种是使用Swift来🔨代码的，那么对应Swift的访问控制 open, public, internal, fileprivate, private这五个。
open : module以外可以访问、重写或者继承。
public: module以外可以访问、不能重写或者继承。
internal(默认)：当前module可用
fileprivate: 当前file可见
private：当前声明区域可见
当你的module的某些类或者方法不想对外提供继承或者重写的权限时可以使用public，而不必使用final。
一个建议是自定义类默认设置为final而不是默认的final(除非有继承的需求)，这样可以提高编译速度。
来看看代码
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
let a = A.init()
a.method()
}
}
class A {
open var opena = 10 //module以外可以访问、重写或者继承。
public var publicb = 10 //module以外可以访问、不能重写或者继承。
internal var internalc = 10 //当前module可用
fileprivate var fileprivated = 10 // 当前file可见
private var privatee = 10 //当前声明区域可见
}
extension A {
func method() {
print(opena)
print(publicb)
print(internalc)
print(fileprivated)
print(privatee)
}
}
都在一个model里面 ，没有问题！！
而这个如果要调用A类里面的成员变量除了用private声明的不可以被调用，其余都有正常被调用。因为private定义为了私有也就只能在A类使用。
而这时候如果我们把extension放在不同文件里就会发生使用fileprivated声明的变量报错了，'xxxxxx' is inaccessible due to 'fileprivate' protection level就是访问权限问题！！fileprivated也就是文件内私有，也在当前的.switf可用。
那internal、public和opena如何测试？如何在不同module呢？
先回答最后一个问题，如何在不同Module呢？可以使用打包的方式。那如何打包呢？可以参考小编的打包静态库教程
首先搞一个静态库静态库里面有一个Utils文件下面对应的类及代码如下：
open class UtilsAA: NSObject {
open var openA = 10
public var publicB = 199
var c = 1000
}
public class UtilsBB: NSObject{
open var openD = 10
public var publicE = 199
var F = 1000
}
class UtilsCC: NSObject {
open var openG = 10
public var publicH = 199
var i = 1000
}
CC这边不是用任何访问权限，那么对应的就是默认的internal。在不同的Module下面调用情况如下
代码如下：
override func viewDidLoad() {
super.viewDidLoad()
let a = UtilsAA.init()
print(a.openA)
print(a.publicB)
//error: 'c' is inaccessible due to 'internal' protection level
print(a.c)
let b = UtilsBB.init()
print(b.openD)
print(b.publicE)
//error:'F' is inaccessible due to 'internal' protection level
print(b.F)
//Cannot find 'UtilsCC' in scope
let c = UtilsCC.init()
}
也就是如果不使用访问修饰符或者使用了internal修饰符，那么可以在整个module都可以访问的到。
而open和public在module外都可以访问的到，再来说说这两个最大的区别就是能不能被继承和重写。我们不改变静态库里的代码，在使用静态库的地方分别对他进行继承看看效果：
效果如下：
class UtilsAAAA: UtilsAA {
func sayNumber() {
print(openA)
print(publicB)
}
}
//error:Cannot inherit from non-open class 'UtilsBB' outside of its defining module
class UtilsBBBB: UtilsBB{
func sayNumber() {
print(openD)
print(publicE)
}
}
Cannot inherit from non-open class ‘UtilsBB’ outside of its defining module中文意思为：无法从其定义模块之外的非开放类“UtilsBB”继承。也就是因为我们的UtilsBB这个类是用Public修饰的,而使用了Public的类在module外是不能被继承的，只有使用open修饰符才能在module外被继承。
再来看看重写的时候open和public的区别,同样的在静态库中增加
open class UtilsDD: NSObject {
open func UtilsDD_sayHello(){
print("say hello")
}
public func UtilsDD_sayHi(){
print("say Hi")
}
}
在调用静态库的时候重写里面的方法
class UtilsDDDD: UtilsDD {
//error: Overriding non-open instance method outside of its defining module
override func UtilsDD_sayHi() {
print("Override !!")
}
override func UtilsDD_sayHello() {
print("Override !!")
}
}
可见，Overriding non-open instance method outside of its defining module也已经告诉我们了，非open对象修饰的是不能被重写的。
都看到这了还不来一个一键三连？？？？？