Las clases anónimas son clases que no pueden tener nombres, por lo que no hay forma de hacer referencia a ellas. Deben declararse como parte de la nueva declaración en el momento de la creación. Esto requiere otra forma de declaración nueva, como sigue: nueva <clase o interfaz> <cuerpo de clase> Esta forma de declaración nueva declara una nueva clase anónima que extiende una clase determinada o implementa una interfaz determinada. También crea una nueva instancia de esa clase y la devuelve como resultado de la declaración. La clase que se ampliará y la interfaz que se implementará son los operandos de la nueva declaración, seguidos del cuerpo de la clase anónima. Si una clase anónima extiende otra clase, su cuerpo puede acceder a los miembros de la clase, anular sus métodos, etc., como cualquier otra clase estándar. Si una clase anónima implementa una interfaz, su cuerpo debe implementar los métodos de la interfaz.
código java
Copie el código de código de la siguiente manera:
interfaz pr
{
impresión nula1();
}
clase pública noNameClass
{
destino de relaciones públicas()
{
devolver nuevo pr(){
impresión pública vacía1()
{
System.out.println("¡Hola mundo!");
}
};
}
principal vacío estático público (argumentos de cadena [])
{
noNameClass c = nuevo noNameClass();
pr hw=c.dest();
hw.print1();
}
}
PR también puede ser una clase, pero el método que llama externamente debe declararse en su clase o interfaz. Los métodos dentro de la clase anónima no se pueden llamar desde el exterior.
Quizás el lugar más utilizado para clases anónimas internas en Java sea agregar Listner a Frame.
como sigue:
código java
Copie el código de código de la siguiente manera:
importar java.awt.*;
importar java.awt.event.*;
la clase pública QFrame extiende el marco {
QFrame público() {
this.setTitle(/"mi aplicación/");
addWindowListener(nuevo WindowAdapter() {
ventana vacía públicaClosing(WindowEvent e) {
disponer();
Sistema.salir(0);
}
});
this.setBounds(10,10,200,200);
}
}
Una clase anónima interna es para crear una clase interna, pero no te da un nombre, es decir, no hay ninguna variable que haga referencia a la instancia.
Copie el código de código de la siguiente manera:
nuevo Adaptador de ventana() {
ventana vacía públicaClosing(WindowEvent e) {
disponer();
Sistema.salir(0);
}
}
new es crear un objeto WindowAdapter, y lo siguiente {} indica que la operación entre paréntesis actúa sobre el nombre del objeto predeterminado, y lo siguiente en el programa Java anterior es un cuerpo de función.
El propósito de este uso es crear una instancia de un objeto y anular una de sus funciones. Puede encontrarlo abriendo el código de WindowAdapter. Es una clase abstracta. Es una implementación de la interfaz WindowListener. El parámetro de Frame.addWindowListner(); es un WindowListner y la implementación consiste en pasar una clase anónima derivada de WindowAdapter.
1. ¿Cómo determinar la existencia de una clase anónima? No puedo ver el nombre, parece que es solo un objeto creado por nuevo de la clase principal y no hay ningún nombre para la clase anónima.
Veamos primero el pseudocódigo.
Copie el código de código de la siguiente manera:
clase abstracta Padre(){
....
}
Prueba de clase pública {
Padre f1 = new Padre(){ .... } //Aquí hay una clase interna anónima
}
En términos generales, cuando se crea un objeto nuevo, debe haber un punto y coma después del paréntesis, es decir, finaliza la declaración del nuevo objeto.
Pero es diferente cuando hay clases internas anónimas. Los paréntesis van seguidos de llaves, y las llaves contienen el método de implementación específico del nuevo objeto.
Porque sabemos que una clase abstracta no puede ser nueva directamente. Debe haber una clase de implementación antes de que podamos crear una nueva clase de implementación.
El pseudocódigo anterior indica que nueva es la clase de implementación de Padre, y esta clase de implementación es una clase interna anónima.
De hecho, dividir la clase interna anónima anterior puede ser
Copie el código de código de la siguiente manera:
clase SonOne extiende Padre {
...//El código aquí es el mismo que el de la clase interna anónima anterior, el código entre llaves
}
Prueba de clase pública {
Padre f1 = nuevo SonOne();
}
2. Precauciones para clases internas anónimas Tenga en cuenta que la declaración de clases anónimas se realiza en tiempo de compilación y la creación de instancias se realiza en tiempo de ejecución. Esto significa que una nueva declaración en un bucle for creará varias instancias de la misma clase anónima, en lugar de crear una instancia de varias clases anónimas diferentes.
Cuando utilice clases internas anónimas, tenga en cuenta los siguientes principios:
・Las clases internas anónimas no pueden tener constructores.
・Las clases internas anónimas no pueden definir miembros, métodos ni clases estáticos.
・Las clases internas anónimas no pueden ser públicas, protegidas, privadas o estáticas.
・Solo se puede crear una instancia de una clase interna anónima.
・Detrás de new debe haber una clase interna anónima y se utiliza para implementar implícitamente una interfaz o implementar una clase.
・Dado que las clases internas anónimas son clases internas locales, todas las restricciones sobre las clases internas locales tienen efecto sobre ellas.
・Las clases internas solo pueden acceder a variables estáticas o métodos estáticos de clases externas.
esto en clases anónimas y clases internas:
A veces usaremos algunas clases internas y clases anónimas. Cuando se usa esto en una clase anónima, se refiere a la clase anónima o a la clase interna misma. En este momento, si queremos utilizar los métodos y variables de la clase externa, debemos agregar el nombre de la clase externa.
3. El papel de las clases internas anónimas.
Las clases internas de Java son fundamentalmente diferentes de las clases anidadas en C++: las clases anidadas de C++ no tienen identificadores para las clases contenedoras. Solo expresa el concepto de encapsulación; pero la clase interna de Java es diferente: puede acceder a los miembros de la clase envolvente (lo que significa que tiene un identificador para la clase envolvente).
Las clases internas anónimas son una forma simplificada de escribir clases internas: return new Wrapper {
...
};
Equivalente a: Wrapped extiende Wrapper {
...
}
devolver nuevo envuelto();
¿Es este el único papel de las clases internas anónimas?
Considere este caso:
Copie el código de código de la siguiente manera:
interfaz ICount {
int recuento();
}
clase padre {
int yo = 0;
int recuento() {
devolver i++;
}
}
Hay una clase Child, que no solo quiere heredar el método count () de Parent, sino que también quiere implementar el método count en la interfaz ICount. Las clases internas pueden entrar en juego:
Copie el código de código de la siguiente manera:
clase Niño extiende Padre {
ICount getCount() {
devolver nuevo ICount {
int yo = 0;
int recuento() {
retorno (yo *= 2);
}
}
}
}
mira este codigo
Copie el código de código de la siguiente manera:
público estático vacío principal (String [] argumentos) {
laAplicación = nuevo Analizador();
SwingUtilities.invokeLater(new Runnable() { // Clase ejecutable anónima
// objeto
public void run() { // Ejecutar método ejecutado en hilo
theApp.creatGUI(); // Llamar al creador de GUI estática
}
});
}
público estático vacío principal (String [] argumentos) {
theApp = new Analyzer(); // Crea un objeto
SwingUtilities.invokeLater(new Runnable() { // Clase ejecutable anónima
// Una clase interna anónima que implementa un hilo
// Originalmente, este método debía pasar un parámetro de tipo Runnable // Esto se puede lograr a través de este método de clase anónimo
// objeto
public void run() { // Ejecutar método ejecutado en hilo
theApp.creatGUI(); // Llamar al creador de GUI estática
}
});
}
