¿Cuáles son las funciones de las clases internas de Java y las clases internas anónimas?

Clases internas de Java

Hay cuatro tipos: clases internas miembro, clases internas locales, clases internas estáticas y clases internas anónimas.

1. Clase interna miembro: existe como miembro de la clase externa, yuxtapuesta con las propiedades y métodos de la clase externa.

Nota: Las variables estáticas no se pueden definir en las clases internas de los miembros, pero se puede acceder a todos los miembros de la clase externa.

clase pública externa{

privada static int i = 1;

privada int j=10;

privada int k=20 ;

public static void outside_f1(){

//hacer algo más

}

public void out_f2(){

//hacer más algo

}

//Clase interna miembro

clase interna{

//estática int internal_i =100; //No se permite definir variables estáticas en clases internas

int j=100;//Las variables de instancia de clases externas en clases internas se pueden guardar

int internal_i=1;

void internal_f1(){

System.out.println(i);//Si las variables de la clase externa no tienen el mismo nombre que la variables de la clase interna, puede usar directamente el nombre de la variable para acceder a las variables de la clase externa

System.out.println(j);// En la clase interna, use el nombre de la variable directamente para acceder a las variables propias de la clase interna

System. out.println(this.j);// También puedes usar "this. nombre de variable" en la clase interna para acceder a la variable de clase interna

// Puede acceder a la variable de instancia en la clase externa con el mismo nombre que la clase interna "Nombre de clase externa.este.Nombre de variable".

System.out.println(k);//Si la variable de la clase externa no tiene el mismo nombre que la variable de la clase interna, puedes acceder directamente a la variable de la clase externa usando el nombre de la variable

exterior_f1();

exterior_f2();

}

}

// El método no estático de la clase externa accede a la clase interna miembro

public void outside_f3(){

Inner internal = new Inner();

internal .inner_f1();

}

//El método estático de la clase externa accede a la clase interna miembro de la misma manera que accede a la clase interna miembro fuera de la clase externa

public static void outside_f4(){

/ /paso1 Crear un objeto de clase externo

Outer out = new Outer();

/ /***paso2 Crear un objeto de clase interno basado en el objeto de clase externo***

Inner internal=out.new Inner();

//método paso3 para acceder al interior clase

internal.inner_f1();

}

public static void main(String[] args){

external_f4() ;

}

}

Ventajas de las clases internas miembro:

⑴ Como miembro de la clase externa, la clase interna puede acceder a los miembros privados o propiedades de la clase externa.

(Incluso si la clase externa se declara como PRIVADA, aún es visible para la clase interna dentro de ella).

⑵ Utilice clases internas para definir propiedades a las que no se puede acceder en la clase externa. De esta manera, los derechos de acceso más pequeños que la clase privada de la clase externa se implementan en la clase externa.

Nota: Las clases internas son un concepto en tiempo de compilación. Una vez compiladas correctamente, se convertirán en dos categorías completamente diferentes. Para una clase externa llamada externa y una clase interna llamada interna definida dentro. Una vez completada la compilación, aparecen dos categorías, external.class y external$inner.class.

2. Clase interna local: es decir, la clase interna definida en el método es similar a la variable local. No hay ningún modificador público o privado delante de la clase interna local, y su alcance es el. bloque de código en el que está definido.

Nota: Las variables estáticas no se pueden definir en clases internas locales. Puede acceder a variables locales de clases externas (es decir, variables dentro de métodos), pero las variables deben ser finales.

clase pública exterior {

int privado s = 100;

int privado out_i = 1;

vacío público f(int final k){

final int s = 200;

int i = 1;

final int j = 10;

clase Interior { //Definido dentro del método

int s = 300;//Puedes definir variables con el mismo nombre que la clase externa

//static int m = 20;// No se puede definir una variable estática

Inner(int k){

Inner_f(k);

}

int Inner_i = 100;

void internal_f(int k){

System.out.println(out_i);// Si la clase interna no tiene una variable con el mismo nombre que la clase externa, se puede acceder directamente a la instancia de la clase externa en la clase interna Variables

System.out.println(k);//*****Puede acceder a variables locales de clases externas (es decir, variables dentro métodos), pero las variables deben ser finales*****

// System.out.println(i);

System.out.println(s);// Si hay una variable en la clase interna con el mismo nombre que la clase externa, úsela directamente. El nombre de la variable accede a la variable de clase interna

System.out.println(this.s); "this.variable name" también accede a la variable de clase interna

System .out.println(Outer.this.s);// Utilice "external class name.this.variable name" externo para acceder a la clase externa variables

}

}

new Inner(k);

}

public static void main( String[] args) {

//Accede a las funciones internas locales La clase primero debe tener un objeto de clase externo

Outer out = new Outer();

out .f(3);

}

}

Nota:

Las clases internas parciales no se pueden generar directamente fuera de la clase (garantía que las clases internas locales son invisibles para el mundo exterior). Si desea utilizar una clase interna local, necesita generar un objeto, el objeto llama a un método y su clase interna local se puede llamar en el método.

Logre un acoplamiento débil forzado a través de clases e interfaces internas, use clases internas locales para implementar la interfaz y devuelva el tipo de interfaz en el método, haciendo que la clase interna local sea invisible y protegiendo la visibilidad de la clase de implementación.

3. Clase interna estática: la clase interna estática se define en la clase, excepto cualquier método, se define como estática.

Nota: Los miembros estáticos o no estáticos se pueden definir en clases internas estáticas

clase pública externa {

privada static int i = 1;

private int j = 10;

public static void external_f1(){

}

public void external_f2(){

}

// Las clases internas estáticas se pueden modificar con public, protected y private

// Los miembros estáticos o no estáticos se pueden definir en clases internas estáticas

clase estática Inner{

static int internal_i = 100;

int internal_j = 200;

static void internal_f1(){

System .out.println("Outer.i"+i);//Las clases internas estáticas solo pueden acceder a miembros estáticos de clases externas

external_f1();//Incluyendo variables estáticas y métodos estáticos

}

void internal_f2(){

// System.out.println("Outer.i"+j);// Las clases internas estáticas no pueden acceder a clases externas Miembros no estáticos

// external_f2();//Incluye variables no estáticas y métodos no estáticos

}

}

public void outside_f3(){

//La clase externa accede a los miembros estáticos de la clase interna: miembros internos class.static

System.out.println( Inner.inner_i);

Inner.inner_f1();

// La clase externa accede a los miembros no estáticos de la clase interna: simplemente cree una instancia de la clase interna

Interior interior = nuevo Interior();

interior.inner_f2();

}

public static void main(String[] args) {

nuevo Exterior(). exterior_f3();

}

}

Nota: ********* Generar (nueva) una clase interna estática no requiere miembros de clase externa: esta es la diferencia entre clases internas estáticas y clases internas de miembros. Los objetos de clases internas estáticas se pueden generar directamente:

Outer.Inner in=new Outer.Inner();

No es necesario generar objetos de clases externas. En realidad, esto convierte a la clase interna estática en una clase de nivel superior. Las clases internas estáticas no se pueden definir de forma privada. *******

Ejemplo:

Para dos clases, tenga el mismo método:

clase Personas

{

ejecutar();

}

clase Máquina{

ejecutar();

}

Hay una clase de robot en este momento:

la clase Robot extiende a las personas que implementan la máquina.

En este momento, run() no se puede implementar directamente.

Nota: Cuando se produce un conflicto de nombres de métodos entre una clase y una interfaz (o entre una interfaz y una interfaz), se debe utilizar una clase interna para implementarlo. La herencia múltiple no se puede lograr completamente usando interfaces. Solo mediante el uso de interfaces y clases internas se puede lograr una herencia múltiple real.

4. Clases internas anónimas

Las clases internas anónimas son un tipo especial de clases internas locales que implementan interfaces a través de clases anónimas.

IA se define como una interfaz.

IA I=new IA(){};

Características de las clases internas anónimas:

1. Una clase se utiliza para heredar otras clases o implementar interfaces. , no es necesario agregar métodos adicionales, es solo una anulación previa o anulación de los métodos heredados.

2, sólo para obtener una instancia de objeto, sin conocer su tipo real.

3. El nombre de la clase no tiene sentido, es decir, no es necesario utilizarlo.

clase pública exterior {

privado estático int i = 1;

privado int j = 10;

público estático vacío exterior_f1( ){

}

public void outside_f2(){

}

// Las clases internas estáticas pueden usar público, protegido y privado Modificación

// Se pueden definir miembros estáticos o no estáticos en clases internas estáticas

static class Inner{

static int internal_i = 100;

int inside_j = 200;

static void inside_f1(){

System.out.println("Outer.i"+i);// Las clases internas estáticas pueden Accede solo a miembros estáticos de clases externas

external_f1();//Incluye variables estáticas y métodos estáticos

}

void internal_f2(){

// System.out.println("Outer.i"+j);// Las clases internas estáticas no pueden acceder a miembros no estáticos de clases externas

// external_f2();// Incluyendo Variables no estáticas y métodos no estáticos

}

}

public void outside_f3(){

// La clase externa accede a la estática de la clase interna Miembros: clase interna Miembros estáticos

System.out.println(Inner.inner_i);

Inner.inner_f1();

//Acceso a clases externas Miembros no estáticos de clases internas: simplemente cree una instancia de la clase interna

Inner internal = new Inner();

internal.inner_f2();

}

public static void main(String[] args) {

new Outer().outer_f3();

}

}

Nota: Una clase interna anónima debe estar detrás de new y se usa para implementar implícitamente una interfaz o implementar una clase sin un nombre de clase. Según el polimorfismo, usamos su padre. nombre de la clase. Debido a que es una clase interna local, se le aplican todas las restricciones de las clases internas locales. Las clases internas anónimas son las únicas clases sin constructores. La mayoría de las clases internas anónimas se utilizan para devoluciones de llamadas de interfaz. El sistema denomina automáticamente a la clase interna anónima Out$1.class durante la compilación. Si el tipo en tiempo de compilación de un objeto es una interfaz, su tipo de ejecución es la clase que implementa esta interfaz. Como las clases internas anónimas no tienen constructor, su ámbito de uso es muy limitado. Las clases internas locales se utilizan cuando se necesitan varios objetos, por lo que existen relativamente muchas aplicaciones de clases internas locales.

Los constructores no se pueden definir en clases internas anónimas. Si el tipo en tiempo de compilación de un objeto es una interfaz, su tipo de ejecución es la clase que implementa esta interfaz.

______________________________________________________________________________

Resumen de la clase interna:

1. Primero, trate la clase interna como un miembro especial de la clase externa, por lo que tiene miembros de clase Nivel de cierre. : privado, protegido, predeterminado (amigable), público

Tiene modificadores para los miembros de la clase: estático, final, abstracto

2. Clase interna no estática anidada, la interna. la clase tiene implícitamente un puntero this de la clase externa, por lo tanto, puede acceder a todos los recursos de la clase externa (incluidos los privados, por supuesto)

Para acceder a los miembros de la clase interna, la clase externa primero debe. Obtener el objeto de la clase interna. Y depende del nivel de encapsulación de los miembros de la clase interna.

Las clases internas no estáticas no pueden contener ningún miembro estático.

3. Clase interna estática: clase interna estática, ya no contiene el puntero this de la clase externa y se inicializa cuando la clase externa está cargada.

Una clase interna estática puede contener miembros estáticos o no estáticos.

Una clase interna estática solo puede acceder a miembros estáticos de una clase externa.

p>

Una clase externa puede acceder a miembros de una clase interna estática, sujeto a las regulaciones generales de la clase. Para miembros estáticos, puede acceder a ellos con class name.member. Para miembros no estáticos, solo puede acceder a ellos con object.member

4. Para clases internas o bloques en métodos, las clases internas solo pueden acceder. variables finales en bloques o métodos.

Hay dos tipos de miembros de clase: estáticos y no estáticos, y también hay dos tipos de clases internas

Se deben crear o pasar instancias de clases internas no estáticas los métodos de la clase externa crean una instancia de la clase externa (OuterClassInstanceName.new internalClassName (ConstructorParameter)) y pueden acceder directamente a la información de la clase externa. Se puede hacer referencia al objeto de la clase externa a través de OuterClassName.this

<. p> instancia estática de la clase interna, creada directamente Es decir, no hay referencia a la instancia de clase externa.

Las clases internas, ya sean estáticas o no estáticas, tienen referencias a clases externas

Las clases internas no estáticas no pueden tener miembros estáticos

Internas en métodos Las clases solo permiten el acceso a las variables locales finales del método y a la lista de parámetros finales del método, por lo que no hay diferencia entre la clase interna y la clase interna del método. Sin embargo, no se puede acceder a las clases internas del método fuera del método y el método no puede tener clases internas estáticas

Si una clase interna anónima hereda de una interfaz, debe implementar el método de la interfaz especificada y no tener parámetros

Si una clase interna anónima hereda de una clase, los parámetros deben pasarse como parámetros del constructor de la clase principal