24, access control

2016-11-13 20:04:29 +08:00
parent 882d38c792
commit e130059ba0
1 changed files with 69 additions and 64 deletions
--- a/source/chapter2/24_Access_Control.md
+++ b/source/chapter2/24_Access_Control.md
@ -1,4 +1,4 @@
-# 访问控制（Access Control）
+# 访问控制
 ------------------

 > 1.0
@ -13,42 +13,28 @@
 > 校对：[shanks](http://codebuild.me)，2015-11-01
 > 
 > 2.2 
-> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-17
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-17   
+> 3.0.1， shanks，2016-11-13

 本页内容包括：

 - [模块和源文件](#modules_and_source_files)
 - [访问级别](#access_levels)
-  -  [访问级别基本原则](#guiding_principle_of_access_levels)
-  -  [默认访问级别](#default_access_levels)
-  -  [单 target 应用程序的访问级别](#access_levels_for_single-target_apps)
-  -  [框架的访问级别](#access_levels_for_frameworks)
-  -  [单元测试 target 的访问级别](#access_levels_for_unit_test_targets)
 - [访问控制语法](#access_control_syntax)
 - [自定义类型](#custom_types)
-  -  [元组类型](#tuple_types)
-  -  [函数类型](#function_types)
-  -  [枚举类型](#enumeration_types)
-  -  [嵌套类型](#nested_types)
 - [子类](#subclassing)
 - [常量、变量、属性、下标](#constants_variables_properties_subscripts)
-  -  [Getter和Setter](#getters_and_setters)
 - [构造器](#initializers)
-  -  [默认构造器](#default_initializers)
-  -  [结构体默认的成员逐一构造器](#default_memberwise_initializers_for_structure_types)
 - [协议](#protocols)
-  -  [协议继承](#protocol_inheritance)
-  -  [协议一致性](#protocol_conformance)
 - [扩展](#extensions)
-  -  [通过扩展添加协议一致性](#adding_protocol_conformance_with_an_extension)
 - [泛型](#generics)
 - [类型别名](#type_aliases)

-访问控制可以限定其他源文件或模块中的代码对你的代码的访问级别。这个特性可以让我们隐藏代码的一些实现细节，并且可以为其他人可以访问和使用的代码提供接口。
+*访问控制*可以限定其他源文件或模块中的代码对你的代码的访问级别。这个特性可以让我们隐藏代码的一些实现细节，并且可以为其他人可以访问和使用的代码提供接口。

 你可以明确地给单个类型（类、结构体、枚举）设置访问级别，也可以给这些类型的属性、方法、构造器、下标等设置访问级别。协议也可以被限定在一定的范围内使用，包括协议里的全局常量、变量和函数。

-Swift 不仅提供了多种不同的访问级别，还为某些典型场景提供了默认的访问级别，这样就不需要我们在每段代码中都申明显式访问级别。其实，如果只是开发一个单一 target 的应用程序，我们完全可以不用显式申明代码的访问级别。
+Swift 不仅提供了多种不同的访问级别，还为某些典型场景提供了默认的访问级别，这样就不需要我们在每段代码中都申明显式访问级别。其实，如果只是开发一个单一目标的应用程序，我们完全可以不用显式声明代码的访问级别。

 > 注意  
 为了简单起见，对于代码中可以设置访问级别的特性（属性、基本类型、函数等），在下面的章节中我们会称之为“实体”。
@ -59,32 +45,41 @@ Swift 中的访问控制模型基于模块和源文件这两个概念。

 模块指的是独立的代码单元，框架或应用程序会作为一个独立的模块来构建和发布。在 Swift 中，一个模块可以使用 `import` 关键字导入另外一个模块。

-在 Swift 中，Xcode 的每个 target（例如框架或应用程序）都被当作独立的模块处理。如果你是为了实现某个通用的功能，或者是为了封装一些常用方法而将代码打包成独立的框架，这个框架就是 Swift 中的一个模块。当它被导入到某个应用程序或者其他框架时，框架内容都将属于这个独立的模块。  
+在 Swift 中，Xcode 的每个目标（例如框架或应用程序）都被当作独立的模块处理。如果你是为了实现某个通用的功能，或者是为了封装一些常用方法而将代码打包成独立的框架，这个框架就是 Swift 中的一个模块。当它被导入到某个应用程序或者其他框架时，框架内容都将属于这个独立的模块。  

-源文件就是 Swift 中的源代码文件，它通常属于一个模块，即一个应用程序或者框架。尽管我们一般会将不同的类型分别定义在不同的源文件中，但是同一个源文件也可以包含多个类型、函数之类的定义。
+*源文件*就是 Swift 中的源代码文件，它通常属于一个模块，即一个应用程序或者框架。尽管我们一般会将不同的类型分别定义在不同的源文件中，但是同一个源文件也可以包含多个类型、函数之类的定义。

 <a name="access_levels"></a>
 ## 访问级别
-Swift 为代码中的实体提供了三种不同的访问级别。这些访问级别不仅与源文件中定义的实体相关，同时也与源文件所属的模块相关。
+Swift 为代码中的实体提供了五种不同的*访问级别*。这些访问级别不仅与源文件中定义的实体相关，同时也与源文件所属的模块相关。

- `public`：可以访问同一模块源文件中的任何实体，在模块外也可以通过导入该模块来访问源文件里的所有实体。通常情况下，框架中的某个接口可以被任何人使用时，你可以将其设置为 `public` 级别。
- `internal`：可以访问同一模块源文件中的任何实体，但是不能从模块外访问该模块源文件中的实体。通常情况下，某个接口只在应用程序或框架内部使用时，你可以将其设置为 `internal` 级别。
- `private`：限制实体只能在所在的源文件内部使用。使用 `private` 级别可以隐藏某些功能的实现细节。
+- *开放访问*和*公开访问*可以访问同一模块源文件中的任何实体，在模块外也可以通过导入该模块来访问源文件里的所有实体。通常情况下，框架中的某个接口可以被任何人使用时，你可以将其设置为开放或者公开访问。
+- *内部访问*可以访问同一模块源文件中的任何实体，但是不能从模块外访问该模块源文件中的实体。通常情况下，某个接口只在应用程序或框架内部使用时，你可以将其设置为内部访问。
+- *文件私有访问*限制实体只能被所定义的文件内部访问。当需要把这些细节被整个文件使用的时候，使用文件私有访问隐藏了一些特定功能的实现细节。
+- *私有访问*限制实体只能在所定义的作用域内使用。需要把这些细节被整个作用域使用的时候，使用文件私有访问隐藏了一些特定功能的实现细节。

-`public` 为最高（限制最少）访问级别，`private` 为最低（限制最多）访问级别。
+开放访问为最高（限制最少）访问级别，私有访问为最低（限制最多）访问级别。

-> 注意  
-Swift 中的 `private` 访问级别不同于其他语言，它的范围限于源文件，而不是声明范围内。这就意味着，一个类型可以访问其所在源文件中的所有 `private` 实体，但是如果它的扩展定义在其他源文件中，那么它的扩展就不能访问它在这个源文件中定义的 `private` 实体。
+开放访问只作用于类类型和类的成员，它和公开访问的区别如下：
+
+* 公开访问或者其他更严访问级别的类，只能在它们定义的模块内部被继承。
+* 公开访问或者其他更严访问级别的类成员，只能在它们定义的模块内部的子类中重写。
+* 开放访问的类，可以在它们定义的模块中被继承，也可以在引用它们的模块中被继承。
+* 开放访问的类成员，可以在它们定义的模块中子类中重写，也可以在引用它们的模块中的子类重写。
+* 
+把一个类标记为开放，显式地表明，你认为其他模块中的代码使用此类作为父类，然后你已经设计好了你的类的代码了。

 <a name="guiding_principle_of_access_levels"></a>
 ### 访问级别基本原则

-Swift 中的访问级别遵循一个基本原则：不可以在某个实体中定义访问级别更高的实体。
+Swift 中的访问级别遵循一个基本原则：*不可以在某个实体中定义访问级别更低（更严格）的实体*。

 例如：

- 一个 `public` 访问级别的变量，其类型的访问级别不能是 `internal` 或 `private`。因为无法保证变量的类型在使用变量的地方也具有访问权限。
- 函数的访问级别不能高于它的参数类型和返回类型的访问级别。因为如果函数定义为 `public` 而参数类型或者返回类型定义为 `internal` 或 `private`，就会出现函数可以在任何地方被访问，但是它的参数类型和返回类型却不可以。
+- 一个公开访问级别的变量，其类型的访问级别不能是内部，文件私有或是私有类型的。因为无法保证变量的类型在使用变量的地方也具有访问权限。
+- 函数的访问级别不能高于它的参数类型和返回类型的访问级别。因为这样就会出现函数可以在任何地方被访问，但是它的参数类型和返回类型却不可以的情况。
+
+关于此原则的各种情况的具体实现，将在下面的细节中体现。

 <a name="default_access_levels"></a>
 ### 默认访问级别
@ -92,75 +87,85 @@ Swift 中的访问级别遵循一个基本原则：不可以在某个实体中
 如果你不为代码中的实体显式指定访问级别，那么它们默认为 `internal` 级别（有一些例外情况，稍后会进行说明）。因此，在大多数情况下，我们不需要显式指定实体的访问级别。

 <a name="access_levels_for_single-target_apps"></a>
-### 单 target 应用程序的访问级别
+### 单目标应用程序的访问级别

-当你编写一个单 target 应用程序时，应用的所有功能都是为该应用服务，而不需要提供给其他应用或者模块使用，所以我们不需要明确设置访问级别，使用默认的访问级别 `internal` 即可。但是，你也可以使用 `private` 级别，用于隐藏一些功能的实现细节。
+当你编写一个单目标应用程序时，应用的所有功能都是为该应用服务，而不需要提供给其他应用或者模块使用，所以我们不需要明确设置访问级别，使用默认的访问级别 `internal` 即可。但是，你也可以使用文件私有访问或私有访问级别，用于隐藏一些功能的实现细节。

 <a name="access_levels_for_frameworks"></a>
 ### 框架的访问级别

-当你开发框架时，就需要把一些对外的接口定义为 `public` 级别，以便使用者导入该框架后可以正常使用其功能。这些被你定义为 `public` 的接口，就是这个框架的 API。
+当你开发框架时，就需要把一些对外的接口定义为开放访问或公开访问级别，以便使用者导入该框架后可以正常使用其功能。这些被你定义为对外的接口，就是这个框架的 API。

 > 注意  
-框架依然会使用默认的 `internal` 级别，也可以指定为 `private` 级别。当你想把某个实体作为框架的 API 的时候，需显式为其指定 `public` 级别。
+框架依然会使用默认的内部访问级别，也可以指定为文件私有访问或者私有访问级别。当你想把某个实体作为框架的 API 的时候，需显式为其指定开放访问或公开访问级别。

 <a name="access_levels_for_unit_test_targets"></a>
-### 单元测试 target 的访问级别
+### 单元测试目标的访问级别

-当你的应用程序包含单元测试 target 时，为了测试，测试模块需要访问应用程序模块中的代码。默认情况下只有 `public` 级别的实体才可以被其他模块访问。然而，如果在导入应用程序模块的语句前使用 `@testable` 特性，然后在允许测试的编译设置（`Build Options -> Enable Testability`）下编译这个应用程序模块，单元测试 target 就可以访问应用程序模块中所有 `internal` 级别的实体。
+当你的应用程序包含单元测试目标时，为了测试，测试模块需要访问应用程序模块中的代码。默认情况下只有开放访问或公开访问级别级别的实体才可以被其他模块访问。然而，如果在导入应用程序模块的语句前使用 `@testable` 特性，然后在允许测试的编译设置（`Build Options -> Enable Testability`）下编译这个应用程序模块，单元测试目标就可以访问应用程序模块中所有内部级别的实体。

 <a name="access_control_syntax"></a>
 ## 访问控制语法

-通过修饰符 `public`、`internal`、`private` 来声明实体的访问级别：
+通过修饰符 `open`，`public`，`internal`，`filepart`，`private` 来声明实体的访问级别：

 ```swift
 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`，可以查阅[默认访问级别](#default_access_levels)这一节。这意味着在不使用修饰符显式声明访问级别的情况下，`SomeInternalClass` 和 `someInternalConstant` 仍然拥有隐式的访问级别 `internal`：
+除非专门指定，否则实体默认的访问级别为内部访问级别，可以查阅[默认访问级别](#default_access_levels)这一节。这意味着在不使用修饰符显式声明访问级别的情况下，`SomeInternalClass` 和 `someInternalConstant` 仍然拥有隐式的内部访问级别：

 ```swift
-class SomeInternalClass {}   // 隐式访问级别 internal
-var someInternalConstant = 0 // 隐式访问级别 internal
+class SomeInternalClass {}   // 隐式内部访问级别
+var someInternalConstant = 0 // 隐式内部访问级别
 ```
+
 <a name="custom_types"></a>
 ## 自定义类型

-如果想为一个自定义类型指定访问级别，在定义类型时进行指定即可。新类型只能在它的访问级别限制范围内使用。例如，你定义了一个 `private` 级别的类，那这个类就只能在定义它的源文件中使用，可以作为属性类型、函数参数类型或者返回类型，等等。
+如果想为一个自定义类型指定访问级别，在定义类型时进行指定即可。新类型只能在它的访问级别限制范围内使用。例如，你定义了一个文件私有级别的类，那这个类就只能在定义它的源文件中使用，可以作为属性类型、函数参数类型或者返回类型，等等。

-一个类型的访问级别也会影响到类型成员（属性、方法、构造器、下标）的默认访问级别。如果你将类型指定为 `private` 级别，那么该类型的所有成员的默认访问级别也会变成 `private`。如果你将类型指定为 `public` 或者 `internal` 级别（或者不明确指定访问级别，而使用默认的 `internal` 访问级别），那么该类型的所有成员的默认访问级别将是 `internal`。
+一个类型的访问级别也会影响到类型*成员*（属性、方法、构造器、下标）的默认访问级别。如果你将类型指定为私有或者文件私有级别，那么该类型的所有成员的默认访问级别也会变成私有或者文件私有级别。如果你将类型指定为公开或者内部访问级别（或者不明确指定访问级别，而使用默认的内部访问级别），那么该类型的所有成员的默认访问级别将是内部访问。

-> 注意  
-上面提到，一个 `public` 类型的所有成员的访问级别默认为 `internal` 级别，而不是 `public` 级别。如果你想将某个成员指定为 `public` 级别，那么你必须显式指定。这样做的好处是，在你定义公共接口的时候，可以明确地选择哪些接口是需要公开的，哪些是内部使用的，避免不小心将内部使用的接口公开。
+> 重要    
+上面提到，一个公开类型的所有成员的访问级别默认为内部访问级别，而不是公开级别。如果你想将某个成员指定为公开访问级别，那么你必须显式指定。这样做的好处是，在你定义公共接口的时候，可以明确地选择哪些接口是需要公开的，哪些是内部使用的，避免不小心将内部使用的接口公开。

 ```swift
-public class SomePublicClass {          // 显式的 public 类
-   	public var somePublicProperty = 0   // 显式的 public 类成员
-   	var someInternalProperty = 0        // 隐式的 internal 类成员
-   	private func somePrivateMethod() {} // 显式的 private 类成员
+public class SomePublicClass {                  // 显式公开类
+    public var somePublicProperty = 0            // 显式公开类成员
+    var someInternalProperty = 0                 // 隐式内部类成员
+    fileprivate func someFilePrivateMethod() {}  // 显式文件私有类成员
+    private func somePrivateMethod() {}          // 显式私有类成员
+}
+ 
+class SomeInternalClass {                       // 隐式内部类
+    var someInternalProperty = 0                 // 隐式内部类成员
+    fileprivate func someFilePrivateMethod() {}  // 显式文件私有类成员
+    private func somePrivateMethod() {}          // 显式私有类成员
+}
+ 
+fileprivate class SomeFilePrivateClass {        // 显式文件私有类
+    func someFilePrivateMethod() {}              // 隐式文件私有类成员
+    private func somePrivateMethod() {}          // 显式私有类成员
+}
+ 
+private class SomePrivateClass {                // 显式私有类
+    func somePrivateMethod() {}                  // 隐式私有类成员
 }

-class SomeInternalClass {               // 隐式的 internal 类
-   	var someInternalProperty = 0        // 隐式的 internal 类成员
-   	private func somePrivateMethod() {} // 显式的 private 类成员
-}
-
-private class SomePrivateClass {        // 显式的 private 类
-   	var somePrivateProperty = 0         // 隐式的 private 类成员
-   	func somePrivateMethod() {}         // 隐式的 private 类成员
-}
 ```
 <a name="tuple_types"></a>
 ### 元组类型

-元组的访问级别将由元组中访问级别最严格的类型来决定。例如，如果你构建了一个包含两种不同类型的元组，其中一个类型为 `internal` 级别，另一个类型为 `private` 级别，那么这个元组的访问级别为 `private`。
+元组的访问级别将由元组中访问级别最严格的类型来决定。例如，如果你构建了一个包含两种不同类型的元组，其中一个类型为内部访问级别，另一个类型为私有访问级别，那么这个元组的访问级别为私有访问级别。

 > 注意  
 元组不同于类、结构体、枚举、函数那样有单独的定义。元组的访问级别是在它被使用时自动推断出的，而无法明确指定。
@ -170,7 +175,7 @@ private class SomePrivateClass {        // 显式的 private 类

 函数的访问级别根据访问级别最严格的参数类型或返回类型的访问级别来决定。但是，如果这种访问级别不符合函数定义所在环境的默认访问级别，那么就需要明确地指定该函数的访问级别。

-下面的例子定义了一个名为 `someFunction` 的全局函数，并且没有明确地指定其访问级别。也许你会认为该函数应该拥有默认的访问级别 `internal`，但事实并非如此。事实上，如果按下面这种写法，代码将无法通过编译：
+下面的例子定义了一个名为 `someFunction()` 的全局函数，并且没有明确地指定其访问级别。也许你会认为该函数应该拥有默认的访问级别 `internal`，但事实并非如此。事实上，如果按下面这种写法，代码将无法通过编译：

 ```swift
 func someFunction() -> (SomeInternalClass, SomePrivateClass) {
@ -267,10 +272,10 @@ private var privateInstance = SomePrivateClass()

 常量、变量、属性、下标的 `Getters` 和 `Setters` 的访问级别和它们所属类型的访问级别相同。

-`Setter` 的访问级别可以低于对应的 `Getter` 的访问级别，这样就可以控制变量、属性或下标的读写权限。在 `var` 或 `subscript` 关键字之前，你可以通过 `private(set)` 或 `internal(set)` 为它们的写入权限指定更低的访问级别。
+`Setter` 的访问级别可以低于对应的 `Getter` 的访问级别，这样就可以控制变量、属性或下标的读写权限。在 `var` 或 `subscript` 关键字之前，你可以通过 `fileprivate(set)`，`private(set)` 或 `internal(set)` 为它们的写入权限指定更低的访问级别。

 > 注意  
-这个规则同时适用于存储型属性和计算型属性。即使你不明确指定存储型属性的 `Getter` 和 `Setter`，Swift 也会隐式地为其创建 `Getter` 和 `Setter`，用于访问该属性的后备存储。使用 `private(set)` 和 `internal(set)` 可以改变 `Setter` 的访问级别，这对计算型属性也同样适用。  
+这个规则同时适用于存储型属性和计算型属性。即使你不明确指定存储型属性的 `Getter` 和 `Setter`，Swift 也会隐式地为其创建 `Getter` 和 `Setter`，用于访问该属性的后备存储。使用 `fileprivate(set)`，`private(set)` 和 `internal(set)` 可以改变 `Setter` 的访问级别，这对计算型属性也同样适用。  

 下面的例子中定义了一个名为 `TrackedString` 的结构体，它记录了 `value` 属性被修改的次数：

@ -384,7 +389,7 @@ Swift 和 Objective-C 一样，协议的一致性是全局的，也就是说，
 <a name="type_aliases"></a>
 ## 类型别名

-你定义的任何类型别名都会被当作不同的类型，以便于进行访问控制。类型别名的访问级别不可高于其表示的类型的访问级别。例如，`private` 级别的类型别名可以作为 `public`、`internal`、`private` 类型的别名，但是 `public` 级别的类型别名只能作为 `public` 类型的别名，不能作为 `internal` 或 `private` 类型的别名。
+你定义的任何类型别名都会被当作不同的类型，以便于进行访问控制。类型别名的访问级别不可高于其表示的类型的访问级别。例如，`private` 级别的类型别名可以作为 `private`，`file-private`，`internal`，`public`或者`open`类型的别名，但是 `public` 级别的类型别名只能作为 `public` 类型的别名，不能作为 `internal`，`file-private`，或 `private` 类型的别名。

 > 注意  
 这条规则也适用于为满足协议一致性而将类型别名用于关联类型的情况。