在 Objective-C 中，实例数据可以是 public、protected 或 private。例如：
@interface Foo : NSObject
{
@public
int x;
@protected:
int y;
@private:
int z;
}
-(int) apple;
-(int) pear;
-(int) banana;
@end
我在Swift参考文档中没有找到任何关于访问修饰符的提及。在Swift中是否可能限制数据的可见性？
从 Swift 3.0.1 开始，有4个访问级别，从最高（最不限制的）到最低（最限制的）分别描述如下。
open 和 public允许实体在定义模块（目标）之外使用。通常在为框架指定公共接口时使用open或public 访问。
然而，open 访问仅适用于类和类成员，与 public 访问不同如下：
public 类和类成员只能在定义模块（目标）内进行子类化和重写。open 类和类成员可在定义模块（目标）内外进行子类化和重写。// 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
internalinternal允许在定义模块（目标）内使用实体。通常在定义应用程序或框架的内部结构时使用internal访问。
// First.framework – A.swift
internal struct A {}
// First.framework – B.swift
A() // ok
// Second.framework – C.swift
import First
A() // error: A is unavailable
fileprivate限制实体仅在其定义的源文件中使用。通常，当这些细节在整个文件中使用时，您会使用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
private限制实体只能在其封闭声明中使用。通常在某个功能的实现细节仅在单个声明中使用时，使用private访问修饰符来隐藏这些细节。
// First.framework – A.swift
internal struct A {
private static let x: Int
internal static func doSomethingWithX() {
x // ok
}
}
A.x // error: x is unavailable
根据 Swift 文档-访问控制，Swift 有5种访问控制级别:
open 和 public: 可以被它们所在模块的实体以及导入到该模块的任何模块中的实体访问。
internal: 只能从它们所在的模块的实体访问。这是默认的访问级别。
fileprivate 和 private: 只能在定义它们的作用域内部访问。
open 和 Swift 先前版本中的 public 是相同的，它们允许其他模块的类使用和继承它们，即：它们可以被其他模块的子类化。此外，它们还允许来自其他模块的成员使用和覆盖它们。对于它们的模块也是相同的逻辑。
public 允许其他模块的类使用它们，但不允许继承它们，即：它们不能被其他模块子类化。此外，它们允许来自其他模块的成员使用它们，但不允许覆盖它们。对于它们的模块，它们具有与 open 相同的逻辑（允许类使用和继承它们；允许成员使用和覆盖它们）。
fileprivate 可以从它们所在文件的任何位置访问。
private 只能从声明它们的单个位置以及在同一文件中的 扩展 中访问该声明；例如：
// Declaring "A" class that has the two types of "private" and "fileprivate":
class A {
private var aPrivate: String?
fileprivate var aFileprivate: String?
func accessMySelf() {
// this works fine
self.aPrivate = ""
self.aFileprivate = ""
}
}
// Declaring "B" for checking the abiltiy of accessing "A" class:
class B {
func accessA() {
// create an instance of "A" class
let aObject = A()
// Error! this is NOT accessable...
aObject.aPrivate = "I CANNOT set a value for it!"
// this works fine
aObject.aFileprivate = "I CAN set a value for it!"
}
}
正如在SE-0169提案中提到的，Swift 4唯一的改进是将private访问控制范围扩展到在同一文件中的声明的扩展中可以访问；例如：
struct MyStruct {
private let myMessage = "Hello World"
}
extension MyStruct {
func printMyMessage() {
print(myMessage)
// In Swift 3, you will get a compile time error:
// error: 'myMessage' is inaccessible due to 'private' protection level
// In Swift 4 it should works fine!
}
}
所以，没有必要将myMessage声明为fileprivate才能在整个文件中访问。
当谈到在Swift或ObjC（或Ruby或Java等）中制作“私有方法”时，这些方法并不是真正私有的。它们周围没有实际的访问控制。任何提供即使只有少量内省的语言都可以让开发者从类外部访问这些值，如果他们真的想这样做的话。
所以我们在这里真正谈论的是一种定义公共接口的方式，仅展示我们想要的功能，并“隐藏”我们认为是“私有”的其余部分。
在Swift中声明接口的机制是protocol，它可以用于此目的。
protocol MyClass {
var publicProperty:Int {get set}
func publicMethod(foo:String)->String
}
class MyClassImplementation : MyClass {
var publicProperty:Int = 5
var privateProperty:Int = 8
func publicMethod(foo:String)->String{
return privateMethod(foo)
}
func privateMethod(foo:String)->String{
return "Hello \(foo)"
}
}
请记住，协议是一流类型，可在任何类型可以使用的地方使用。而且，以这种方式使用时，它们只会公开自己的接口，而不会公开实现类型的接口。
因此，只要在参数类型等中使用MyClass而不是MyClassImplementation，一切都应该正常工作：
func breakingAndEntering(foo:MyClass)->String{
return foo.privateMethod()
//ERROR: 'MyClass' does not have a member named 'privateMethod'
}
有些情况下需要直接赋值时，你必须明确指定类型，而不能依赖Swift进行推断，但这似乎并不是致命问题：
var myClass:MyClass = MyClassImplementation()
通过协议、闭包和嵌套/内部类的组合，现在可以使用类似模块模式来隐藏Swift中的信息。虽然阅读起来并不是非常干净或美观，但确实可行。
例如：
protocol HuhThing {
var huh: Int { get set }
}
func HuhMaker() -> HuhThing {
class InnerHuh: HuhThing {
var innerVal: Int = 0
var huh: Int {
get {
return mysteriousMath(innerVal)
}
set {
innerVal = newValue / 2
}
}
func mysteriousMath(number: Int) -> Int {
return number * 3 + 2
}
}
return InnerHuh()
}
HuhMaker()
var h = HuhMaker()
h.huh // 2
h.huh = 32
h.huh // 50
h.huh = 39
h.huh // 59
innerVal和mysteriousMath在此处被隐藏以防止外部使用，任何试图深入对象的尝试都应该导致错误。
我只是开始阅读Swift文档的一部分，如果这里有什么缺陷，请指出来，非常想知道。
reflect(h)[0].1.value // 19 - John Estropia从Xcode 6 beta 4开始，Swift具有访问修饰符。根据发行说明：
Swift访问控制有三个访问级别：
- private实体只能在定义它们的源文件中访问。
- internal实体可以在定义它们的目标内的任何位置访问。
- public实体可以从目标内的任何位置以及导入当前目标模块的任何其他上下文中访问。
隐式默认值为internal，因此在应用程序目标中，您可以省略访问修饰符，除非您想要更严格限制。在框架目标中（例如，如果您嵌入框架以在应用程序和共享或今天视图扩展之间共享代码），请使用public指定要向您的框架客户端公开的API。
Open 访问和 public 访问使实体能够在定义模块中的任何源文件中使用，并且在导入定义模块的另一个模块的源文件中也可以使用。通常在指定框架的公共接口时使用 open 或 public 访问。
Internal 访问使实体能够在其定义模块的任何源文件中使用，但不能在该模块外的任何源文件中使用。通常在定义应用程序或框架的内部结构时使用内部访问。
File-private 访问将实体的使用限制为其自己的定义源文件。当这些细节在整个文件中使用时，使用 file-private 访问来隐藏特定功能的实现细节。
Private 访问将实体的使用限制为封闭声明。当这些细节仅在单个声明中使用时，使用 private 访问来隐藏特定功能的实现细节。
Open 访问是最高（最不受限制）的访问级别，而 private 访问是最低（最受限制）的访问级别。
默认访问级别
如果您没有明确指定实体的访问级别，那么代码中的所有实体（除了一些特定的例外）都具有默认的内部访问级别。因此，在许多情况下，您不需要在代码中指定显式的访问级别。
有关该主题的发布说明：
声明为 public 的类不能在其定义模块之外进行子类化，声明为 public 的方法不能在其定义模块之外进行覆盖。要允许外部子类化类或外部覆盖方法，请将它们声明为 open，这是一个超出 public 的新访问级别。导入的 Objective-C 类和方法现在都作为 open 导入，而不是 public。使用 @testable import 导入模块的单元测试仍将允许子类化 public 或 internal 类以及覆盖 public 或 internal 方法。（SE-0117）
class foo { }
private extension foo {
func somePrivateHelperFunction01() { }
func somePrivateHelperFunction02() { }
func somePrivateHelperFunction03() { }
}
对于Swift 1-3：
不，这是不可能的。根本没有私有/受保护的方法和变量。
一切都是公开的。
更新 自从Swift 4以后，可以看到其他帖子中的答案。