[Java] Clase interna InnerClass

Java permite que la definición de una clase se ubique dentro de otra clase, la primera es la clase interna y la segunda se llama la clase externa

InnerClass generalmente define el nombre completo cuando se refiere a una clase externa en su clase o bloque de instrucciones

 

Clase interna para miembros y clase interna local

- Clase interna de miembro estático

- Clase interna de miembro no estático

Clase interna anónima

 

Clase interna estática miembro clase interna clase interna local

// En comparación con la clase interna, esta es una clase 
pública de  clase externa OuterClass {
     public  int a;
     int b;
     protected  int c;
     private  int d; 

    static  int e; 
    
    public  void memberMethod () { 
        System.out.println ( " ¡Métodos miembros de clases externas! " ); 

        // Las clases internas miembros pueden crear instancias 
        InnerClass innerClass = new InnerClass ();
         // Las clases internas estáticas pueden crear instancias 
        StaticInnerClass staticInnerClass = new StaticInnerClass (); 
    } 

    public  static void staticMethod () { 
        System.out.println ( "¡Método estático de clase externa!" ); 
    } 

    // La clase interna de miembro y la clase interna estática pueden ser abstractas o finales abstractas, y se puede acceder y modificar mediante 4 tipos de permisos 

    // miembro interno La clase no permite ninguna 
    clase de existencia estática InnerClass {
         // La clase interna del miembro puede modificar todos los permisos de acceso 
        public  int a;
         int b;
         protected  int c;
         private  int d; 

        // La clase interna del miembro no puede escribir métodos
         estáticos // static void staticMethod () {} 

        // La clase interna miembro puede declarar el método miembro 
        void memberMethod () {
             // La clase interna miembro puede llamar al método miembro de la clase externa
            OuterClass. This .memberMethod (); 

            // El método estático de la clase interna del miembro también puede llamarse 
            OuterClass.staticMethod (); 
        } 

        // La clase interna del miembro puede ser construida por 
        InnerClass () {} 

        // Acceso a cada campo 
        público  vacío checkField ( int a) {
             // Parámetro formal a 
            a = 50 ;
             // Campo de la clase interna de este miembro a 
            this .a = 100 ;
             // Campo de la clase externa a 
            OuterClass. this .a = 150 ; 
        } 
    } 

    // clases internas estáticas 
    estática  de claseStaticInnerClass {
         // La clase interna estática puede decorar todos los permisos de acceso 
        public  int a;
         int b;
         protected  int c;
         private  int d; 

        // La clase interna estática puede declarar métodos miembro 
        void memberMethod () {
             // Puede llamar a métodos estáticos de clases externas 
            OuterClass.staticMethod (); 

            // El método miembro de la clase externa no está bien
             // OuterClass.this.memberMethod (); 
        } 

        // La clase interna estática puede declarar el método 
        estático static  void staticMethod () {
             // Puede llamar al método estático de la clase externa 
            OuterClass .staticMethod (); 

            //El método miembro de la clase externa no funciona
             // OuterClass.this.memberMethod (); 
        } 

        public  void fieldCheck ( int a) {
             // Campo de parámetro formal 
            a = 100 ; 

            // Campo de clase interna estático 
            this .a = 150 ; 

            // Externo Los campos de clase solo pueden acceder a métodos estáticos y campos estáticos 
            OuterClass.e = 300 ; 
        } 

        // Las clases internas estáticas también pueden ser construidas por 
        StaticInnerClass () {} 
    } 

    public  void classMethod () {
         // Las clases internas locales no tienen acceso para modificar, solo lo hacen Utilizado en este método, puede establecer final para modificar la clase interna local 

        // Las variables locales a las que accede la clase interna deben ser Final
         //El alcance de x sobrevive en este método.
         // Cuando finaliza la llamada al método y aparece el método, se destruye la variable x. 
        Final  int x = 123 ; 
        
        // Clase de 
        clase interna local LocalInnerClass { 

            // Pero la instancia de clase interna local sigue siendo Solo ahora, aún mantenga el punto de referencia de la variable x
             // si llama a este método después de que se destruye el método local, ya no puede acceder a la variable x, este es un problema ERROR
             // pero JDK8 ha expresado implícitamente la variable x por defecto Se modifica finalmente, x debe ser una presencia constante
             // eso significa que si x se destruye, pero su valor no cambia, aún puede ser dado por acceso 
            
            // La razón es que el alcance de la instancia de la clase interna local es mayor que El alcance de esta variable 
            public  int returnX () {
                 // x + = 100; la variable x no se puede modificar 
                return x; 
            } 
        } 
    } 
    
    //El uso de clases internas locales se puede usar para devolver una instancia que implementa una interfaz. 
    Public Comparable getComparable () {
         class LocalInnerClass implementa Comparable {
             // Método de interfaz de reescritura de clase interna local 
            @Override
             public  int compareTo (Object o) {
                 return 0 ; 
            } 
        } 
        // Volver a la llamada externa 
        return  new LocalInnerClass (); 
    } 
}

Tres clases internas

 

Clase interna estática y creación y acceso de instancia externa de clase interna miembro

public  class ClassTest {
     public  static  void main (String [] args) {
         //   Instanciar una clase interna estática 
        OuterClass.StaticInnerClass staticInnerClass = new OuterClass.StaticInnerClass ();
         //   Método miembro de la clase interna estática 
        staticInnerClass.memberMethod ();
         //   Método estático de clase interna estática 
        OuterClass.StaticInnerClass.staticMethod (); 

        //   Clase interna de miembro instantáneo , debe tener una instancia de la clase externa antes de 
        OuterClass externalClass = new OuterClass (); // Primero cree una instancia externa 
        OuterClass.InnerClass innerClass = outsideClass. new InnerClass (); //Luego llame a la inicialización interna a través de la instancia externa.
         //   También puede 
        anonimizar directamente el objeto de clase externa, llamar a la clase interna para inicializar OuterClass.InnerClass innerClass2 = new OuterClass (). New InnerClass (); 

        // La clase interna miembro llama al método miembro 
        innerClass.memberMethod (); 
    } 
}

Instanciación y acceso

 

Clase interna anónima

public  class ClassTest {
     public  static  void main (String [] args) { 
        
        AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass () {
             // Este es el cuerpo de la clase de la clase interna anónima, anónimo, como su nombre lo indica, no hay nombre de clase 
            
            // método para reescribir la interfaz 
            @ Anular
             public  void aicMethod () { 
                System.out.println ( "Esta es la clase interna anónima" );     
            } 
            
            // La clase interna anónima solo se puede declarar esta vez y no se puede guardar como la clase mostrada
             // utilizada para crear para implementar un Una interfaz puede heredar una clase abstracta o heredar una clase ordinaria
             // adecuada para implementar interfaces con un solo método, como Runnable multiproceso 
            
            //Tenga en cuenta que el hilo también tiene un Callable 
        }; 
    } 
} 

// Declarar una interfaz y una 
interfaz de método abstracto AnonymousInnerClass {
     void aicMethod (); 
}

Clase interna anónima