Cours anonymes en Java

Les

classes anonymes en Java sont des classes sans nom, idéales pour définir et instancier des implémentations de classes ou d'interfaces sur place, sans avoir besoin de fichiers supplémentaires. Son caractère à usage unique empêche sa réutilisation. Contrairement aux classes locales (déclarations), les classes anonymes sont des expressions qui génèrent un seul objet, attribuable à une variable.

Ils sont particulièrement utiles lorsqu'une classe n'est utilisée qu'une seule fois, par exemple lors de la définition d'une méthode spécifique d'une interface ou d'une classe abstraite. Son application est fréquente en Java Swing avec des fonctions event listeners ou lambda (fonctions fléchées).

Comme fait curieux, le compilateur Java leur attribue un nom automatique (par exemple ClaseContenedora.class), formé par le nom de la classe contenant et un numéro qui indique sa position.

Syntaxe :

Étant une expression, sa syntaxe ressemble à l'invocation d'un constructeur, mais à la place, elle contient un bloc de code qui définit la structure de la classe :

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

Les composants clés sont :

• L'opérateur new.
• Le nom de la classe à étendre ou l'interface à implémenter.
• Parenthèses avec les arguments du constructeur (si vous en avez), comme lors de l'instanciation d'une classe normale. Dans les interfaces, les parenthèses sont vides.
• Clés qui verrouillent le corps de la classe.
• Il est déclaré et instancié sur une seule ligne, stocké dans une variable.

Types de cours anonymes :

• Extension d'un cours.
• Extension d'une classe abstraite.
• Mise en place d'une interface.
• Argument d'une méthode.

Exemples :

1. Prolongation d'un cours :

<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. Extension d'une classe abstraite :

<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. Mise en place d'une interface :

<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 d'une méthode :

<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>

Avantages :

• Création d'objets uniquement lorsqu'ils sont nécessaires.
• Modifier le comportement des classes ou des interfaces sans sous-classes.
• Code plus concis et lisible.
• Gain de temps en évitant les fichiers supplémentaires.

Portée :

Similaire aux classes normales, avec accès aux variables locales de la portée du conteneur, avec les restrictions de ne pas pouvoir déclarer d'initialiseurs ou d'interfaces statiques, et la limitation de l'accès aux variables locales non finales ou effectivement finales.

Conclusion :

Les classes anonymes sont un outil puissant et polyvalent en Java, utile pour des implémentations uniques et concises. Son utilisation, bien que parfois implicite, simplifie le code et améliore l'efficacité. Pour plus d'informations, consultez la documentation Java officielle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!