Anonyme Klassen in Java

Anonyme Klassen in Java sind unbenannte Klassen, ideal zum Definieren und Instanziieren von Implementierungen von Klassen oder Schnittstellen in-place, ohne dass zusätzliche Dateien erforderlich sind. Da es nur für den einmaligen Gebrauch bestimmt ist, ist eine Wiederverwendung nicht möglich. Im Gegensatz zu lokalen Klassen (Deklarationen) sind anonyme Ausdrücke, die ein einzelnes Objekt generieren, das einer Variablen zugewiesen werden kann.

Sie sind besonders nützlich, wenn eine Klasse nur einmal verwendet wird, beispielsweise beim Definieren einer bestimmten Methode einer Schnittstelle oder einer abstrakten Klasse. Seine Anwendung kommt häufig in Java Swing mit event listeners oder Lambda-Funktionen (Pfeilfunktionen) vor.

Es ist eine merkwürdige Tatsache, dass der Java-Compiler ihnen automatisch einen Namen zuweist (z. B. ClaseContenedora.class), der aus dem Namen der enthaltenden Klasse und einer Zahl besteht, die ihre Position angibt.

Syntax:

Da es sich um einen Ausdruck handelt, ähnelt seine Syntax dem Aufruf eines Konstruktors, enthält jedoch stattdessen einen Codeblock, der die Struktur der Klasse definiert:

<code class="language-java">ClaseOInterfaz nombreVariable = new ClaseOInterfaz() {
    // Cuerpo de la clase anónima
};</code>

Die Schlüsselkomponenten sind:

• Der Operator new.
• Der Name der zu erweiternden Klasse oder der zu implementierenden Schnittstelle.
• Klammern mit den Konstruktorargumenten (falls vorhanden), genau wie beim Instanziieren einer normalen Klasse. In Schnittstellen sind Klammern leer.
• Schlüssel, die den Hauptteil der Klasse sperren.
• Es wird in einer einzigen Zeile deklariert und instanziiert und in einer Variablen gespeichert.

Arten anonymer Kurse:

• Erweiterung einer Klasse.
• Erweiterung einer abstrakten Klasse.
• Implementierung einer Schnittstelle.
• Argument einer Methode.

Beispiele:

1. Erweiterung einer Klasse:

<code class="language-java">public class Carro {
    public void tipoMotor() {
        System.out.println("Motor de combustión interna");
    }
}

public class Main {
    public static void main(String[] args) {
        Carro carroCombustion = new Carro();
        Carro carroElectrico = new Carro() {
            @Override
            public void tipoMotor() {
                System.out.println("Motor eléctrico");
            }
        };
        carroCombustion.tipoMotor(); // Motor de combustión interna
        carroElectrico.tipoMotor(); // Motor eléctrico
    }
}</code>

2. Erweiterung einer abstrakten Klasse:

<code class="language-java">public abstract class ConexionBD {
    public abstract void obtenerConexion();
}

public class Main {
    public static void main(String[] args) {
        ConexionBD conexionMySQL = new ConexionBD() {
            @Override
            public void obtenerConexion() {
                System.out.println("Conexión a MySQL");
            }
        };
        ConexionBD conexionPostgreSQL = new ConexionBD() {
            @Override
            public void obtenerConexion() {
                System.out.println("Conexión a PostgreSQL");
            }
        };
        conexionMySQL.obtenerConexion(); // Conexión a MySQL
        conexionPostgreSQL.obtenerConexion(); // Conexión a PostgreSQL
    }
}</code>

3. Implementierung einer Schnittstelle:

<code class="language-java">import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numeros = Arrays.asList(5, 10, 56, 3, 2, 1, 0);
        numeros.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(numeros); // [56, 10, 5, 3, 2, 1, 0]
    }
}</code>

4. Argument einer Methode:

<code class="language-java">public class Main {
    public static void main(String[] args) {
        Thread hilo = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("Hola, soy un hilo");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        hilo.start();
    }
}</code>

Vorteile:

• Erstellung von Objekten nur dann, wenn sie benötigt werden.
• Ändern des Verhaltens von Klassen oder Schnittstellen ohne Unterklassen.
• Prägnanterer und lesbarerer Code.
• Zeitersparnis durch Vermeidung zusätzlicher Dateien.

Geltungsbereich:

Ähnlich wie bei normalen Klassen, mit Zugriff auf lokale Variablen des Containerbereichs, mit den Einschränkungen, dass keine statischen Initialisierer oder Schnittstellen deklariert werden können, und der Einschränkung des Zugriffs auf nicht endgültige oder effektiv endgültige lokale Variablen.

Fazit:

Anonyme Klassen sind ein leistungsstarkes und vielseitiges Werkzeug in Java, das für einzigartige und prägnante Implementierungen nützlich ist. Seine Verwendung, auch wenn sie manchmal implizit ist, vereinfacht den Code und verbessert die Effizienz. Weitere Informationen finden Sie in der offiziellen Java-Dokumentation.

Das obige ist der detaillierte Inhalt vonAnonyme Klassen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!