Swift 的訪問控制模型建立在模組(module)與原始檔(source file)這兩個概念之上。
private:僅能在當前原始檔(或宣告的作用域)內訪問,用於隱藏實作細節。fileprivate:僅能在當前檔案內訪問。internal:【使用 internal 修飾】【範圍中】public:【使用 public 修飾】【範圍大】open:範圍最大,允許其他模組繼承與覆寫,僅用於類別與類別成員。訪問級別從低到高大致為:private < fileprivate < internal < public < open。
/* 1.【成員(屬性和方法) <= 類】
若將類宣告為 private,則該類所有成員的預設訪問級別也成為 private;
若將類宣告為 public 或 internal,則該類所有成員的預設訪問級別為 internal。 */
public class SomePublicClass {
public var somePublicProperty = 0 // 顯式的 public 類成員
var someInternalProperty = 0 // 隱式的 internal 類成員
internal var someInternalProperty2 = 0 // 顯式的 internal 類成員
private func somePrivateMethod() {} // 顯式的 private 類成員
}
internal class SomeInternalClass {
var someInternalProperty = 0 // 隱式的 internal 類成員
private func somePrivateMethod() {} // 顯式的 private 類成員
// Error:-> public var somePublicProperty = 0
}
private class SomePrivateClass {
var somePrivateProperty = 0 // 隱式的 private 類成員
func somePrivateMethod() {} // 隱式的 private 類成員
// Error:-> public var somePublicProperty = 0
// Error:-> internal var someInternalProperty = 0
}
/* 2.【(常量、變量、屬性、下標腳本) <= 自己類型】 */
private let somePrivate1 = SomePrivateClass() // 變量 private <= 類型 private
private let somePrivate2 = SomeInternalClass() // 變量 private <= 類型 internal
private let somePrivate3 = SomePublicClass() // 變量 private <= 類型 public
// Error:internal let someInternal1 = SomePrivateClass() // internal 大於 private,錯誤
internal let someInternal2 = SomeInternalClass() // internal <= internal
internal let someInternal3 = SomePublicClass() // internal <= public
// Error:public let somePublic1 = SomePrivateClass() // public 大於 private,錯誤
// Error:public let somePublic2 = SomeInternalClass() // public 大於 internal,錯誤
public let somePublic3 = SomePublicClass() // public <= public
/* 3.【setter <= getter】,private(set) 修飾將 setter 權限設為 private */
/* 此規則適用於用作儲存的屬性或用作計算的屬性。
即使不明確宣告儲存屬性的 Getter、Setter,Swift 也會隱式地為其建立。 */
public class SetterPrivateClass { // 該類可在任何模組中使用
private(set) var value = 0 // 將儲存屬性的 setter 設為 private
// 將計算屬性的 setter 設為 private
private(set) var setPrivateProperty: Int {
set { // 此時 setter 為 private,只能在本文件中使用
value = newValue + 1
}
get { // getter 預設為 internal
return value + 1
}
}
}
/* 4.【required 修飾的方法 == 類】,(結構體)【預設逐一構造函數 <= 所有成員】 */
protocol RequiredTestProtocol {
init(aprot: Int) // 初始化構造器要求
}
public class RequiredTestClass: RequiredTestProtocol {
var aprot: Int // 預設為 internal
// 實作協議的初始化要求時,必須使用 required 關鍵字確保子類也得實作此構造器
public required init(aprot: Int) { // 此時必須設為 public,因為預設是 internal
self.aprot = aprot
}
}
// 該結構體的預設逐一構造方法為 private,但預設構造方法還是 internal
public struct StructInitTest {
private var somePrivateProperty = 0
internal var someInternalProperty = 0
public var somePublicProperty = 0
}
/* 5.【子類 <= 父類】,【子協議 <= 父協議】 */
private class PrivateSuperClass { }
internal class InternalSuperClass { }
public class PublicSuperClass { }
private class PrivateSubClass1: PrivateSuperClass { } // private <= private
private class PrivateSubClass2: InternalSuperClass { } // private <= internal
private class PrivateSubClass3: PublicSuperClass { } // private <= public
// Error:internal class InternalSubClass1: PrivateSuperClass { } // internal 大於 private
internal class InternalSubClass2: InternalSuperClass { }
internal class InternalSubClass3: PublicSuperClass { }
// Error:public class PublicSubClass1: PrivateSuperClass { } // public 大於 private
// Error:public class PublicSubClass2: InternalSuperClass { } // public 大於 internal
public class PublicSubClass3: PublicSuperClass { }
/* 6.不違反前面規則,子類可透過重寫父類方法來調整訪問權限範圍 */
public class OverrideSuperClass {
private func someMethod() {}
}
internal class OverrideSubClass: OverrideSuperClass {
override internal func someMethod() {
super.someMethod() // 子類和父類在同一個源文件中,所以可以訪問 super 的 someMethod()
}
}
/* 7.【協議所有必須實作的成員 == 協議】,【類 >= 協議】,【協議實作 >= 協議要求】 */
internal protocol InternalProtocol {
// 協議成員不可添加訪問控制關鍵字,預設等於協議的訪問權限範圍
var someProperty: Int { get set }
func someMethod()
}
// 類必須大於或等於要遵循的協議
public class ProtocolTestClass: InternalProtocol {
// Error:-> private var someProperty = 0 // 協議實作必須大於或等於協議要求
public var someProperty = 0
internal func someMethod() {
print("ProtocolTestClass someMethod")
}
}
/* 8.【元組 = Min(所有元素類型)】,注意是類型而不是變量 */
private var privateValue = SomePrivateClass()
var internalValue = SomeInternalClass()
var publicValue = SomePublicClass()
// 這裡變量是 internal 的,但類型是 public 的
private let privateTupleValue = (privateValue, internalValue, publicValue)
internal let internalTupleValue = (internalValue, internalValue, publicValue)
public let publicTupleValue = (publicValue, publicValue, publicValue)
/* 9.【函數 = Min(參數類型,回傳值類型)】 */
private func someFunction(value: SomeInternalClass) -> SomePrivateClass {
return SomePrivateClass()
}
/* 10.【枚舉成員 == 枚舉】,枚舉成員無法單獨設置訪問級別,【(原始值,關聯值) >= 枚舉】 */
private enum PrivateEnum {
case PrivateEnumCase(SomePrivateClass)
case InternalEnumCase(SomeInternalClass)
case PublicEnumCase(SomePublicClass)
}
internal enum InternalEnum {
// Error:-> case PrivateEnumCase(SomePrivateClass) // 關聯值必須大於等於枚舉
case InternalEnumCase(SomeInternalClass)
case PublicEnumCase(SomePublicClass)
}
/* 11.【泛型類型 = Min(類類型,泛型參數)】 */
public class GenericityClass<T> {
var value = [T]()
func someFunction(value: T) { }
}
private let genericityPrivate = GenericityClass<SomePrivateClass>() // 泛型類型為 private
internal let genericityInternal = GenericityClass<SomeInternalClass>() // 泛型類型為 internal
public let genericityPublic = GenericityClass<SomePublicClass>() // 泛型類型為 public
// Error:public let genericityInternal = GenericityClass<SomeInternalClass>() // 泛型類型為 internal
/* 12.【類型別名 <= 原類型】 */
// 包含類型別名的類,遵循【成員 <= 類】
public class MyClass {
private typealias privateName1 = SomePrivateClass
private typealias privateName2 = SomeInternalClass
private typealias privateName3 = SomePublicClass
// internal 的類型別名可以是 internal、public 的類型,不可以是 private 類型
// Error:-> internal typealias internalName1 = SomePrivateClass
internal typealias internalName2 = SomeInternalClass
internal typealias internalName3 = SomePublicClass
// public 的類型別名只能是 public 的類型
// Error:-> public typealias publicName1 = SomePrivateClass
// Error:-> public typealias publicName2 = SomeInternalClass
public typealias publicName3 = SomePublicClass
private var someProperty = privateName1()
}