目录

[toc]

模块和源文件

• 模块：独立的代码单元
• 框架或应用程序会作为一个独立的模块来构建和发布
• 一个模块可以使用import关键字导入另外一个模块
• Xcode的每个target(例如框架或应用程序)都被当作独立的模块处理
• 源文件：Swift中的源代码文件

访问级别（低-->高）

• open: 类似public。可以被访问和被继承
• public: 可以访问同一模块源文件中的任何实体，在模块外也可以通过导入该模块来访问源文件里的所有实体。可以被访问不可以被继承
• internal: 可以访问同一模块源文件中的任何实体，但是不能从模块外访问该模块源文件中的实体。通常情况下，某个接口只在应用程序或框架内部使用时，你可以将其设置为internal级别。
• fileprivate: 限制实体只能在所在的源文件内部使用。
• private: 只在定义的实体中使用

• 访问级别基本原则：不可以在某个实体中定义访问级别更高的实体
• 函数的访问级别不能高于它的参数类型和返回类型的访问级别。
• 一般，默认为internal级别
• 在导入应用程序模块的语句前使用 @testable 特性，然后在允许测试的编译设置( Build Options -> Enable Testability )下编译这个应用程序模块，单元测试 target 就可以访问应用程序模块中所有 internal 级别的实体。

访问控制语法

通过修饰符open，public，internal，fileprivate，private来声明实体的访问级别：

public class SomePublicClass {}
internal class SomeInternalClass {}
fileprivate class SomeFilePrivateClass {}
private class SomePrivateClass {}

public var somePublicVariable = 0
internal let someInternalConstant = 0
fileprivate func someFilePrivateFunction() {}
private func somePrivateFunction() {}

除非专门指定，否则实体默认的访问级别为 internal。这意味着在不使用修饰符显式声明访问级别的情况下，SomeInternalClass和someInternalConstant仍然拥有隐式的internal：

class SomeInternalClass {}   // 隐式 internal
var someInternalConstant = 0 // 隐式 internal

自定义类型

• 一个类型的访问级别也会影响到类型成员（属性、方法、构造器、下标）的默认访问级别。
• 元组：元组的访问级别将由元组中访问级别最严格的类型来决定。
• 函数：函数的访问级别根据访问级别最严格的参数类型或返回类型的访问级别来决定。但是，如果这种访问级别不符合函数定义所在环境的默认访问级别，那么就需要明确地指定该函数的访问级别。
• 枚举类型：枚举成员的访问级别和该枚举类型相同，你不能为枚举成员单独指定不同的访问级别。枚举定义中的任何原始值或关联值的类型的访问级别至少不能低于枚举类型的访问级别。

public class SomePublicClass {                  // 显式 public 类
    public var somePublicProperty = 0            // 显式 public 类成员
    var someInternalProperty = 0                 // 隐式 internal 类成员
    fileprivate func someFilePrivateMethod() {}  // 显式 fileprivate 类成员
    private func somePrivateMethod() {}          // 显式 private 类成员
}

class SomeInternalClass {                       // 隐式 internal 类
    var someInternalProperty = 0                 // 隐式 internal 类成员
    fileprivate func someFilePrivateMethod() {}  // 显式 fileprivate 类成员
    private func somePrivateMethod() {}          // 显式 private 类成员
}

fileprivate class SomeFilePrivateClass {        // 显式 fileprivate 类
    func someFilePrivateMethod() {}              // 隐式 fileprivate 类成员
    private func somePrivateMethod() {}          // 显式 private 类成员
}

private class SomePrivateClass {                // 显式 private 类
    func somePrivateMethod() {}                  // 隐式 private 类成员
}

子类

• 子类的访问级别不得高于父类的访问级别。
• 可以在符合当前访问级别的条件下重写任意类成员（方法、属性、构造器、下标等）。

public class A {
    fileprivate func someMethod() {}
}
internal class B: A {
    override internal func someMethod() {
        super.someMethod()
    }
}

常量、变量、属性、下标

常量、变量、属性访问级别不能高于它们所属的类型。

struct TrackedString {
    private(set) var numberOfEdits = 0
    var value: String = "" {
        didSet {
            numberOfEdits += 1
        }
    }
}
var stringToEdit = TrackedString()
stringToEdit.value = "This string will be tracked."
stringToEdit.value += " This edit will increment numberOfEdits."
stringToEdit.value += " So will this one."
print("The number of edits is \(stringToEdit.numberOfEdits)")  
// 打印 “The number of edits is 3”
public struct TrackedString2 {
    public private(set) var numberOfEdits = 0                       
    // Getter的访问级别是public，Setter的访问级别是private。
    public var value: String = "" {
        didSet {
            numberOfEdits += 1
        }
    }
    public init() {}
}

构造器

必要构造器 的访问级别必须和所属类型相同。

默认构造器的访问级别与所属类型的访问级别相同，除非类型的访问级别是public。如果一个类型被指定为public级别，那么默认构造器的访问级别将为internal。如果你希望一个public级别的类型也能在其他模块中使用这种无参数的默认构造器，你只能自己提供一个public访问级别的无参数构造器。

协议

如果想为一个协议类型明确地指定访问级别，在定义协议时指定即可。这将限制该协议只能在适当的访问级别范围内被采纳。

协议中的每一个要求都具有和该协议相同的访问级别。你不能将协议中的要求设置为其他访问级别。这样才能确保该协议的所有要求对于任意采纳者都将可用。

注意：如果你定义了一个public访问级别的协议，那么该协议的所有实现也会是public访问级别。这一点不同于其他类型，例如，当类型是public访问级别时，其成员的访问级别却只是internal。

协议一致性

一个类型可以采纳比自身访问级别低的协议。例如，你可以定义一个public级别的类型，它可以在其他模块中使用，同时它也可以采纳一个internal级别的协议，但是只能在该协议所在的模块中作为符合该协议的类型使用。

采纳了协议的类型的访问级别取它本身和所采纳协议两者间最低的访问级别。也就是说如果一个类型是public级别，采纳的协议是internal级别，那么采纳了这个协议后，该类型作为符合协议的类型时，其访问级别也是internal。

如果你采纳了协议，那么实现了协议的所有要求后，你必须确保这些实现的访问级别不能低于协议的访问级别。例如，一个public级别的类型，采纳了internal级别的协议，那么协议的实现至少也得是internal级别。

注意：Swift和Objective-C一样，协议的一致性是全局的，也就是说，在同一程序中，一个类型不可能用两种不同的方式实现同一个协议。

Extension

Extension可以在访问级别允许的情况下对类、结构体、枚举进行扩展。Extension的成员具有和原始类型成员一致的访问级别。例如，你使用extension扩展了一个public或者internal类型，extension中的成员就默认使用internal访问级别，和原始类型中的成员一致。如果你使用extension扩展了一个private类型，则extension的成员默认使用private访问级别。

或者，你可以明确指定extension的访问级别（例如，private extension），从而给该extension中的所有成员指定一个新的默认访问级别。这个新的默认访问级别仍然可以被单独指定的访问级别所覆盖。

如果你使用extension来遵循协议的话，就不能显式地声明extension的访问级别。extension每个protocol要求的实现都默认使用protocol的访问级别。

Extension的私有成员

扩展同一文件内的类，结构体或者枚举，extension里的代码会表现得跟声明在原类型里的一模一样。也就是说你可以这样：

• 在类型的声明里声明一个私有成员，在同一文件的extension里访问。
• 在extension里声明一个私有成员，在同一文件的另一个extension里访问。
• 在extension里声明一个私有成员，在同一文件的类型声明里访问。

这意味着你可以像组织的代码去使用extension，而且不受私有成员的影响。例如，给定下面这样一个简单的协议：

protocol SomeProtocol {
    func doSomething() -> Void
}

你可以使用 extension 来遵守协议，就想这样：

struct SomeStruct {
    private var privateVariable = 12
}

extension SomeStruct: SomeProtocol {
    func doSomething() {
        print(privateVariable)
    }
}

泛型

泛型类型或泛型函数的访问级别取决于泛型类型或泛型函数本身的访问级别，还需结合类型参数的类型约束的访问级别，根据这些访问级别中的最低访问级别来确定。

类型别名

类型别名的访问级别不可高于其表示的类型的访问级别