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

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

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

// 注意: 为了简单起见, 对于代码中可以设置 访问级别的特定 ( 属性, 基本类型, 函数 等) 在下面的章节中我们会称为 '实体'

// 模块和源文件

// Swift 中的访问控制模型 基于模块和源文件 这两个概念

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

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

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

// 访问级别

// Swift 为代码中的实体提供了五种不同的访问级别, 这些访问级别不仅与源文件中定义的实体相关, 同时也与源文件所属的模块相关

// 1: 开放访问 和 公开访问 可以访问同一模块源文件中的任何实体, 在模块外也可以通过导入 该模块来访问源文件里的所有实体, 童话村那个情况下, 框架中的某个接口可以被任何人使用, 你可以将其设置 开放 或者公开访问

// 2: 内部访问 可以访问同一模块源文件中的任何实体, 但是不能从模块外访问该模块文件的实体, 通常情况下, 某个接口只在应用程序 或框架内部使用时, 你可以将其设置为 内部访问

// 3: 文件私有访问 限制实体只能被锁定义的文件内部使用, 当需要把这些细节被整个文件使用时, 使用私有文件私有访问隐藏了一些特定功能的实现细节

// 私有访问 限制实体只能在所定义的作用域内使用, 需要把这些细节被整个作用域使用的时候, 使用文件私有访问隐藏了一些特定的实现细节

// 开放访问为最高 (限制最少) 访问级别, 私有访问为最低 (限制最多) 访问级别

// 开放访问只作用于 类类型 和类的成员, 它和公开访问的区别如下

// 1: 公开访问或者 其他更严访问级别的类, 只能在他们定义的模块内部被继承

// 2: 公开访问或者 其他更严访问级别的类成员, 只能在他们定义的模块内部的子类中重写

// 3: 开放访问的类, 可以在他们定义的模块中被继承, 也可以在引用他们的模块中被继承

// 4: 开放访问的类成员, 可以在他们定义的模块中子类中重写, 也可以在引用他们的模块中的子类重写

// 访问级别基本原则

// Swift 中的访问级别遵循一个基本原则, 不可以 在某个实体中定义访问级别  更低的(更严格的)实体

// 一个公开访问级别的变量, 其类型的访问级别不能是内部, 文件私有或是 私有类型的, 因为无法保证变量的类型在使用变量的地方也具有访问权限

// 函数的访问级别不能高于他的参数类型和反馈类型的访问级别, 因为这样就会出现函数可以在任意地方呗访问, 但是他的参数类型和返回类型 却不可以的情况

// 默认访问级别

// 如果你不为代码中的实体显式指定访问级别, 那么他们默认为 internal(内部的) 级别, 因为, 在大多数情况下, 我们不需要显式指定实体的访问级别

// 单目标应用程序的访问级别

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

// 框架的访问级别

// 放你开发框架时候, 需要把一些对外的接口定义为开放访问 或者公开访问级别, 以便于使用者导入该框架的时候可以正常使用其功能, 这些定义对外的接口, 就是这个框架的 API

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

// 单元测试目标的访问级别

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

// 访问控制语法

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

public class SomePublicClass{}

internal class SomeInternalClass{}

fileprivate class SomeFilePrivateClass{}

private class SomePrivateClass{}

public var somePulicVariable = 0

internal let someInternalConstant = 0

fileprivate func someFilePrivateFunction(){}

private func somePrivateFunction(){}

// 除非专门指定, 否则实体默认的访问级别为内部访问级别

// 自定义类型

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

// 一个类型的访问级别也会影响到类型成员 (属性, 方法, 构造器, 下标) 的默认访问级别, 如果你将类型指定为私有 或者文件私有级别, 那么该类型的所有成员的默认访问级别也会变成 私有 或者文件私有级别, 如果你将类型指定为公开或者内部访问级别 (或者不明确指定访问级别, 而使用默认的内部访问级别), 那么该类型的所有成员的默认访问级别将是内部访问

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

// 元组类型

// 元组的访问级别将由元组中访问级别最严格的类型来决定, 例如, 如果你构建了一个包含两种不同类型的元机组, 其中一个类型为内部访问级别, 另一个类型为私有访问级别, 那么这个元组的访问级别是私有访问级别

// 注意 : 元组不同于类, 结构体, 枚举, 函数那样有单独的定义, 元组的访问级别是在他被使用时自动推断出来的, 而无法明确指定.

// 函数类型

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

// 枚举类型

// 枚举成员的访问级别和 该枚举的类型相同, 你不能为枚举成员单独指定不同的访问级别

// 原始值和关联值

// 枚举定义中的任何原始值 或关联值的类型的访问级别至少不能低于枚举类型的访问级别

// 嵌套类型

// 如果在 private 级别的类型中定义嵌套类型, 那么该嵌套类型就自动拥有 private 访问级别, 如果在 public 或者 internal 级别的类型中定义嵌套类型, 那么该嵌套类型自动拥有 internal 访问级别, 如果你想要嵌套类型拥有 public 访问级别, 那么需要明确指定该嵌套类型的访问级别

// 子类

// 子类的访问级别不得高于父类的访问级别, 例如,父类的访问级别是 internal , 子类的访问级别就不能是 public

// 常量, 变量, 属性, 下标

// 常量,变量,属性,不能拥有比他们的类型更高的访问级别, 例如, 你不能定义一个 public 级别的属性, 但是他们的类型却是 private 级别的, 同样下标也不能拥有比 索引类型 或返回类型更高的访问级别

// 如果常量,变量, 属性, 下标的类型是 private 级别的, 那么他们必须明确指定访问级别为 private

// Getter 和 Setter

// 常量,变量,属性,下标的 Getter 和 Setter 的访问级别和 他们所述类型的访问级别相同

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

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

struct TrackdeString{

private(set) var numberOfEdits = 0

var value: String = "" {

didSet{

numberOfEdits += 1

}

}

}

// TrackedString 结构体定义了一个用于存储 String 值的属性, value, 并将初始值设为 "" (一个空字符串), 该结构体还定义了另一个用于存储 Int 值的属性 numberOfEdits, 它用于记录属性 value 被修改的次数, 这个功能通过属性 value 的 didSet 观察器来实现, 每当给 value 赋新值的时候就会调用 didSet 方法, 然后将 numberOfEdits 的值加一

// 结构体 TrackedString 和它的属性 value 均没有显式指定访问级别, 所以它们都拥有默认的访问级别 internal ,但是该结构体的 numberOfEdits 属性使用 private(set) 修饰符, 这意味着 numberOfEdits 属性只能在定义该结构体的源文件中赋值, numberOfEdits 属性的 Getter 依然是默认的访问级别 internal, 但是 Seter 的访问级别是 private, 这表示该属性只有在当前的源文件中是可读可写的, 而在当前源文件所属的模块中只是一个可读的属性

// 构造器

// 自定义构造器的访问级别可以低于 或等于其所属类型的访问级别, 唯一的例外是 必要构造器, 他的访问级别必须和所属类型的访问级别相同

// 如同函数或方法的参数, 构造器参数的访问级别也不能低于构造器本身的访问级别

// 默认构造器

// Swift 会为结构体和类提供一个默认的无参数的构造器, 只要它们为所有存储型属性设置了默认初始值. 并且未提供自定义的构造器

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

// 结构体默认的成员逐一构造器

// 如果结构体中任意存储型属性的访问级别为 private，那么该结构体默认的成员逐一构造器的访问级别就是 private。否则，这种构造器的访问级别依然是 internal。

// 如同前面提到的默认构造器，如果你希望一个 public 级别的结构体也能在其他模块中使用其默认的成员逐一构造器，你依然只能自己提供一个 public 访问级别的成员逐一构造器。

// 协议

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

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

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

// 协议继承

// 如果定义了一个继承自其他协议的新协议，那么新协议拥有的访问级别最高也只能和被继承协议的访问级别相同。例如，你不能将继承自 internal 协议的新协议定义为 public 协议。

// 协议一致性

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

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

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

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

// 扩展

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

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

// 通过扩展添加协议一致性

// 如果你通过扩展来采纳协议，那么你就不能显式指定该扩展的访问级别了。协议拥有相应的访问级别，并会为该扩展中所有协议要求的实现提供默认的访问级别。

// 泛型

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

// 类型别名

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

// 注意

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