Einführung in die Unterschiede zwischen anonymen inneren 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

Wie aus dem obigen 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 liegt bei mehreren vor In Bezug auf die Thread-Implementierung müssen Sie zum Implementieren von Multithreading 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) {
        new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        }.start();
    }
}

Laufergebnisse: 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();
    }
}

Tatsächlich kann es geschrieben werden prägnanter

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

Laufergebnis: 1 2 3 4 5

Das obige ist der detaillierte Inhalt vonEinführung in die Unterschiede zwischen anonymen inneren Klassen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!