使用协议、闭包和嵌套/内部类的组合，现在可以使用模块模式来隐藏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文档的一部分，所以如果这里有缺陷，请指出来，我很想知道。

当人们谈论在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中为此目的使用的类扩展。

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访问级别之间的区别

你可以使用的一个选项是将实例创建包装到一个函数中，并在构造函数中提供适当的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中的信息。它不是很干净，也不是很好读，但它确实有用。

例子:

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文档的一部分，所以如果这里有缺陷，请指出来，我很想知道。