clases internas estáticas y clases internas

Ejemplos

public class OuterClass {
    private int numPrivate = 1;
    public int numPublic = 2;
    public static int numPublicStatic = 3;
    private static int numPrivateStatic = 4;

    public void nonStaticPublicMethod(){
        System.out.println("using nonStaticPublicMethod");
    }

    private void nonStaticPrivateMethod(){
        System.out.println("using nonStaticPrivateMethod");
    }

    public static void staticPublicMethod(){
        System.out.println("using staticPublicMethod");
    }

    private static void staticPrivateMethod(){
        System.out.println("using staticPrivateMethod");
    }

    class InnerClass{

        //Inner class cannot have static declarations
        //static int numInnerClass = 4;
        //public static void test(){}

        int numNonStaticInnerClass = 5;

        public void print(){
            System.out.println("using InnerClass");
            System.out.println("access private field: "+numPrivate);
            System.out.println("access public field: "+numPublic);
            System.out.println("access public static field: "+numPublicStatic);
            System.out.println("access private static field: "+numPrivateStatic);
            System.out.println("access numNonStaticInnerClass: "+numNonStaticInnerClass);
            nonStaticPrivateMethod();
            nonStaticPublicMethod();
            staticPrivateMethod();
            staticPublicMethod();
        }
    }

    static class StaticNestedClass{

        static int numStaticNestedClass = 6;
        int numNonStaticNestedClass = 7;

        public void print(){
            System.out.println("using StaticNestedClass");
            System.out.println("access public static field: "+numPublicStatic);
            System.out.println("access private static field: "+numPrivateStatic);
            System.out.println("access numStaticNestedClass: "+numStaticNestedClass);
            System.out.println("access numNonStaticNestedClass: "+numNonStaticNestedClass);
            staticPrivateMethod();
            staticPublicMethod();
        }
    }

    public static void main(String[] args) {
        //内部类实例对象
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.print();
        System.out.println("=====================");
        //静态内部类实例化对象
        OuterClass.StaticNestedClass nestedClass = new OuterClass.StaticNestedClass();
        nestedClass.print();
    }
}

resultado

using InnerClass
access private field: 1
access public field: 2
access public static field: 3
access private static field: 4
access numNonStaticInnerClass: 5
using nonStaticPrivateMethod
using nonStaticPublicMethod
using staticPrivateMethod
using staticPublicMethod
=====================
using StaticNestedClass
access public static field: 3
access private static field: 4
access numStaticNestedClass: 6
access numNonStaticNestedClass: 7
using staticPrivateMethod
using staticPublicMethod

interna estática uso clases

clases internas estáticas de acceso a través de una clase externa

OuterClass.StaticNestedClass

Crear un objeto de la clase interna estática

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

Uso clase interna

Hay que crear una instancia de la clase externa primera clase interna a instantiate

OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();

Diferencia entre los dos

clase interna, incluso el acceso lata privada, ya sea estática o no estático se puede acceder
- El acceso a todas las variables y métodos de la clase envolvente miembros (fuera de clase)
- variables miembro privadas privadas y métodos de la clase envolvente (fuera de clase) también se puede acceder en
- No tener variables estáticas y métodos estáticos clases internas
clases internas estáticas
- El cierre no tiene la clase de acceso (clase externa) variable no estática o un método no estático
- variables y métodos de la clase envolvente (fuera de clase) también se puede acceder a miembros privados estática privada estáticas
- Puede tener variables estáticas y métodos estáticos estáticos clases internas
clase interna puede ser declarado como privado, público, protegido, o un paquete privado. Pero la clase cerrada (fuera de clase) sólo puede declararse publico paquete privado

circunstancias especiales

public class ShadowTest {

    public int x = 0;

    class FirstLevel {

        public int x = 1;

        void methodInFirstLevel(int x) {
            System.out.println("x = " + x);
            System.out.println("this.x = " + this.x);
            System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
        }
    }

    public static void main(String... args) {
        ShadowTest st = new ShadowTest();
        ShadowTest.FirstLevel fl = st.new FirstLevel();
        fl.methodInFirstLevel(23);
    }
}

salida

x = 23
this.x = 1
ShadowTest.this.x = 0

conclusión

clase ShadowTest define tres nombres, como variable x
- ShadowTest variable miembro x
- FirstLevel variables miembro clase interna x
- methodInFirstLevel parámetro del método x
methodInFirstLevel parámetro del método de x en la sombra de la clase interna FirstLevel, el uso en el proceso de x cuando el methodInFirstLevel, x está apuntando método parámetro x, el resultado de x en este momento es 23
En este punto en el interior de esta clase alcance FirstLevel, por lo que el resultado es un this.x
alcance ShadowTest.this ShadowTest es puntiaguda, entonces el resultado es 1 ShadowTest.this.x

¿Por qué clases de interiores

Este es un método utilizado sólo para la clase en un lugar agrupación lógica : si una clase es útil sólo a otra clase, la clase y luego incrustar los dos se mantienen juntos es lógico.
Se agrega el paquete : Considere dos clases de nivel superior A y B, donde B necesita tener acceso a los miembros de A, si un miembro se declara un privateentonces B no puede acceder. Al ocultar la clase B clase A, los miembros de A pueden ser declaradas privada y B pueden acceder a ellos. Además, en sí B se puede esconder del mundo exterior.
Esto podría conducir a un código más legible y fácil de mantener : subcategorías anidadas hacer que el código fuera de la clase más cerca de la posición de uso.

serialización

Se recomienda encarecidamente no a las clases internas (incluyendo las clases locales y anónimas) son serializados.

Si la secuencia de una clase interna, a continuación, utilizar otro JRE lograr su deserializado, puede experimentar problemas de compatibilidad.

Serialización de clases internas, incluyendo clases locales y anónimas, está totalmente desaconsejado. Cuando el compilador Java compila ciertas construcciones, tales como las clases internas, se crea construcciones sintéticas; estos son clases, métodos, campos, y otras construcciones que no tienen una construcción correspondiente en el código fuente. construcciones sintéticas permiten a los compiladores Java para implementar nuevas características del lenguaje Java sin cambios en la JVM. Sin embargo, las construcciones sintéticas pueden variar entre diferentes implementaciones del compilador de Java, que significa que los archivos .class puede variar entre diferentes implementaciones también. En consecuencia, es posible que tenga problemas de compatibilidad si serializar una clase interna y luego deserializar con una aplicación JRE diferente.

Las diferencias en la clase interna de Java y clases internas estáticas