您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 程式設計技術

Swift 學習筆記(九):訪問控制全解析

編輯:iOS 程式設計技術

一、Swift 的訪問控制

Swift 的訪問控制模型建立在模組(module)與原始檔(source file)這兩個概念之上。

  1. 模組
    指的是 Framework 或 App bundle。在 Swift 中,可以用 import 關鍵字引入自己的工程。
  2. 原始檔
    指的是 Swift 中編寫程式碼的 .swift 檔,它通常隸屬於某一個模組。
Swift 提供了五種訪問級別(由低到高):
  • private:僅能在當前原始檔(或宣告的作用域)內訪問,用於隱藏實作細節。
  • fileprivate:僅能在當前檔案內訪問。
  • internal:【使用 internal 修飾】【範圍中】
    可訪問當前模組中的任何實體,但模組外無法訪問,這是所有實體的預設訪問級別(通常在單一 target 的 Application 中無須自行設定)。
  • public:【使用 public 修飾】【範圍大】
    可訪問當前模組及其他模組中的任何實體(通常用於 Framework),但預設不可被子模組繼承或覆寫。
  • open:範圍最大,允許其他模組繼承與覆寫,僅用於類別與類別成員。

訪問級別從低到高大致為:private < fileprivate < internal < public < open。

訪問控制的使用規則相當繁瑣,這裡先做一次歸納:
  1. 【成員(屬性和方法)<= 類】
  2. 【(常量、變量、屬性、下標腳本)<= 類型】
  3. 【Setter <= Getter】
  4. 【required 方法 == 類】【預設逐一構造函數 <= 所有成員】
  5. 【子類 <= 父類】【子協議 <= 父協議】
  6. 子類重寫父類成員時可調整訪問範圍
  7. 【協議成員 == 協議】【類 >= 協議】【協議實作 >= 協議要求】
  8. 【元組 = Min(所有元素類型)】
  9. 【函數 = Min(參數類型、回傳值類型)】
  10. 【枚舉成員 == 枚舉】【(原始值、關聯值)>= 枚舉】
  11. 【泛型類型 = Min(類類型、泛型參數)】
  12. 【類型別名 <= 原類型】

二、訪問控制使用規則詳解

1.【成員(屬性和方法)<= 類】
/* 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.【(常量、變量、屬性、下標腳本)<= 類型】
/* 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】
/* 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 方法 == 類】【預設逐一構造函數 <= 所有成員】
/* 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.【子類 <= 父類】【子協議 <= 父協議】
/* 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. 子類重寫父類成員以調整訪問範圍
/* 6.不違反前面規則,子類可透過重寫父類方法來調整訪問權限範圍 */
public class OverrideSuperClass {
    private func someMethod() {}
}
internal class OverrideSubClass: OverrideSuperClass {
    override internal func someMethod() {
        super.someMethod() // 子類和父類在同一個源文件中,所以可以訪問 super 的 someMethod()
    }
}
7.【協議成員 == 協議】【類 >= 協議】【協議實作 >= 協議要求】
/* 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(所有元素類型)】
/* 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(參數類型、回傳值類型)】
/* 9.【函數 = Min(參數類型,回傳值類型)】 */
private func someFunction(value: SomeInternalClass) -> SomePrivateClass {
    return SomePrivateClass()
}
10.【枚舉成員 == 枚舉】【(原始值、關聯值)>= 枚舉】
/* 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(類類型、泛型參數)】
/* 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.【類型別名 <= 原類型】
/* 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()
}
有任何問題都歡迎在下方評論區提出!O(∩_∩)O 哈!
  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved