Zusammenfassung anonymer innerer Klassen in Java

Anonyme innere Klassen sind auch innere Klassen ohne Namen

Da sie keine Namen haben, können anonyme innere Klassen nur einmal verwendet werden. Sie werden normalerweise verwendet, um das Schreiben von Code zu vereinfachen

Verwenden Sie jedoch anonym Innere Klassen Es gibt auch eine Voraussetzung für eine Klasse: Sie muss eine übergeordnete Klasse erben oder eine Schnittstelle implementieren

Beispiel 1: Verwenden Sie keine anonymen inneren Klassen, um abstrakte Methoden zu implementieren

abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

run-Ergebnis: etwas essen

Wie Sie sehen können, haben wir die Person-Klasse mit Child geerbt, dann eine Instanz von Child implementiert und sie in einen Verweis auf die Person-Klasse umgewandelt

Wenn hier jedoch die Child-Klasse nur einmal verwendet wird, wäre es dann nicht mühsam, sie als unabhängige Klasse zu schreiben?

Zu diesem Zeitpunkt wurden anonyme innere Klassen eingeführt

Beispiel 2: Grundlegende Implementierung anonymer innerer Klassen

abstract class Person {
    public abstract void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

Laufergebnis: Etwas essen

Wie Sie sehen, implementieren wir die Methoden direkt in der abstrakten Klasse Person in geschweiften Klammern

Auf diese Weise können wir das Schreiben einer Klasse weglassen

Außerdem anonyme innere Klassen können auch auf Schnittstellen verwendet werden

Beispiel 3: Verwendung anonymer innerer Klassen auf Schnittstellen

interface Person {
    public void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

Ergebnisse ausführen: etwas essen

Aus dem oben Wie aus dem Beispiel ersichtlich ist, können die Methoden in ihren Unterklassen mithilfe anonymer innerer Klassen implementiert werden, solange eine Klasse abstrakt oder eine Schnittstelle ist.

Die häufigste Situation ist die Multithread-Implementierung. weil Um Multithreading zu implementieren, müssen Sie die Thread-Klasse oder die Runnable-Schnittstelle erben

Beispiel 4: Anonyme innere Klassenimplementierung der Thread-Klasse

public class Demo {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}

Running Ergebnisse: 1 2 3 4 5

Beispiel 5: Anonyme innere Klassenimplementierung der Runnable-Schnittstelle

public class Demo {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
    }
}

Laufende Ergebnisse: 1 2 3 4 5