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でデータの可視性を制限することは可能ですか？

以下のようスウィフト3.0.1、あるアクセスの4つのレベル最小（最も制限的）に最も高い（最も制限）から説明します。

1. 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

2。 internal

エンティティを定義モジュール（ターゲット）内で使用できるようにします。通常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

3。 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

4。 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 4 / Swift 5

Swift Documentation-Access Controlで述べたように、Swiftには5つのアクセスコントロールがあります。

• openおよび public：モジュールのエンティティおよび定義モジュールをインポートする任意のモジュールのエンティティからアクセスできます。

• internal：モジュールのエンティティからのみアクセスできます。これはデフォルトのアクセスレベルです。

• fileprivateおよび private：アクセスできるのは、それらを定義する限定されたスコープ内のみです。

オープンとパブリックの違いは何ですか？

openは以前のバージョンのSwiftのpublicと同じで、他のモジュールのクラスがそれらを使用および継承できるようにします。つまり、他のモジュールからサブクラス化できます。また、他のモジュールのメンバーがそれらを使用およびオーバーライドできるようにします。同じロジックがモジュールにも当てはまります。

国民は、他のモジュールからのクラスがそれらを使用することができますが、ではない、すなわち、それらを継承する：彼らがすることはできません、他のモジュールからサブクラス化すること。また、他のモジュールのメンバーがそれらを使用できるようにしますが、オーバーライドすることはできません。それらのモジュールについては、それらは同じオープンのロジックを持っています（クラスがそれらを使用および継承できるようにします。メンバーがそれらを使用およびオーバーライドできるようにします）。

fileprivateとprivateの違いは何ですか？

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!"
    }
}

Swift 3とSwift 4のアクセス制御の違いは何ですか？

SE-0169提案で述べたように、Swift 4に加えられた唯一の改良点は、同じファイル内の宣言の拡張機能からアクセスできるようにプライベートアクセス制御スコープが拡張されたことです。例えば：

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

この方法でプロトコルを使用することは、意味があり、合理的に簡潔であり、ObjCでこの目的のために使用してきたClass Extentionsによく似ています。

私が知る限り、「公開」、「非公開」、「保護」のキーワードはありません。これは、すべてが公開されていることを示唆しています。

ただし、Appleは、人々が「プロトコル」（他の世界ではインターフェイスと呼ばれる）とファクトリデザインパターンを使用して実装タイプの詳細を隠すことを期待している場合があります。

これは多くの場合、とにかく使用するのに適した設計パターンです。論理型システムを同じに保ちながら、実装クラス階層を変更できるからです。

プロトコル、クロージャー、ネスト/内部クラスの組み合わせを使用すると、モジュールパターンの行に沿って何かを使用して、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ドキュメントを読んでいる途中なので、ここに欠陥がある場合は指摘してください。ぜひ教えてください。

Xcode 6ベータ4以降、Swiftにはアクセス修飾子があります。リリースノートから：

Swiftアクセスコントロールには3つのアクセスレベルがあります。

• プライベートエンティティは、それらが定義されているソースファイル内からのみアクセスできます。
• 内部エンティティには、それらが定義されているターゲット内のどこからでもアクセスできます。
• パブリックエンティティには、ターゲット内のどこからでも、現在のターゲットのモジュールをインポートする他のコンテキストからもアクセスできます。

暗黙のデフォルトはinternalなので、アプリケーションターゲット内で、より制限したい場合を除いて、アクセス修飾子をオフのままにすることができます。フレームワークターゲット（たとえば、アプリと共有またはTodayビュー拡張間でコードを共有するためにフレームワークを埋め込む場合）を使用publicして、フレームワークのクライアントに公開するAPIを指定します。

Swift 3.0は5つの異なるアクセス制御を提供します：

1. 開いた
2. 公衆
3. 内部
4. fileprivate
5. 民間

オープンアクセスとパブリックアクセスにより、エンティティを定義モジュールの任意のソースファイル内で使用できるほか、定義モジュールをインポートする別のモジュールのソースファイルでも使用できます。フレームワークへのパブリックインターフェイスを指定するときは、通常、オープンアクセスまたはパブリックアクセスを使用します。

内部アクセスにより、エンティティは定義モジュールのソースファイル内で使用できますが、そのモジュール外のソースファイルでは使用できません。通常、アプリまたはフレームワークの内部構造を定義するときに内部アクセスを使用します。

ファイルプライベートアクセスは、エンティティの使用をそれ自体の定義ソースファイルに制限します。特定の機能の実装の詳細がファイル全体で使用されている場合、それらの詳細を非表示にするには、ファイルプライベートアクセスを使用します。

プライベートアクセスでは、エンティティの使用を囲んでいる宣言に制限します。特定の機能の実装の詳細が単一の宣言内でのみ使用される場合は、プライベートアクセスを使用して、特定の機能の実装の詳細を非表示にします。

オープンアクセスは最高（最も制限の少ない）アクセスレベルであり、プライベートアクセスは最低（最も制限の多い）アクセスレベルです。

デフォルトのアクセスレベル

明示的なアクセスレベルを自分で指定しない場合、コード内のすべてのエンティティ（いくつかの特定の例外を除く）のデフォルトのアクセスレベルは内部です。その結果、多くの場合、コードで明示的なアクセスレベルを指定する必要はありません。

トピックに関するリリースノート：

publicとして宣言されたクラスは、定義モジュールの外部でサブクラス化できなくなり、publicとして宣言されたメソッドは、定義モジュールの外部でオーバーライドできなくなりました。クラスを外部でサブクラス化したり、メソッドを外部でオーバーライドしたりできるようにするには、それらをオープンとして宣言します。これは、パブリックを超える新しいアクセスレベルです。インポートされたObjective-Cのクラスとメソッドは、すべてパブリックではなくオープンとしてインポートされるようになりました。@testableインポートを使用してモジュールをインポートする単体テストでは、パブリッククラスまたは内部クラスをサブクラス化したり、パブリックメソッドまたは内部メソッドをオーバーライドしたりできます。（SE-0117）

詳細と詳細： Swiftプログラミング言語（アクセス制御）

Beta 6では、3つの異なるアクセス修飾子があるとドキュメントに記載されています。

• 公衆
• 内部
• 民間

これら3つは、クラス、プロトコル、関数、プロパティに適用されます。

public var somePublicVariable = 0
internal let someInternalConstant = 0
private func somePrivateFunction() {}

詳しくは、アクセス制御を確認してください。

現在ベータ4で、Swiftにアクセス修飾子を追加しました。

Xcodeの6ベータ4 realeseノート：

Swiftアクセスコントロールには3つのアクセスレベルがあります。

• private エンティティは、それらが定義されているソースファイル内からのみアクセスできます。
• internal エンティティは、定義されているターゲット内のどこからでもアクセスできます。
• public エンティティには、ターゲット内のどこからでも、現在のターゲットのモジュールをインポートする他のコンテキストからでもアクセスできます。

デフォルトでは、ソースファイル内のほとんどのエンティティは内部アクセス権を持っています。これにより、アプリケーション開発者はアクセス制御をほとんど無視でき、フレームワーク開発者はフレームワークのAPIを完全に制御できます。

Xcode 6で導入されたアクセス制御メカニズム：

Swiftは、コード内のエンティティに3つの異なるアクセスレベルを提供します。これらのアクセスレベルは、エンティティが定義されているソースファイルに関連しており、ソースファイルが属するモジュールにも関連しています。

• パブリックアクセスにより、エンティティを定義モジュールの任意のソースファイル内で使用したり、定義モジュールをインポートする別のモジュールのソースファイルで使用したりできます。フレームワークへのパブリックインターフェイスを指定するときは、通常、パブリックアクセスを使用します。
• 内部アクセスにより、エンティティは定義モジュールのソースファイル内で使用できますが、そのモジュール外のソースファイルでは使用できません。通常、アプリまたはフレームワークの内部構造を定義するときに内部アクセスを使用します。
• プライベートアクセスは、エンティティの使用をそれ自体の定義ソースファイルに制限します。プライベートアクセスを使用して、特定の機能の実装の詳細を非表示にします。

パブリックアクセスは最高（最も制限の少ない）アクセスレベルであり、プライベートアクセスは最低（または最も制限の強い）アクセスレベルです。

デフォルトでは内部にアクセスするため、指定する必要はありません。また、ご注意プライベート指定子はいないクラスレベルではなく、ソースファイルレベルでの作業を。つまり、クラスの一部を本当にプライベートにするには、独自のファイルに分離する必要があります。これはまた、単体テストに関していくつかの興味深いケースを紹介します...

上記のリンクでコメントされている私のもう1つのポイントは、アクセスレベルを「アップグレード」できないことです。何かをサブクラス化する場合、それをさらに制限できますが、その逆はできません。

この最後のビットはまた、すなわち機能が使用されている場合ような方法で機能し、タプルかつ確実に他のものに影響を与えプライベートクラスを、それが機能を持つことが有効ではありません内部または公共彼らはへのアクセス権がない可能性がありますように、プライベートクラスを。この結果、コンパイラの警告が表示され、関数をプライベート関数として再宣言する必要があります。

Swift 3と4では、変数とメソッドのアクセスレベルにも多くの変更が加えられました。Swift 3および4には4つの異なるアクセスレベルがあり、オープン/パブリックアクセスが最高（最も制限の少ない）アクセスレベルであり、プライベートアクセスが最低（最も制限の強い）アクセスレベルです。

• プライベート関数とメンバーには、エンティティ自体（構造体、クラスなど）とその拡張機能（Swift 3では拡張機能も制限されていました）のスコープ内からのみアクセスできます。
• fileprivate関数とメンバーは、それらが宣言されているソースファイル内からのみアクセスできます。
• 内部関数とメンバー（明示的にアクセスレベルキーワードを追加しない場合のデフォルト）は、それらが定義されているターゲット内のどこにでもアクセスできます。そのため、TestTargetはすべてのソースに自動的にアクセスするわけではなく、xCodeのファイルインスペクターでアクセス可能としてマークする必要があります。
• オープン関数またはパブリック関数とメンバーには、ターゲット内のどこからでも、現在のターゲットのモジュールをインポートする他のコンテキストからでもアクセスできます。

面白い：

すべてのメソッドまたはメンバーを「プライベート」としてマークする代わりに、クラス/構造体の拡張でいくつかのメソッド（通常はヘルパー関数）をカバーし、拡張全体を「プライベート」としてマークできます。

class foo { }

private extension foo {
    func somePrivateHelperFunction01() { }
    func somePrivateHelperFunction02() { }
    func somePrivateHelperFunction03() { }
}

これは、より保守しやすいコードを取得するために、良い考えです。また、1つの単語を変更するだけで（単体テストなどで）非公開に簡単に切り替えることができます。

Appleのドキュメント

Swift 1-3の場合：

いいえ、それは不可能です。プライベート/保護されたメソッドと変数はまったくありません。

すべてが公開されています。

更新 Swift 4以降、このスレッドで他の回答を見ることができます

使用できるオプションの1つは、インスタンスの作成を関数にラップし、コンストラクターで適切なゲッターとセッターを提供することです。

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

言語の文法は、キーワードの公開」、「プライベート」や「保護」を持っていません。これは、すべてが公開されていることを示唆しています。もちろん、これらのキーワードなしでアクセス修飾子を指定する別の方法があるかもしれませんが、言語リファレンスでは見つかりませんでした。

うまくいけば、保護されたメソッドに似たものが欲しい人のために時間を節約できます：

他の回答と同様に、Swiftは 'private'修飾子を提供します。これは、JavaやC＃などのようにクラスごとではなくファイルごとに定義されます。これは、保護されたメソッドが必要な場合は、迅速なプライベートメソッドで実行できることを意味します場合、同じファイルにある場合はます。

1. 「保護された」メソッド（実際にはプライベート）を保持する基本クラスを作成する
2. このクラスをサブクラス化して同じメソッドを使用する
3. 他のファイルでは、サブクラスを作成しても、基本クラスのメソッドにアクセスできません。

例：ファイル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
    }

}

https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AccessControl.html#//apple_ref/doc/uid/TP40014097-CH41-ID3

SWIFT 2.2の開始;）

• 公衆
• 内部
• 民間

デフォルトでは内部

swift 2.0までは3つのアクセスレベル[パブリック、内部、プライベート]しかありませんでしたが、swift 3.0では[Open、fileType]の2つの新しいアクセスレベルが追加されたため、swift 3.0では5つのアクセスレベルがありますここで役割をクリアしますこれらの2つのアクセスレベルの1。オープン：これはパブリックと非常に似ていますが、唯一の違いは、パブリックがサブクラスにアクセスしてオーバーライドできることと、オープンアクセスレベルがこの画像にアクセスすることができないことです。 オープンアクセスとパブリックアクセスの間

次に、2番目の新しいアクセスレベル2に移動します。filetypeは、privateのバージョンが大きいか、内部よりアクセスレベルが低くなっています。fileTypeは、[class、struct、enum]の拡張部分にアクセスでき、privateは、アクセスできるコードの拡張部分にアクセスできません。この画像が中規模のWebサイトから取得された語彙の範囲。 これは、fileTypeとPrivateアクセスレベルの違いを示します