Java Language
入れ子クラスと内部クラス

前書き

構文

• パブリッククラスOuterClass {public class InnerClass {}} //インナークラスはprivateでもかまいません
• パブリッククラスOuterClass {public static class StaticNestedClass {}} //静的にネストされたクラスもプライベートにすることができます
• public void method（）{private class LocalClass {}} //ローカルクラスは常にprivateです。
• SomeClass anonymousClassInstance = new SomeClass（）{}; //匿名の内部クラスには名前を付けることができないため、アクセスは疑わしいです。 'SomeClass（）'が抽象クラスの場合、ボディはすべての抽象メソッドを実装する必要があります。
• SomeInterface anonymousClassInstance =新しいSomeInterface（）{}; //ボディはすべてのインターフェイスメソッドを実装する必要があります。

備考

ネストされたクラスを使用した単純なスタック

public class IntStack {

    private IntStackNode head;

    // IntStackNode is the inner class of the class IntStack
    // Each instance of this inner class functions as one link in the
    // Overall stack that it helps to represent
    private static class IntStackNode {

        private int val;
        private IntStackNode next;

        private IntStackNode(int v, IntStackNode n) {
            val = v;
            next = n;
        }
    }

    public IntStack push(int v) {
        head = new IntStackNode(v, head);
        return this;
    }

    public int pop() {
        int x = head.val;
        head = head.next;
        return x;
    }
}

そして、（特に）ネストされたクラスの存在を全く認めない、その使用。

public class Main {
    public static void main(String[] args) {
 
        IntStack s = new IntStack();
        s.push(4).push(3).push(2).push(1).push(0);

        //prints: 0, 1, 2, 3, 4, 
        for(int i = 0; i < 5; i++) {
            System.out.print(s.pop() + ", ");
        }            
    }
}

静的クラスと非静的クラス

ネストされたクラスを作成するときは、そのネストされたクラスを静的にする選択に直面します：

public class OuterClass1 {

    private static class StaticNestedClass {

    }

}

または非静的：

public class OuterClass2 {

    private class NestedClass {

    }

}

そのコアでは、静的ネストされたクラスは 、外部クラスの周囲のインスタンスを持たないのに対し、非静的なネストされたクラスはそのようにします。これは、ネストされたクラスをインスタンス化することが許可されている場所とその場所と、そのネストされたクラスのインスタンスにアクセスが許可されている場所の両方に影響します。上記の例に加えて：

public class OuterClass1 {

    private int aField;
    public void aMethod(){}

    private static class StaticNestedClass {
        private int innerField;

        private StaticNestedClass() {
             innerField = aField; //Illegal, can't access aField from static context 
             aMethod();           //Illegal, can't call aMethod from static context 
        }

        private StaticNestedClass(OuterClass1 instance) {
             innerField = instance.aField; //Legal
        }

    }

    public static void aStaticMethod() {
        StaticNestedClass s = new StaticNestedClass(); //Legal, able to construct in static context
        //Do stuff involving s...
    }

}

public class OuterClass2 {

    private int aField;

    public void aMethod() {}

    private class NestedClass {
        private int innerField;

        private NestedClass() {
             innerField = aField; //Legal   
             aMethod(); //Legal
        }
    }

    public void aNonStaticMethod() {
        NestedClass s = new NestedClass(); //Legal
    }

    public static void aStaticMethod() {
        NestedClass s = new NestedClass(); //Illegal. Can't construct without surrounding OuterClass2 instance.
                                         //As this is a static context, there is no surrounding OuterClass2 instance
    }
}

したがって、静的と非静的の主な決定は、主に外部クラスのフィールドとメソッドに直接アクセスできる必要があるかどうかによって異なりますが、ネストされたクラスをいつどこで構築できるかにも影響します。

経験則として、外部クラスのフィールドやメソッドにアクセスする必要がないかぎり、ネストされたクラスを静的にしてください。公開が必要な場合を除いて、フィールドを非公開にするのと同様に、（外部インスタンスへのアクセスを許可しないことで）ネストされたクラスで使用可能な可視性を減らし、エラーの可能性を減らします。

内部クラスのアクセス修飾子

Javaにおけるアクセス修飾子の完全な説明は、ここで見つけることができます 。しかし、彼らはどのようにInnerクラスとやりとりしますか？

publicは、いつものように、型にアクセスできるスコープに無制限のアクセス権を与えます。

public class OuterClass {

    public class InnerClass {

        public int x = 5;

    }

    public InnerClass createInner() {
        return new InnerClass();
    }
}

public class SomeOtherClass {

    public static void main(String[] args) {
        int x = new OuterClass().createInner().x; //Direct field access is legal
    }
}

protectedとdefault修飾子（何もしていない）の両方が、ネストされていないクラスに対しても同じように動作します。

興味深いことに、 private 、それが属するクラスに制限されません。むしろ、コンパイル単位（.javaファイル）に制限されます。つまり、OuterクラスはInnerクラスのフィールドとメソッドにフルアクセスできますが、 privateクラスとマークされていても使用できます。

public class OuterClass {

    public class InnerClass {

        private int x;
        private void anInnerMethod() {}
    }

    public InnerClass aMethod() {
        InnerClass a = new InnerClass();
        a.x = 5; //Legal
        a.anInnerMethod(); //Legal
        return a;
    }
}

インナークラス自体は、 public以外の可視性を持つことができます。それをprivateまたは他の制限付きアクセス修飾子にマークすることにより、他の（外部の）クラスはその型をインポートして割り当てることができません。しかし、それらは依然としてそのタイプのオブジェクトへの参照を得ることができます。

public class OuterClass {

    private class InnerClass{}

    public InnerClass makeInnerClass() {
        return new InnerClass();
    }
}

public class AnotherClass {

    public static void main(String[] args) {
        OuterClass o = new OuterClass();
     
        InnerClass x = o.makeInnerClass(); //Illegal, can't find type
        OuterClass.InnerClass x = o.makeInnerClass(); //Illegal, InnerClass has visibility private
        Object x = o.makeInnerClass(); //Legal
    }
}

匿名の内部クラス

匿名の内部クラスは、宣言され、単一のステートメントでインスタンス化される内部クラスの形式です。結果として、プログラムのどこかで使用できるクラスの名前はありません。つまり、それは匿名です。

匿名クラスは、通常軽量クラスを作成してパラメータとして渡せるようにする必要がある場合に使用します。これは、通常、インタフェースで行われます。例えば：

public static Comparator<String> CASE_INSENSITIVE =
        new Comparator<String>() {
            @Override
            public int compare(String string1, String string2) {
                return string1.toUpperCase().compareTo(string2.toUpperCase());
            }
        };

この匿名クラスは、大文字と小文字の違いを無視して2つの文字列を比較するComparator<String>オブジェクト（ CASE_INSENSITIVE ）を定義します。

匿名クラスを使用して頻繁に実装されインスタンス化されるその他のインタフェースは、 RunnableおよびCallableです。例えば：

// An anonymous Runnable class is used to provide an instance that the Thread
// will run when started.
Thread t = new Thread(new Runnable() {
        @Override 
        public void run() {
              System.out.println("Hello world");
        }
    });
t.start();  // Prints "Hello world"

匿名の内部クラスは、クラスに基づくこともできます。この場合、匿名クラスは暗黙的に既存のクラスをextendsします。拡張されるクラスが抽象クラスの場合、匿名クラスはすべての抽象メソッドを実装する必要があります。非抽象メソッドをオーバーライドすることもできます。

コンストラクタ

匿名クラスは明示的なコンストラクタを持つことはできません。代わりに、拡張されているクラスのコンストラクタにパラメータを渡すためにsuper(...)を使用する暗黙のコンストラクタが定義されています。例えば：

SomeClass anon = new SomeClass(1, "happiness") {
            @Override
            public int someMethod(int arg) {
                // do something
            }
        };

SomeClass匿名サブクラスの暗黙のコンストラクタは、呼び出しシグネチャSomeClass(int, String)と一致するSomeClassコンストラクタを呼び出します。コンストラクタが利用できない場合は、コンパイルエラーが発生します。一致したコンストラクタによってスローされた例外も、暗黙のコンストラクタによってスローされます。

もちろん、これはインターフェイスを拡張するときには機能しません。インターフェイスから匿名クラスを作成する場合、クラススーパークラスは引数なしのコンストラクタのみを持つjava.lang.Objectです。

メソッドローカルの内部クラス

メソッドローカルインナークラスと呼ばれるメソッド内に記述されたクラス 。その場合、内部クラスのスコープはメソッド内で制限されます。

メソッドローカルの内部クラスは、内部クラスが定義されているメソッド内でのみインスタンス化できます。

メソッドローカル内部クラスの使用例：

public class OuterClass {
    private void outerMethod() {
       final int outerInt = 1;
        // Method Local Inner Class
        class MethodLocalInnerClass {
            private void print() {
                System.out.println("Method local inner class " + outerInt);
            }
        }
        // Accessing the inner class
        MethodLocalInnerClass inner = new MethodLocalInnerClass();
        inner.print();
    }

    public static void main(String args[]) {
        OuterClass outer = new OuterClass();
        outer.outerMethod();
    }
}

実行すると、出力が得られます。 Method local inner class 1 。

非静的な内部クラスから外部クラスにアクセスする

外部クラスへの参照はクラス名を使用しthis

public class OuterClass {
    public class InnerClass {
        public void method() {
            System.out.println("I can access my enclosing class: " + OuterClass.this);
        }
    }
}

外部クラスのフィールドとメソッドに直接アクセスできます。

public class OuterClass {
    private int counter;

    public class InnerClass {
        public void method() {
            System.out.println("I can access " + counter);
        }
    }
}

しかし、名前の衝突の場合は、外部クラス参照を使用できます。

public class OuterClass {
    private int counter;

    public class InnerClass {
        private int counter;
        
        public void method() {
            System.out.println("My counter: " + counter);
            System.out.println("Outer counter: " + OuterClass.this.counter);
            
            // updating my counter
            counter = OuterClass.this.counter;
        }
    }
}

外部から非静的な内部クラスのインスタンスを作成する

このクラスからも、任意の外部クラスから見える内部クラスを作成することができます。

内部クラスは外部クラスに依存し、そのインスタンスへの参照を必要とします。内部クラスのインスタンスを作成するには、 new演算子は外部クラスのインスタンスに対してのみ呼び出す必要があります。

class OuterClass {

    class InnerClass {
    }
}

class OutsideClass {

    OuterClass outer = new OuterClass();
    
    OuterClass.InnerClass createInner() {
        return outer.new InnerClass();
    }
}

使用法はouter.new注意してouter.new 。