Javaの内部クラスおよび静的入れ子のクラス

https://stackoverflow.com/questions/70324

09-06-2019
|

質問

の主な違いは内部クラスおよび静的な入れ子のクラスJava?なデザインと実装の役割を果たの選択のみられます。

解決

入れ子のクラスがあります:静的および非おります。入れ子のクラスはstaticとして宣言されたこれまでの静的な入れ子になった。非静入れ子のクラスと呼ばれる内部クラス.

静入れ子のクラスを使用してアクセス、囲むクラス名：

OuterClass.StaticNestedClass

例えば、オブジェクトのクラスを使用すると、この構文:

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

オブジェクトのインスタンスの内部クラス内に存在するインスタンスの外側のクラスです。考え、以下のクラス

class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

インスタンスのInnerClassことで存在でき内のインスタンスOuterClass通路で直結しており、アクセス方法及び分野での囲みインスタンス.

インスタンスを生成する内部クラスは、まず最初にインスタンスを生成し、外クラスです。その後、内側のオブジェクト内側のオブジェクトとこの構文:

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

参照: Javaチュートリアル-入れ子のクラス

のための完全性もございますのでご注意などものとして内部クラスなしは、囲むインスタンス:

class A {
  int t() { return 1; }
  static A a =  new A() { int t() { return 2; } };
}

ここで、 new A() { ... } は 内部クラスで定義される静脈 してはおりませ囲むインスタンス.

他のヒント

の Javaチュートリアルという:

用語:入れ子のクラスに分かれてそれぞれ静的非対応します。入れ子のクラスはstaticとして宣言されたこれまでの静的な入れ子になった。非静入れ子のクラスと呼ばれる内ます。

共有の用語の用語"入れ子"と"内部"を使用されるほとんどのプログラマが、また利用したいと思い、正しい"の"入れ子のクラス"の双方を対象としている内します。

授業の入れ子 ad infinitum, などクラスを含むことができクラスBを含むクラスCを含むクラス。しかし、以上のレベルのクラスに入れ子では珍しいのでは一般的に悪いデザイン。

ある理由でしょうを入れ子のクラス：

組織:もう最良のソートクラスの名前空間のクラスは、特にがんに使用その他の文脈
アクセス：入れ子のクラスは特別なアクセス、変数/分野のを含むクラスを精密にする変数/分野によって入れ子のクラスから内部またはstatic).
利便性:ることを新規作成ファイル毎に新しいタイプのが面倒、特に力するときに使用するタイプのみにする"にチェックを入れてくださ脈

があり 四種の入れ子のクラスJava.簡単に言う:

静クラス:として宣言された静的な会員の別のクラス
内部クラス:として宣言されたインスタンスの会員の別のクラス
地元の内部クラス:宣言された内インスタンスメソッドの別のクラス
匿名の内部クラス:のように地域の内部クラスが書かれている表現を返しますなどの一時オブジェクト

なお話をさせて頂きたいと思います。

静授業

静授業の最も簡単なような理解でいいのインスタンスを含むクラスです。

静的クラスのクラスとして宣言された静的な会員の別のクラスです。のようにその他の静員は、このようなクラスは本当にただのハンガーその利用を含むクラスと名前空間 例えば のクラスヤギとして宣言された静的な会員のクラスサイパッケージピザ称 ッフを募集しています。サイズ.ヤギ.

package pizza;

public class Rhino {

    ...

    public static class Goat {
        ...
    }
}

正直、静的な授業かは価値のな特徴での授業は既に分かれての名前空間によりパッケージ。と考えられる理由を静的クラスは、そのようなクラスへのアクセス、を含むクラスのprivate static員が、これかにラメの正当性を静的クラスの機能が存在します。

内部クラス

内部クラスのクラスとして宣言された非静会員の別のクラス：

package pizza;

public class Rhino {

    public class Goat {
        ...
    }

    private void jerry() {
        Goat g = new Goat();
    }
}

のように静的クラスの内部クラスとして知られる資格を有する社を含むクラス名 ッフを募集しています。サイズ.ヤギ, ものを含むクラスは、正確に知ることができますが、その単純名です。しかし、毎のインスタンスの内部クラス結びついて、特定のインスタンスを含有スクラス：上記のヤギ作成された ジェリー, は、暗黙のうちに縛られるサイインスタンスこのに ジェリー.その他の関連するサイインスタンス時に明示したインスタンスを生成ヤギ:

Rhino rhino = new Rhino();
Rhino.Goat goat = rhino.new Goat();

（お知らせの内部タイプとしてだけでヤギになっ 新しい 構文:Java推論の含有タイプからサイます。あり 新しい才.ヤギ() うがよい。)

なのでこれ得る。もに、内部クラスインスタンスにアクセスできるインスタンスのを含むクラスのインスタンス.これらの囲むインスタンス委員以内での内部クラス通だけのシンプルな名前ではな通この (このの内部クラスは内部クラスインスタンスではなく、関連を含むクラスのインスタンス):

public class Rhino {

    private String barry;

    public class Goat {
        public void colin() {
            System.out.println(barry);
        }
    }
}

の内部クラスを参照することができますこののを含むクラスとして サイズ.この, ないときはこの参照、 例えばサイズ.ます。ハーモニーランドのパスポート.

地元の内部クラス

地元の内部クラスのクラスで宣言されたの体のメソッドになっています。どのクラスで知られる内を含む方法でのみインスタンスを生成して、その会員以内でアクセス、を含む方法。ゲインは地域の内部クラスインスタンスを結びつけるのでアクセスの最終局所変数のを含む方法。時のインスタンスを使用した最終地のを含む方法では、変数を保持する値で開催時のインスタンスの創出の場合でも、変数がなくなってしまったのが範囲外になることを効果的にJavaの原油限定バージョンの閉鎖).

が地域の内部クラスは、会員のクラスまたはパッケージで宣言されていませんのアクセスす。(明らかにし、しかし、自分自身の会員がアクセスレベルのような通常のクラスです。)

た場合、内部クラスで宣言されたインスタンスメソッドは、インスタンス生成の内部クラスと結びつけ、インスタンスを開催し、を含む方法のこの時のインスタンスの作成、を含むクラスのインスタンス会員がアクセスのようなインスタンス内部クラスです。地元の内部クラスのインスタンスが作成で通その名の 例えば 地元の内部クラス猫はインスタンスを生成してい 新猫), は新しいです。猫とします。

匿名の内部クラス

匿名の内部クラスは、便利な方法の地域の内部クラスです。最も一般的には、地元の内部クラスのインスタンスが作成でだれ、を含む方法。ができると思うのですが、ついてお話しいただきましたが結合し、地域の内部クラスの定義およびその単一のインスタンス生成を一つの便利な構文の形でもコミュニケーションを取り合えないと考えら名前のクラスの少ない非協力名はコードが含まれているの？匿名の内部クラスでもこれらのもの

new *ParentClassName*(*constructorArgs*) {*members*}

この表現が返す新しいインスタンスの名前のないクラスを拡張 ParentClassName.はできませんの供給自分のコンストラクタ;むしろ、一つは暗黙的に供給するだけで通話のスーパーコンストラクタの引数に供給された、スーパーコンストラクタです。場合は、親会社を含む複数のコンストラクタは、"単純な"一"と呼ばれるもの"簡単"で決定されるような複雑なルールのプライベートビーチがあり気に学ぶ詳細にだけ意見を表明するものではなくボタンひたEclipseを伝えます。)

またご指定いただくことができますインターフェースの実装:

new *InterfaceName*() {*members*}

そのような宣言の作成新しいインスタンスの名前のないクラスを拡張オブジェクトを実施す InterfaceName.おり、供給できない独自のコンストラクタ;この場合、Java暗黙的に供給しないargいなしのコンストラクタではありませんコンストラクタ引数です。

もできない匿名の内部クラスのコンストラクタが確認できていないかの設定を使用して初期化子ブロック(a{}ブロックを設置して合法です。

明らかにする匿名の内部クラスは、単にフロート制を地域の内部クラスとインスタンス.したい場合は地域の内部クラスを実装する複数のインタフェースを実装する界面を横に引きながら、一部のクラス以外の オブジェクト またはを指定し、独自のコンストラクタには、こだわった作り正規の名の地元の内部クラスです。

すべてのグアダラハラアセンブリによって、上記の応答となります。

初めての権

入れ子のクラスはクラスに含まれる別のクラスのソースコードです。
では静的な場合を宣言するもの静的を模倣しています。
非静入れ子のクラスは内部クラスです。(I泊非静入れ子のクラスです。)

マーティンの答えは、右です。しかし、実際の質問は目的は何かを宣言する入れ子のクラスの静的はありませんか？

ご利用の 静入れ子のクラス またく同じクラスの場合所属している内容およびアドレス（url）を変更または場合に入れ子のクラスは独占的に使用されてい囲むクラスです。ありません意味の違い静的な入れ子のクラスや他のすべてのクラスです。

非静入れ子のクラス は異なる獣.同様に匿名の内部クラスは、入れ子のクラスで実際に抑止するためには、必要かなっているミャン周辺の範囲を囲むインスタンスを作ること。その例を明らかにした。このスタブのコンテナ:

public class Container {
    public class Item{
        Object data;
        public Container getContainer(){
            return Container.this;
        }
        public Item(Object data) {
            super();
            this.data = data;
        }

    }

    public static Item create(Object data){
        // does not compile since no instance of Container is available
        return new Item(data);
    }
    public Item createSubItem(Object data){
        // compiles, since 'this' Container is available
        return new Item(data);
    }
}

この場合において子供から項目をコンテナのサブコンポーネン.を用いたクラスを使用すると、この作品の一部です。アクセスでき、囲むインスタンスのコンテナの構文 Container.this.

よりハードコアな説明：

また、Javaバイトコードをコンパイラ生成のためには、非静的)入れ子のクラスでなることも明:

// class version 49.0 (49)
// access flags 33
public class Container$Item {

  // compiled from: Container.java
  // access flags 1
  public INNERCLASS Container$Item Container Item

  // access flags 0
  Object data

  // access flags 4112
  final Container this$0

  // access flags 1
  public getContainer() : Container
   L0
    LINENUMBER 7 L0
    ALOAD 0: this
    GETFIELD Container$Item.this$0 : Container
    ARETURN
   L1
    LOCALVARIABLE this Container$Item L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 1
  public <init>(Container,Object) : void
   L0
    LINENUMBER 12 L0
    ALOAD 0: this
    ALOAD 1
    PUTFIELD Container$Item.this$0 : Container
   L1
    LINENUMBER 10 L1
    ALOAD 0: this
    INVOKESPECIAL Object.<init>() : void
   L2
    LINENUMBER 11 L2
    ALOAD 0: this
    ALOAD 2: data
    PUTFIELD Container$Item.data : Object
    RETURN
   L3
    LOCALVARIABLE this Container$Item L0 L3 0
    LOCALVARIABLE data Object L0 L3 2
    MAXSTACK = 2
    MAXLOCALS = 3
}

ご覧のとおり、コンパイラを作成し隠し Container this$0.このコンストラクタは追加パラメータのタイプコンテナの指定は、囲むインスタンス.見えないけれどこのパラメータのソースをコンパイラが暗黙的に生成された入れ子のクラスです。

マーティンの例

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

いなとりまとめのようなもの(バイトコード)

new InnerClass(outerObject)

完全性のために:

匿名クラスは例外クラスを使用するだけではない名前が関連付けられないので参照できます。

と思いなしの回答ついての説明と実際の差入れ子のクラスおよび静的な入れ子のクラスのアプリケーションデザイン:

概要

入れ子のクラス きnonstaticまたは静的およびそれぞれの場合 クラス内で定義された別のクラス. 入れ子のクラスは存在には、囲むクラス, 場合に入れ子のクラスが他のクラスに封入るべきであるとして宣言されたトップレベルのクラスです。

差

Nonstatic入れ子のクラス :は暗黙のうちに伴い、囲むのインスタンスを含むクラスは、このことが可能で呼び出す方法とアクセス変数を囲むインスタンス.一つの利用nonstatic入れ子のクラスを定義するアダプタクラスです。

静入れ子のクラス :なアクセスを囲むクラスインスタンスを起動方法でするために使用されるメソッドは、入れ子のクラスを必要としませんへのアクセスのインスタンスは、囲むクラスです。共用のクラスを導入することによって、現在は、部品の外オブジェクトです。

結論

その差異は、主に二つのデザインからの観点から: nonstatic入れ子のクラスアクセスのインスタンスのコンテナクラスが静的な.

シンプルにして入れ子のクラスがJava提供いたしません抑止するためには、必要か

入れ子のクラスクラス内で定義されている身体の他の囲むクラスです。かなりの数の種類の静的および非おります。

使い方の一員として、囲むクラスが指定できず、アクセス指定子- private, package, protected, public.いこの高級トップレベルのクラスで宣言され public またはパッケージです。

内部クラスの赤外スタックのクラスへのアクセスの他のメンバーのトップクラスの場合でも、宣言されてい民間を静入れ子のクラスを手に入れられないなどのトップクラスです。

public class OuterClass {
    public static class Inner1 {
    }
    public class Inner2 {
    }
}

Inner1 弊社静内部クラスと Inner2 当社の内部クラスではない。キーこれらの差額についてはできませんの作成 Inner2 インスタンスな外場としてのを作成することができます Inner1 オブジェクト。

するおそれがある場合はご利用内部クラス?

いる状況を考え Class A や Class B の関係, Class B ニーズへのアクセス Class A 会員 Class B は関係など Class A.内部クラスが登場します。

創造のインスタンスの内部クラスを作成する必要がありますインスタンスの外側のクラスです。

OuterClass outer = new OuterClass();
OuterClass.Inner2 inner = outer.new Inner2();

または

OuterClass.Inner2 inner = new OuterClass().new Inner2();

するおそれがある場合はご利用の静的内部クラス?

う定義するstaticの内部クラスが分かっている場合は、この関連で、インスタンスは、囲むクラス/トップクラスです。の場合の内部クラスを使用しない方法または分野の外側のクラスをかけて食べるという習慣があり廃棄物の空間です。

例えば、オブジェクトのクラスを使用すると、この構文:

OuterClass.Inner1 nestedObject = new OuterClass.Inner1();

このクラスを使用することを必要としないオブジェクトを含むクラス/トップクラスです。この手伝いをさせていただき低減のオブジェクト数のご応募を行います。

と思い、コンベンション一般に次いです:

静クラス 内トップレベルのクラスは、 入れ子のクラス
静クラス 内トップレベルのクラスは、 内部クラス, し、さらに詳しい形式：
- 地域クラス それらを宣言されたクラス内のブロックのようなメソッドまたはコンストラクタの体の
- 匿名クラス -名前のないクラスインスタンスが作成された表現や諸表

しかし、別の複数の ポイントを記憶 ：

トップレベルの授業やクラスを使用する意味的に同じことを除いた場合クラスを使用できる"静参考個人staticフィールド/メソッドの外側の[親]クラスを開きます。
内部クラスのアクセスのインスタンス変数を囲むインスタンスの外側の[親]クラスです。についてはこちらをご覧ください内部クラスが囲むインスタンス、内部クラスの静的コンテキストのように匿名クラスで使用static初期化子ブロックなのです。
匿名クラスのデフォルトの親クラスを実装する親会社インタであり更なる条項へのその他のクラスまたは実施いますインタフェースなので、
- new YourClass(){}; 手段 class [Anonymous] extends YourClass {}
- new YourInterface(){}; 手段 class [Anonymous] implements YourInterface {}

っていると、大きな問題はオープンマインドを使用ますか？が主によって異なりのシナリオをお持ちのものを読むと回答された@jrudolphがけていますのでご利用ください一部決定します。

こちらは鍵の共通点と相違点Javaの内部クラスおよび静的入れ子のクラスです。

希望です!

内部クラス

アクセスできる 外クラス 両および静的インスタンス 方法及び分野
関連のインスタンスを囲むクラス でインスタンスを生成するまずニーズのインスタンスの外側のクラス(注 新しい キーワード場所）:
```
Outerclass.InnerClass innerObject = outerObject.new Innerclass();
```
できない 載の定義静員そのもの
できない してい クラス または インタ 宣言

静入れ子のクラス

アクセスできません 外側のクラス インスタンス 手法や分野
に関連付けられていないのインスタンスを囲むクラス でインスタンス化できます:
```
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
```

類似性

両 内部クラス アクセスできるもの 個人分野と方法 の 外側のクラス
もの 外側のクラス アクセス 個人分野と方法 の 内部クラス
授業では民間レベルで、protected、または公開アクセス修飾子

を利用する理由入れ子のクラス?

にOracleの文書がいくつかの理由(ドキュメントを充分に):

うものですし、そうやって論理的にグループ化されたクラスのみにする"にチェックを入れてくださ場所： 場合にクラスを一つだけ他のクラスは、その論理的な埋め込みでスク以外のリスクにつき意の二つを一つにした。ネストの"ヘルパークラス"によっておりパッケージをより効率化されました。

そのために、この封止: 検討のトップレベルのクラス、AとBのニーズにアクセスすることを宣言します。隠れたBクラス内のクラスは、メンバーで宣言された個人およびBにアクセスできます。また、Bそのもので隠すことができ、外部からの世界です。

でも読みやすくするために、保守性コード: 巣の少人数クラス内でトップレベルの授業場所のコードに近い場所で利用されています。

入れ子のクラス：クラス内のクラス

種類：

静入れ子のクラス
非クラスを使用する[内部クラス]

差：

非クラスを使用する[内部クラス]

非静入れ子のクラスオブジェクトの内部クラス内に存在するオブジェクトの外側のクラスです。このデータを会員の外部クラスでアクセスについては、アクセス権内部クラスです。Soをオブジェクトの内部クラスを作成オブジェクトの外側のクラスです。

outerclass outerobject=new outerobject();
outerclass.innerclass innerobjcet=outerobject.new innerclass();

静入れ子のクラス

静入れ子のクラスオブジェクトの内部クラスなオブジェクトの外側のクラスでの"静"を示す必要はないオブジェクトの作成.

class outerclass A {
    static class nestedclass B {
        static int x = 10;
    }
}

アクセスしたいならば、x、一時的に保存してから、以下の内方法

  outerclass.nestedclass.x;  i.e. System.out.prinltn( outerclass.nestedclass.x);

インスタンスの内部クラスを作成した時のインスタンスの外側のクラスを作成します。そのための方法や内部クラスのアクセスの方法やインスタンス(オブジェクト)の外側のクラスです。時のインスタンスの外側のクラスの範囲、または内部クラスのインスタンスは中止が存在します。

のクラスを使用できないコンクリートインスタンス.であるため、このことは、も利用するには、時間のように静ます。この完全に独立した団体で、法の変数を持たないアクセスのインスタンスの外側のクラスです。

の静的な入れ子のクラスな結合の外オブジェクトは、より速く、いわからないかheap/stackメモリが必要な作インスタンスのクラスです。そのための経験則を試してみを定義するクラスを使用すると、限られた範囲内で個人>=クラス>=保護>=公開）に変換する内部クラスを取り除"静"の識別子)を緩める範囲にあれば、その本当に必要です。

があり繊細なご利用については入れ子の静的な授業となる場合があります。-

は静的属性の取得インスタンスを生成クラスの前に必ずインストラクタがインスタンス化を通じてコンストラクタ静属性内部の入れ子の静的な授業になるようになインスタンスを生成後までクラスのコンストラクタが呼び出され、少なくともいまの属性が最初に参照している、場合でもキャナを実行しているときは、"最後の'.

次のような例を考えてみましょう:

public class C0 {

    static C0 instance = null;

    // Uncomment the following line and a null pointer exception will be
    // generated before anything gets printed.
    //public static final String outerItem = instance.makeString(98.6);

    public C0() {
        instance = this;
    }

    public String makeString(int i) {
        return ((new Integer(i)).toString());
    }

    public String makeString(double d) {
        return ((new Double(d)).toString());
    }

    public static final class nested {
        public static final String innerItem = instance.makeString(42);
    }

    static public void main(String[] argv) {
        System.out.println("start");
        // Comment out this line and a null pointer exception will be
        // generated after "start" prints and before the following
        // try/catch block even gets entered.
        new C0();
        try {
            System.out.println("retrieve item: " + nested.innerItem);
        }
        catch (Exception e) {
            System.out.println("failed to retrieve item: " + e.toString());
        }
        System.out.println("finish");
    }
}

も'入れ子"と"innerItem'の両方として宣言された'static final'.の設定の入れ子構造があります。innerItemを取らない場所でのクラスのインスタンスが作成(または少なくともの中でネストした静的項目最初に参照されるとき自分でによるコメントやuncommentingのラインを参考にご覧くださいねる。と同じになる true'outerItem'.

少なくともこれは僕が見てJava6.0.

の作成の場合はインスタンスのインスタンスの静内部クラスの作成を参照のオブジェクトの外側のクラスで定義されています。このを意味していinclosingインスタンス.そのインスタンスの静的な内部クラスの作成を参照の外側のクラスの付いていないの参照オブジェクトの外側のクラスです。この意味でいinclosingインスタンス.

例えば:

class A
{
  class B
  {
    // static int x; not allowed here…..    
  }
  static class C
  {
    static int x; // allowed here
  }
}

class Test
{
  public static void main(String… str)
  {
    A o=new A();
    A.B obj1 =o.new B();//need of inclosing instance

    A.C obj2 =new A.C();

    // not need of reference of object of outer class….
  }
}

とは思わない場合がありここで追加の回答を完全に説明の差異のクラスを使用すると、内部クラス.一般の賃貸住宅を借りる場合の問題が入れ子のクラスvs内。としてもカップルでのご回答の内部クラスを利用できないインスタンスを生成せずに、インスタンスを囲むクラスするということ保 a ポインタ インスタンスを囲むクラスを有するメモリのオーバーフローまたはスタックオーバーフローによる例外のものGCできませんのでゴミの収集、囲むクした場合でも使用しない。この明確なチェックには、次のコードout:

public class Outer {


    public  class Inner {

    }


    public Inner inner(){
        return new Inner();
    }

    @Override
    protected void finalize() throws Throwable {
    // as you know finalize is called by the garbage collector due to destroying an object instance
        System.out.println("I am destroyed !");
    }
}


public static void main(String arg[]) {

    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();

    // out instance is no more used and should be garbage collected !!!
    // However this will not happen as inner instance is still alive i.e used, not null !
    // and outer will be kept in memory until inner is destroyed
    outer = null;

    //
    // inner = null;

    //kick out garbage collector
    System.gc();

}

削除されたり、コメント // inner = null; プログラムを出力 "私は破壊され!"を維持していることでなくてはなりません。
その理由は白内インスタンスが参照されるGCを収集することはできませんので、で参照(ポインタを格納)を外インスタンスで収集することはありません。このほどこれらのオブジェクトプロジェクトで実施しています。
に比べて静内部クラスを利用するなポイントの内部クラスインスタンスではないのでインスタンスするためには、関係するクラスです。上記のプログラムの印刷ができる"私は破壊され!"場の内部クラスの静的およびインスタンス化 Outer.Inner i = new Outer.Inner();

の条件をも呼ばれる.いっpedanticで、そのえ定義"入れ子のクラス"を参照してい静内部クラスは、一つになるかを囲むインスタンス.コードなければならなくなるかもしれま

public class Outer {
    public class Inner {}

    public static class Nested {}
}

ないとして広く受け入れの定義になってる。

入れ子のクラスは、一般的な期間：すべてのクラスはトップレベルである入れ子のクラスです。内部クラスの非static入れ子のクラスです。ジョゼフ-ダーシーを書いたものについての説明入れ子の内、会員、トップレベルの授業.

う-内部クラスは入れ子のクラス...な匿名クラスの内部クラス?

編集：まだ内vs匿名...内部クラスはクラス内で定義されたクラスなど

public class A {
    public class B {
    }
}

は匿名クラスを拡張して定義されたクラスが匿名で、実際の"クラスが定義されるまで、

public class A {
}

A anon = new A() { /* you could change behavior of A here */ };

さらに編集：

Wikipedia 請求項に違いがあり Javaができないかなぁ、とおもってJavaでの8年間で最初に聞いたあ...はもちろんありません参考文献にあり、請求項に...ボトムラインは、内部クラスはクラス内で定義されたクラス(静的)や、入れ子には別の意味同じことをしているのです。

あの微妙な違いの静的および非クラスを使...基本的には非静内部クラスが暗黙的にアクセスインスタンス分野の方法は、囲むクラス(このような構成されて静的な文脈でコンパイラエラー)。静入れ子のクラスについてお答えください暗黙的なアクセスインスタンスの分野や方法を構築することができ、静的コンテキスト

学習者を対象に、初心者Javaおよび/または入れ子のクラス

入れ子のクラスのいずれかです:
1.静的な入れ子になった。
2.非静的な入れ子になった。(としても知られる 内部クラス)=>憶えていてください

1.内部クラス
例:

class OuterClass  {
/*  some code here...*/
     class InnerClass  {  }
/*  some code here...*/
}

内部クラスはサブセットの入れ子のクラス:

内部クラスは特定の型の入れ子のクラス
内部クラスはサブセットの入れ子のクラス
であると言えるだろう、 内部クラスにも入れ子のクラスですないという入れ子のクラスも、内部クラス.

名物の内部クラス:

インスタンスの内部クラスは、 すべてのアクセス のメンバーの外側のクラスは、印されている"プライベート"

2.静入れ子のクラス:
例:

class EnclosingClass {
  static class Nested {
    void someMethod() { System.out.println("hello SO"); }
  }
}

例1:スをインスタンス化静的な入れ子のクラスから非囲むクラス

class NonEnclosingClass {

  public static void main(String[] args) {
    /*instantiate the Nested class that is a static
      member of the EnclosingClass class:
    */

    EnclosingClass.Nested n = new EnclosingClass.Nested(); 
    n.someMethod();  //prints out "hello"
  }
}

事例2：スをインスタンス化静的な入れ子のクラスからは、囲むクラス

class EnclosingClass {

  static class Nested {
    void anotherMethod() { System.out.println("hi again"); } 
  }

  public static void main(String[] args) {
    //access enclosed class:

    Nested n = new Nested(); 
    n.anotherMethod();  //prints out "hi again"
  }

}

名物の静的ラ

静内部クラスだけにアクセスし、その外側のクラスは、アクセスの非staticます。

結論:
質問の主な違いは、内部クラスおよび静的な入れ子のクラスJava?
回答: だけを通して具体的な各クラス。

内部クラス や 入れ子のクラスの静的 Javaと宣言されたクラス内の別のクラスとして知られるトップレベルのクラスJava.Javaにおける用語の場合を宣言するのに入れ子のクラスの静的で呼び入れ子の静的なJavaのクラスではないクラスを使用すると単に"としての内部クラスです。

何の内部クラスJava?

任意のクラスではないトップレベルに宣言された内部クラスとして知られる入れ子のクラスには入れ子のクラス、クラスの宣言された静と呼ばれる内部クラスJava.についての内部クラスJava:

1)地域の内部クラスで宣言された内部コードブロックまたは方法です。
2)匿名の内部クラスであるクラスでない名前を参照および初期化された時と同じ場所で作成されます。
3）会員の内部クラスで宣言されて静員外クラスです。

public class InnerClassTest {
    public static void main(String args[]) {      
        //creating local inner class inside method i.e. main() 
        class Local {
            public void name() {
                System.out.println("Example of Local class in Java");

            }
        }      
        //creating instance of local inner class
        Local local = new Local();
        local.name(); //calling method from local inner class

        //Creating anonymous inner class in Java for implementing thread
        Thread anonymous = new Thread(){
            @Override
            public void run(){
                System.out.println("Anonymous class example in java");
            }
        };
        anonymous.start();

        //example of creating instance of inner class
        InnerClassTest test = new InnerClassTest();
        InnerClassTest.Inner inner = test.new Inner();
        inner.name(); //calling method of inner class
    }

     //Creating Inner class in Java
    private class Inner{
        public void name(){
            System.out.println("Inner class example in java");
        }
    }
}

何が入れ子の静的なJavaのクラス?

入れ子の静的クラスが別のクラスで宣言された内部クラスとして、会員としております。入れ子の静的クラスが宣言されたメンバーとしての外側のクラスで作る、民間、公的機関または保護されいます。の利益の入れ子の静的クラス以上の内部クラスは、インスタンスは入れ子のクラスの静的なを囲むインスタンスの外側のクラスです。 おもなインスタンスの外側を作成するクラスのインスタンスで入れ子の静的なJavaのクラス.

1)アクセス可能で 静的データメンバー 外クラスを含む。
2)静的な入れ子のクラスアクセスできません 非静的インスタンスデータ員 または方法.

public class NestedStaticExample {
    public static void main(String args[]){  
        StaticNested nested = new StaticNested();
        nested.name();
    }  
    //static nested class in java
    private static class StaticNested{
        public void name(){
            System.out.println("static nested class example in java");
        }
    }
}

Ref: 内部クラスおよび入れ子の静的なJavaのクラスと例

ることはできないこのプログラムを使ってこの通知ポスター:静巣のクラスで最初の内部クラスです。例えば:

 public static class A {} //ERROR

 public class A {
     public class B {
         public static class C {} //ERROR
     }
 }

 public class A {
     public static class B {} //COMPILE !!!

 }

なので、まとめ、静的クラスからのクラスにその入っています。うにしなくてはならないため、通常のクラスです。（通常のクラスを必要とします。

時を宣言しているため静会員クラスの内部クラスとして知られるトップレベルの入れ子のクラスまたは静的な入れ子のクラスです。で実証することができ下記の通りとなります。

class Test{
    private static int x = 1;
        static class A{
        private static int y = 2;
        public static int getZ(){
            return B.z+x;
        }
    }
    static class B{
        private static int z = 3;
        public static int getY(){
            return A.y;
        }
    }
}

class TestDemo{
     public static void main(String[] args){
        Test t = new Test();
        System.out.println(Test.A.getZ());
        System.out.println(Test.B.getY());
    }
}

時を宣言いたしました非会員クラスの内部クラスとして知られる内部クラスです。内部クラス実証することができ下記の通りとなります。

    class Test{
        private int i = 10;
        class A{
            private int i =20;
            void display(){
            int i = 30;
            System.out.println(i);
            System.out.println(this.i);
            System.out.println(Test.this.i);
        }
    }
}

以下の例で static nested class や inner class:

OuterClass.java

public class OuterClass {
     private String someVariable = "Non Static";

     private static String anotherStaticVariable = "Static";  

     OuterClass(){

     }

     //Nested classes are static
     static class StaticNestedClass{
        private static String privateStaticNestedClassVariable = "Private Static Nested Class Variable"; 

        //can access private variables declared in the outer class
        public static void getPrivateVariableofOuterClass(){
            System.out.println(anotherStaticVariable);
        }
     }

     //non static
     class InnerClass{

         //can access private variables of outer class
         public String getPrivateNonStaticVariableOfOuterClass(){
             return someVariable;
         }
     }

     public static void accessStaticClass(){
         //can access any variable declared inside the Static Nested Class 
         //even if it private
         String var = OuterClass.StaticNestedClass.privateStaticNestedClassVariable; 
         System.out.println(var);
     }

}

OuterClassTest:

public class OuterClassTest {
    public static void main(String[] args) {

        //access the Static Nested Class
        OuterClass.StaticNestedClass.getPrivateVariableofOuterClass();

        //test the private variable declared inside the static nested class
        OuterClass.accessStaticClass();
        /*
         * Inner Class Test
         * */

        //Declaration

        //first instantiate the outer class
        OuterClass outerClass = new OuterClass();

        //then instantiate the inner class
        OuterClass.InnerClass innerClassExample =  outerClass. new InnerClass();

        //test the non static private variable
        System.out.println(innerClassExample.getPrivateNonStaticVariableOfOuterClass()); 

    }

}

と思いなしの回答がこのような形にしておくこと例きの差入れ子のクラスおよび静的な入れ子のクラスの応募デザイン。との主な違いは静的な入れ子のクラスの内部クラスは、アクセスする能力、外側のクラスのインスタンス。

ましょうを見せてくれるので，次の二つの例です。

静巣のクラス：は、例えば静的な入れ子のクラスでビルダーパターンhttps://dzone.com/articles/design-patterns-the-builder-pattern).

のためのBankAccountを使用していまクラスを使用すると、これは主に

静巣クラスのインスタンスが作成される前に、外側のクラスです。
をビルダーパターンをビルダーでのヘルパークラスを作成するのに使用されBankAccount.
BankAccount.ビルダーのみに伴うBankAccount.他のクラスに関連しBankAccount.ビルダを構築します。なめしを使わずに名前。

public class BankAccount {

    private long accountNumber;
    private String owner;
    ...

    public static class Builder {

    private long accountNumber;
    private String owner;
    ...

    static public Builder(long accountNumber) {
        this.accountNumber = accountNumber;
    }

    public Builder withOwner(String owner){
        this.owner = owner;
        return this; 
    }

    ...
    public BankAccount build(){
            BankAccount account = new BankAccount(); 
            account.accountNumber = this.accountNumber;
            account.owner = this.owner;
            ...
            return account;
        }
    }
}

内部クラス:共通利用内部クラスで定義するイベントハンドラです。https://docs.oracle.com/javase/tutorial/uiswing/events/generalrules.html

のためのMyClassを用いて、内部クラスを中心にするためには、多くの

内部クラスMyAdapterへのアクセスを必要とされる外部クラスです。
この例では、次MyAdapterが付きます。他のクラスに関連しMyAdapter.なめしを使用せずに名前条約

public class MyClass extends Applet {
    ...
        someObject.addMouseListener(new MyAdapter());
    ...
    class MyAdapter extends MouseAdapter {
        public void mouseClicked(MouseEvent e) {
            ...// Event listener implementation goes here...
            ...// change some outer class instance property depend on the event
        }
    }
}

まずはありませんこのようなクラスと呼ばれStaticクラスです。にStatic修飾子の使用と内部クラスと呼ばれる、入れ子のクラス)というのでは静電気を会員の外部クラスまでのアクセスとして他の静員となインスタンスの外側のクラスです。（利益の静的なすようになりました。)

差を利用入れ子のクラスは、通常の内部クラスは:

OuterClass.InnerClass inner = new OuterClass().new InnerClass();

まず最初にできるインスタンスを生成するOuterclassそのアクセスできます。

が入れ子のクラスはその構文:

OuterClass.InnerClass inner = new OuterClass.InnerClass();

を利用した静的な構文と通常の実施静キーワードとなります。

Javaプログラミング言語のできるクラスを定義するためのその他のクラスです。どのクラスを呼び入れ子のクラスはこちら:

class OuterClass {
...
class NestedClass {
    ...
    }
}

入れ子のクラスがあります:静的および非おります。入れ子のクラスはstaticとして宣言されたという静的な入れ子になった。非静入れ子のクラスと呼ばれる内部クラス.こだけは非静入れ子のクラス内側クラス）のアクセスの他のメンバーは、囲むクラスの場合でも、宣言されています。静入れ子のクラスアクセスの他のメンバーは、囲むクラスの場合は対応します。できませんのでアクセスの非staticの外側のクラスです。どのクラスメソッドは、変数、静的な入れ子のクラスに関連する外クラスです。例えば、オブジェクトのクラスを使用すると、この構文:

OuterClass.StaticNestedClass nestedObject =
 new OuterClass.StaticNestedClass();

OuterClass.InnerClass innerObject = new OuterClass().new InnerClass();

なぜ入れ子のクラス

うものですし、そうやって論理的にグループ化されたクラスのみにする"にチェックを入れてください。
そのために、この封止.
でも読みやすくするために、保守性のコードです。

ソース： Java™のチュートリアル-入れ子のクラス

その違いは、入れ子のクラスの宣言もしている静止できるインスタンスを生成外、囲むクラスです。

き入れ子のクラスの宣言とはない静されていること 内部クラス, Javaんだインスタンス化で経由、囲むクラスです。のオブジェクトで制作し、内部クラスのオブジェクトから作成された外側のクラスの内部クラスを参照の分野の外に

があった場合の静的にリンクが存在しないと、外側の分野でアクセスできない（通常の参照と同様にオブジェクト)ができるインスタンスを生成メソッドは、入れ子のクラスそのものです。

のように多くの正しいとエラーのシナリオで起こるjavaコードです。

    class Outter1 {

        String OutStr;

        Outter1(String str) {
            OutStr = str;
        }

        public void NonStaticMethod(String st)  {

            String temp1 = "ashish";
            final String  tempFinal1 = "ashish"; 

            //  below static attribute not permitted
            // static String tempStatic1 = "static";    

            //  below static with final attribute not permitted         
            // static final String  tempStatic1 = "ashish";  

            // synchronized keyword is not permitted below          
            class localInnerNonStatic1 {            

                synchronized    public void innerMethod(String str11) {
                    str11 = temp1 +" sharma";
                    System.out.println("innerMethod ===> "+str11);
                }

                /* 
        //  static method with final not permitted
          public static void innerStaticMethod(String str11) { 

                    str11 = temp1 +" india";
                    System.out.println("innerMethod ===> "+str11);
                }*/
            }

            // static class not permitted below
            //  static class localInnerStatic1 {   }                            

        }

        public static  void StaticMethod(String st)     {

            String temp1 = "ashish";
            final String  tempFinal1 = "ashish"; 

            // static attribute not permitted below
            //static String tempStatic1 = "static";     

            //  static with final attribute not permitted below
            // static final String  tempStatic1 = "ashish";                         

            class localInnerNonStatic1 {
                public void innerMethod(String str11) {
                    str11 = temp1 +" sharma";
                    System.out.println("innerMethod ===> "+str11);
                }

                /*
    // static method with final not permitted
    public static void innerStaticMethod(String str11) {  
                    str11 = temp1 +" india";
                    System.out.println("innerMethod ===> "+str11);
                }*/
            }

            // static class not permitted below
            //  static class localInnerStatic1 {   }    

        }

        // synchronized keyword is not permitted
        static  class inner1 {          

            static String  temp1 = "ashish";
            String  tempNonStatic = "ashish";
            // class localInner1 {

            public void innerMethod(String str11) {
                str11 = temp1 +" sharma";
                str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }

            public static void innerStaticMethod(String str11) {
                //  error in below step
                str11 = temp1 +" india";    
                //str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }
            //}
        }

        //synchronized keyword is not permitted below
        class innerNonStatic1 {             

//This is important we have to keep final with static modifier in non
// static innerclass below
            static final String  temp1 = "ashish";  
            String  tempNonStatic = "ashish";
            // class localInner1 {

            synchronized    public void innerMethod(String str11) {
                tempNonStatic = tempNonStatic +" ...";
                str11 = temp1 +" sharma";
                str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }

            /*
            //  error in below step
            public static void innerStaticMethod(String str11) {   
                            //  error in below step
                            // str11 = tempNonStatic +" india";                     
                            str11 = temp1 +" india";
                            System.out.println("innerMethod ===> "+str11);
                        }*/
                    //}
                }
    }

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow