Detaillierte Erläuterung der internen Java-Klassen

Gewöhnliche innere Klassen

Es gibt zwei Hauptpunkte, die in gewöhnlichen inneren Klassen gemeistert werden müssen

hält die Eltern fest Klassenreferenz, also Variablen und Methoden, die auf alle Zugriffsrechte der übergeordneten Klasse zugreifen können

Wie interne Klassen außerhalb der übergeordneten Klasse erstellt werden

public class Main{
    public static void main(String args[]){
        Outer outer = new Outer();
        //外部类外部创建内部类
        Outer.Inner inner = outer.new Inner();
        inner.method();
    }
}
class Outer{
    private String value = "OuterValue";
    class Inner{
        public void method(){
            //持有父类引用,可以访问父类private变量value
            System.out.println(value);
        }
        //利用.this关键字,可以返回父类对象引用
        public Outer outerObject(){
            return Outer.this;
        }
    }
}

(Empfohlenes Tutorial: Java Getting Started Program )

Methoden-Innenklasse

Innere Klasse

, die direkt in der Methode definiert ist, hat die gleichen Berechtigungen wie die Methode und kann auf andere Methoden zugreifen und Mitgliedsvariablen der externen Klasse.

kann auf die Parameter dieser Methode zugreifen. Nach 1.8 müssen die Parameter nicht auf final gesetzt werden.

verfügt über dieselben Berechtigungen wie die lokalen Variablen der Methode und kann auf die lokalen Variablen zugreifen davor definiert

Auf die innere Klasse der Methode kann nur im Methodenbereich zugegriffen werden

public class Main{
    public static void main(String args[]){
        Outer outer = new Outer();
        outer.outerMethod("param");
    }
}
class Outer{
    public void outerMethod(String value){
        class Inner {
            public void innerMethod(){
                //可以访问方法参数
                //1.8以后，内部类访问的方法参数不必设置为final
                System.out.println(value);
            }
        }
        new Inner().innerMethod();
    }
}

Anonyme innere Klasse

Anonyme innere Klasse ist eigentlich Ein Schlüsselpunkt, und es ist auch ein Wissenspunkt, den wir häufig verwenden.

Zum Beispiel einen neuen Thread erstellen

public class Main{
    public static void main(String args[]){
        Thread a = new Thread(new Runnable(){
            @Override
            public void run(){
                System.out.println("thread a is running;");
            }
        });
        a.start();
    }
}

Der obige Code bedeutet, ein anonymes Klassenobjekt zu erstellen, das die Runnable-Schnittstelle implementiert, was aus Gründen der Schreibfreundlichkeit dem folgenden Code entspricht , wir verwenden oft den zweiten Typ

public class Main{
    public static void main(String args[]){
        Thread a = new Thread(new RunnableImp());
        a.start();
    }
    static class RunnableImp implements Runnable{
        @Override
        public void run(){
            System.out.println("thread a is running;");
        }
    }
}

Statische innere Klasse

Beachten Sie die folgenden zwei Punkte

Um ein statisches inneres Klassenobjekt zu erstellen, müssen Sie Folgendes tun Benötigt kein Objekt der äußeren Klasse (normale innere Klassen erfordern )

Kann nicht auf nicht statische externe Klassenmethoden oder Mitgliedsvariablen von statischen inneren Klassen zugreifen

public class Main{
    Outer.Inner inner = new Outer.Inner();
}

class Outer{
    private String ordValue;
    private static String staValue;
    static class Inner{
        {
            System.out.println(staValue);

            //这句编译通不过
            //System.out.println(ordValue);
        }
    }
}

Empfehlungen für entsprechende Video-Tutorials: Java-Video

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der internen Java-Klassen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!