anonymous classes in Java are unnamed classes, ideal for defining and instantiating implementations of classes or interfaces in-place, without the need for additional files. Its single-use nature prevents its reuse. Unlike local classes (declarations), anonymous ones are expressions that generate a single object, assignable to a variable.

They are especially useful when a class is used only once, such as when defining a specific method of an interface or abstract class. Its application is frequent in Java Swing with event listeners or lambda functions (arrow functions).

As a curious fact, the Java compiler assigns them an automatic name (e.g. ClaseContenedora.class), formed by the name of the containing class and a number that indicates its position.

Syntax:

Being an expression, its syntax resembles the invocation of a constructor, but instead, it contains a block of code that defines the structure of the class:

ClaseOInterfaz nombreVariable = new ClaseOInterfaz() {
    // Cuerpo de la clase anónima
};

The key components are:

• The operator new.
• The name of the class to extend or the interface to implement.
• Parentheses with the constructor arguments (if you have them), just like when instantiating a normal class. In interfaces, parentheses are empty.
• Keys that lock the body of the class.
• It is declared and instantiated in a single line, stored in a variable.

Types of Anonymous Classes:

• Extension of a class.
• Extension of an abstract class.
• Implementation of an interface.
• Argument of a method.

Examples:

1. Extension of a class:

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

2. Extension of an abstract class:

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

3. Implementation of an interface:

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

4. Argument of a method:

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

Advantages:

• Creation of objects only when they are needed.
• Modifying the behavior of classes or interfaces without subclasses.
• More concise and readable code.
• Time savings by avoiding additional files.

Scope:

Similar to normal classes, with access to local variables of the container scope, with the restrictions of not being able to declare static initializers or interfaces, and the limitation of access to non-final or effectively final local variables.

Conclusion:

Anonymous classes are a powerful and versatile tool in Java, useful for unique and concise implementations. Its use, although sometimes implicit, simplifies the code and improves efficiency. For more information, see the official Java documentation.

The above is the detailed content of Anonymous classes in Java. For more information, please follow other related articles on the PHP Chinese website!