till swift 2.0 there were only three access level [Public, internal, private] but in swift 3.0 apple added two new access level which are [ Open, fileType ] so now in swift 3.0 there are 5 access level Here I want to clear the role of these two access level 1. Open: this is much similar to Public but the only difference is that the Public can access the subclass and override, and Open access level can not access that this image is taken from Medium website and this describe the difference between open and public access

现在是第二个新的访问级别 2. 文件类型是更大版本的私有或更低的访问级别比内部 fileType可以访问[class, struct, enum]的扩展部分 而且private不能访问扩展部分的代码，它只能访问 词法作用域 这张照片取自Medium网站，描述了fileType和Private访问级别之间的区别

对于Swift 1-3:

不，不可能。这里根本没有任何私有/受保护的方法和变量。

一切都是公开的。

更新 从Swift 4开始，可能会在这个帖子中看到其他答案

till swift 2.0 there were only three access level [Public, internal, private] but in swift 3.0 apple added two new access level which are [ Open, fileType ] so now in swift 3.0 there are 5 access level Here I want to clear the role of these two access level 1. Open: this is much similar to Public but the only difference is that the Public can access the subclass and override, and Open access level can not access that this image is taken from Medium website and this describe the difference between open and public access

现在是第二个新的访问级别 2. 文件类型是更大版本的私有或更低的访问级别比内部 fileType可以访问[class, struct, enum]的扩展部分 而且private不能访问扩展部分的代码，它只能访问 词法作用域 这张照片取自Medium网站，描述了fileType和Private访问级别之间的区别

Swift 3.0提供了5种不同的访问控制:

开放 公共 内部 fileprivate 私人

Open access and public access enable 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 open or 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. File-private access restricts the use of an entity to its own defining source file. Use file-private access to hide the implementation details of a specific piece of functionality when those details are used within an entire file. Private access restricts the use of an entity to the enclosing declaration. Use private access to hide the implementation details of a specific piece of functionality when those details are used only within a single declaration. Open access is the highest (least restrictive) access level and private access is the lowest (most restrictive) access level.

默认访问级别

如果您自己没有明确指定访问级别，那么代码中的所有实体(除了少数特定的例外)都有一个默认的内部访问级别。因此，在许多情况下，您不需要在代码中指定显式的访问级别。

关于该主题的发布说明:

Classes declared as public can no longer be subclassed outside of their defining module, and methods declared as public can no longer be overridden outside of their defining module. To allow a class to be externally subclassed or a method to be externally overridden, declare them as open, which is a new access level beyond public. Imported Objective-C classes and methods are now all imported as open rather than public. Unit tests that import a module using an @testable import will still be allowed to subclass public or internal classes as well as override public or internal methods. (SE-0117)

更多信息和细节: Swift编程语言(访问控制)

当人们谈论在Swift或ObjC(或ruby或java或…)中创建“私有方法”时，这些方法并不是真正的私有方法。他们周围没有实际的访问控制。任何语言只要能够提供一点内省功能，就可以让开发人员从类之外获得这些值，如果他们真的想要的话。

因此，我们在这里真正谈论的是一种定义面向公众的接口的方法，该接口仅呈现我们想要的功能，并“隐藏”其余我们认为是“私有”的功能。

Swift声明接口的机制就是协议，它可以用于此目的。

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()

以这种方式使用协议是语义上的，相当简洁，而且在我看来很像我们在ObjC中为此目的使用的类扩展。

使用协议、闭包和嵌套/内部类的组合，现在可以使用模块模式来隐藏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和mysterousmath隐藏在这里，不被外部使用，试图挖掘对象的方法应该会导致错误。

我只是阅读了Swift文档的一部分，所以如果这里有缺陷，请指出来，我很想知道。