Clase interna anónima en Java

Las clases anidadas en Java  son un requisito previo requerido antes de seguir adelante para comprender la clase interna anónima. Es una clase interna sin nombre y para la que solo se crea un único objeto. Una clase interna anónima puede ser útil al crear una instancia de un objeto con ciertos «extras», como anular métodos de una clase o interfaz, sin tener que subclasificar una clase.

Sugerencia: las clases internas anónimas son útiles para escribir clases de implementación para interfaces de escucha en la programación de gráficos. 

La sintaxis de una expresión de clase anónima es como la invocación de un constructor, excepto que hay una definición de clase contenida en un bloque de código. 

Sintaxis:

// Test can be interface,abstract/concrete class
Test t = new Test() 
{
   // data members and methods
   public void test_method() 
   {
      ........
      ........
    }   
};

Ahora analicemos la diferencia entre la clase regular (clases normales) y la clase interna anónima

• Una clase normal puede implementar cualquier cantidad de interfaces, pero la clase interna anónima solo puede implementar una interfaz a la vez.
• Una clase regular puede extender una clase e implementar cualquier cantidad de interfaces simultáneamente. Pero la clase interna anónima puede extender una clase o implementar una interfaz, pero no ambas a la vez.
• Para la clase regular/normal, podemos escribir cualquier cantidad de constructores, pero no podemos escribir ningún constructor para la clase interna anónima porque la clase anónima no tiene ningún nombre y, al definir el nombre de la clase del constructor, el nombre del constructor debe ser el mismo.

Acceso a variables locales del ámbito adjunto y declaración y acceso a miembros de la clase anónima 

Al igual que las clases locales, las clases anónimas pueden capturar variables; tienen el mismo acceso a las variables locales del alcance adjunto:  

• Una clase anónima tiene acceso a los miembros de su clase envolvente.
• Una clase anónima no puede acceder a variables locales en su ámbito adjunto que no estén declaradas como finales o efectivamente finales.
• Al igual que una clase anidada, una declaración de un tipo (como una variable) en una clase anónima sombrea cualquier otra declaración en el ámbito adjunto que tenga el mismo nombre.

Las clases anónimas también tienen las mismas restricciones que las clases locales con respecto a sus miembros: 

• No podemos declarar inicializadores estáticos o interfaces de miembros en una clase anónima.
• Una clase anónima puede tener miembros estáticos siempre que sean variables constantes.

Nota: Podemos declarar lo siguiente en clases anónimas de la siguiente manera:

• Campos
• Métodos adicionales (incluso si no implementan ningún método del supertipo)
• Inicializadores de instancia
• clases locales

Maneras:

Las clases internas anónimas se crean de forma genérica a través de las siguientes dos formas enumeradas a continuación: 

1. Clase (puede ser abstracto o concreto)
2. Interfaz

Ahora tomemos un ejemplo con el que entenderemos la clase interna anónima, tomemos un programa simple

Ejemplo

// Java program to demonstrate Need for
// Anonymous Inner class
 
// Interface
interface Age {
 
    // Defining variables and methods
    int x = 21;
    void getAge();
}
 
// Class 1
// Helper class implementing methods of Age Interface
class MyClass implements Age {
 
    // Overriding getAge() method
    @Override public void getAge()
    {
        // Print statement
        System.out.print("Age is " + x);
    }
}
 
// Class 2
// Main class
// AnonymousDemo
class GFG {
    // Main driver method
    public static void main(String[] args)
    {
        // Class 1 is implementation class of Age interface
        MyClass obj = new MyClass();
 
        // calling getage() method implemented at Class1
        // inside main() method
        obj.getAge();
    }
}

Producción:

Explicación de salida:

En el programa anterior, la interfaz Age se crea con el método getAge() y x=21. Myclass está escrita como una clase de implementación de la interfaz Age. Como se hizo en Program, no hay necesidad de escribir una clase separada Myclass. En su lugar, copie directamente el código de Myclass en este parámetro, como se muestra aquí: 

Age oj1 = new Age() 
{
    @Override
    public void getAge() 
    {
        System.out.print("Age is " + x);
    }
};

Aquí, no se crea un objeto para Age, pero se crea un objeto de Myclass y se copia en todo el código de la clase, como se muestra arriba. Esto solo es posible con una clase interna anónima. Tal clase se llama ‘clase interna anónima’, por lo que aquí llamamos ‘Miclase’ como clase interna anónima.

Ejemplo:

// Java Program to Demonstrate Anonymous inner class
 
// Interface
interface Age {
    int x = 21;
    void getAge();
}
 
// Main class
class AnonymousDemo {
   
    // Main driver method
    public static void main(String[] args)
    {
 
        // Myclass is hidden inner class of Age interface
        // whose name is not written but an object to it
        // is created.
        Age oj1 = new Age() {
           
            @Override public void getAge()
            {
                // printing  age
                System.out.print("Age is " + x);
            }
        };
       
        oj1.getAge();
    }
}

Age is 21

Tipos de clase interna anónima

Según la declaración y el comportamiento, hay 3 tipos de clases internas anónimas: 

1. Clase interna anónima que extiende una clase
2. Clase interna anónima que implementa una interfaz
3. Clase interna anónima que define el argumento del método/constructor interno

Tipo 1: clase interna anónima que amplía una clase

Podemos tener una clase interna anónima que extienda una clase. Por ejemplo, sabemos que podemos crear un hilo extendiendo una clase Thread. Supongamos que necesitamos un subproceso inmediato, pero no queremos crear una clase que amplíe la clase Subproceso todo el tiempo. Con la ayuda de este tipo de clase Anonymous Inner, podemos definir un hilo listo.

Ejemplo

// Java program to illustrate creating an immediate thread
// Using Anonymous Inner class that extends a Class
 
// Main class
class MyThread {
   
    // Main driver method
    public static void main(String[] args)
    {
        // Using Anonymous Inner class that extends a class
        // Here a Thread class
        Thread t = new Thread() {
           
            // run() method for the thread
            public void run()
            {
                // Print statement for child thread
                // execution
                System.out.println("Child Thread");
            }
        };
 
        // Starting the thread
        t.start();
 
        // Displaying main thread only for readability
        System.out.println("Main Thread");
    }
}

Main Thread
Child Thread

Tipo 2: clase interna anónima que implementa una interfaz

También podemos tener una clase interna anónima que implemente una interfaz. Por ejemplo, también sabemos que al implementar la interfaz Runnable podemos crear un Thread. Aquí usamos una clase interna anónima que implementa una interfaz.

Ejemplo

// Java program to illustrate defining a thread
// Using Anonymous Inner class that implements an interface
 
// Main class
class MyThread {
   
    // Main driver method
    public static void main(String[] args)
    {
        // Here we are using Anonymous Inner class
        // that implements a interface i.e. Here Runnable
        // interface
        Runnable r = new Runnable() {
           
            // run() method for the thread
            public void run()
            {
                // Print statement when run() is invoked
                System.out.println("Child Thread");
            }
        };
 
        // Creating thread in main() using Thread class
        Thread t = new Thread(r);
 
        // Starting the thread using start() method
        // which invokes run() method automatically
        t.start();
 
        // Print statement only
        System.out.println("Main Thread");
    }
}

Main Thread
Child Thread

Tipo 3: clase interna anónima que define el argumento del método/constructor interno

Las clases internas anónimas en argumentos de método/constructor se utilizan a menudo en aplicaciones de interfaz gráfica de usuario (GUI). Para familiarizarse con la sintaxis, echemos un vistazo al siguiente programa que crea un hilo usando este tipo de clase interna anónima

Ejemplo

// Java program to illustrate defining a thread
// Using Anonymous Inner class that define inside argument
 
// Main class
class MyThread {
    // Main driver method
    public static void main(String[] args)
    {
        // Using Anonymous Inner class that define inside
        // argument
        // Here constructor argument
        Thread t = new Thread(new Runnable() {
           
            public void run()
            {
                System.out.println("Child Thread");
            }
        });
 
        t.start();
 
        System.out.println("Main Thread");
    }
}

Main Thread
Child Thread

Sin embargo, los constructores no se pueden declarar en una clase anónima.
Este artículo es una contribución de Nishant Sharma y Bishal Kumar Dubey . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org . Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.