从Swift 3.0.1开始，共有4个访问级别，从最高(限制最少)到最低(限制最多)。

---

1. 公开和公共

允许在定义模块(目标)之外使用一个实体。在指定框架的公共接口时，通常使用开放或公共访问。

然而，开放访问仅适用于类和类成员，它与公共访问的区别如下:

公共类和类成员只能在定义模块(目标)内进行子类化和重写。 开放类和类成员可以在定义模块(目标)内外被子类化和重写。

// First.framework – A.swift

open class A {}

// First.framework – B.swift

public class B: A {} // ok

// Second.framework – C.swift

import First

internal class C: A {} // ok

// Second.framework – D.swift

import First

internal class D: B {} // error: B cannot be subclassed

2. 内部

启用在定义模块(目标)中使用的实体。在定义应用程序或框架的内部结构时，通常使用内部访问。

// First.framework – A.swift

internal struct A {}

// First.framework – B.swift

A() // ok

// Second.framework – C.swift

import First

A() // error: A is unavailable

3.fileprivate

将实体的使用限制到其定义的源文件。当在整个文件中使用特定功能块的实现细节时，通常使用文件私有访问来隐藏这些细节。

// First.framework – A.swift

internal struct A {

    fileprivate static let x: Int

}

A.x // ok

// First.framework – B.swift

A.x // error: x is not available

4. 私人

将实体的使用限制在其封闭声明范围内。当只在单个声明中使用特定功能块的实现细节时，通常使用私有访问来隐藏这些细节。

// First.framework – A.swift

internal struct A {

    private static let x: Int

    internal static func doSomethingWithX() {
        x // ok
    }

}

A.x // error: x is unavailable

据我所知，没有关键词“公共”，“私人”或“受保护”。这意味着一切都是公开的。

然而，苹果可能希望人们使用“协议”(世界上其他地方称为接口)和工厂设计模式来隐藏实现类型的细节。

无论如何，这通常是一个很好的设计模式;因为它允许您更改实现类层次结构，同时保持逻辑类型系统不变。

Xcode 6中引入的访问控制机制:

Swift provides three different access levels for entities within your code. These access levels are relative to the source file in which an entity is defined, and also relative to the module that source file belongs to. Public access enables entities to be used within any source file from their defining module, and also in a source file from another module that imports the defining module. You typically use public access when specifying the public interface to a framework. Internal access enables entities to be used within any source file from their defining module, but not in any source file outside of that module. You typically use internal access when defining an app’s or a framework’s internal structure. Private access restricts the use of an entity to its own defining source file. Use private access to hide the implementation details of a specific piece of functionality. Public access is the highest (least restrictive) access level and private access is the lowest (or most restrictive) access level.

默认在内部访问，因此不需要指定。还要注意，私有说明符不是在类级别上工作，而是在源文件级别上工作。这意味着要使类的某些部分真正私有，您需要将其分离到自己的文件中。这也介绍了一些关于单元测试的有趣案例……

我提出的另一个观点(在上面的链接中有评论)是，你不能“升级”访问级别。如果你子类化了某个东西，你可以对它进行更多的限制，但反过来就不行。

最后一点也会影响函数、元组和其他东西，例如，如果一个函数使用了私有类，那么将函数设置为内部或公共是无效的，因为它们可能无法访问私有类。这将导致编译器警告，并且您需要将该函数重新声明为私有函数。

你可以使用的一个选项是将实例创建包装到一个函数中，并在构造函数中提供适当的getter和setter:

class Counter {
    let inc: () -> Int
    let dec: () -> Int

    init(start: Int) {
        var n = start

        inc = { ++n }
        dec = { --n }
    }
}


let c = Counter(start: 10)

c.inc()  // 11
c.inc()  // 12
c.dec()  // 11

语言语法没有关键字“public”，“private”或“protected”。这意味着一切都是公开的。当然，可以有一些替代方法来指定没有这些关键字的访问修饰符，但我在语言参考中找不到它。

希望为那些想要类似保护方法的人节省一些时间:

与其他答案一样，swift现在提供了“private”修饰符——它是按文件定义的，而不是像Java或c#那样按类定义的。这意味着如果你想要受保护的方法，如果它们在同一个文件中，你可以使用swift私有方法

创建一个基类来保存“受保护的”方法(实际上是私有的) 子类化这个类以使用相同的方法 在其他文件中，您不能访问基类方法，即使您创建了子类

文件1:

class BaseClass {
    private func protectedMethod() {
        
    }
}

class SubClass : BaseClass {
    func publicMethod() {
        self.protectedMethod()  //this is ok as they are in same file
    }
}

文件2:

func test() {
    var a = BaseClass()
    a.protectedMethod() //ERROR


    var b = SubClass()
    b.protectedMethod() //ERROR
}

class SubClass2 : BaseClass {
    func publicMethod() {
        self.protectedMethod() //ERROR
    }
}