Clases anidadas en Java

En Java, es posible definir una clase dentro de otra clase, dichas clases se conocen como clases anidadas . Le permiten agrupar lógicamente las clases que solo se usan en un lugar, por lo que aumenta el uso de la encapsulación y crea un código más legible y mantenible.

• El alcance de una clase anidada está limitado por el alcance de su clase envolvente. Por lo tanto, en el siguiente ejemplo, la clase NestedClass no existe independientemente de la clase OuterClass .
• Una clase anidada tiene acceso a los miembros, incluidos los miembros privados, de la clase en la que está anidada. Lo contrario también es cierto, es decir, la clase envolvente puede acceder a los miembros de la clase anidada.
• Una clase anidada también es miembro de su clase envolvente.
• Como miembro de su clase envolvente, una clase anidada puede declararse private , public , protected o package private (predeterminado).
• Las clases anidadas se dividen en dos categorías:
  1. clase anidada estática: las clases anidadas que se declaran estáticas se denominan clases anidadas estáticas.
  2. clase interna: una clase interna es una clase anidada no estática.

Sintaxis:

class OuterClass
{
...
    class NestedClass
    {
        ...
    }
}

Clases estáticas anidadas

En el caso de clases internas normales o regulares, sin que exista un objeto de clase externo, no puede haber un objeto de clase interno. es decir, un objeto de la clase interna siempre está fuertemente asociado con un objeto de la clase externa. Pero en el caso de una clase anidada estática, sin que exista un objeto de clase externo, puede haber un objeto de clase anidada estática. es decir, un objeto de una clase anidada estática no está fuertemente asociado con el objeto de la clase externa.
Al igual que con los métodos y variables de clase, una clase anidada estática está asociada con su clase externa. Y al igual que los métodos de clase estáticos, una clase anidada estática no puede referirse directamente a variables de instancia o métodos definidos en su clase envolvente: solo puede usarlos a través de una referencia de objeto.
Se accede a ellos utilizando el nombre de clase adjunto.

OuterClass.StaticNestedClass

Por ejemplo, para crear un objeto para la clase anidada estática, use esta sintaxis:

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

// Java program to demonstrate accessing
// a static nested class
 
// outer class
class OuterClass
{
    // static member
    static int outer_x = 10;
     
    // instance(non-static) member
    int outer_y = 20;
     
    // private member
    private static int outer_private = 30;
     
    // static nested class
    static class StaticNestedClass
    {
        void display()
        {
            // can access static member of outer class
            System.out.println("outer_x = " + outer_x);
             
            // can access display private static member of outer class
            System.out.println("outer_private = " + outer_private);
             
            // The following statement will give compilation error
            // as static nested class cannot directly access non-static members
            // System.out.println("outer_y = " + outer_y);
         
        }
    }
}
 
// Driver class
public class StaticNestedClassDemo
{
    public static void main(String[] args)
    {
        // accessing a static nested class
        OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
         
        nestedObject.display();
         
    }
}

Producción:

outer_x = 10
outer_private = 30

clases internas

Para instanciar una clase interna, primero debe instanciar la clase externa. Luego, cree el objeto interno dentro del objeto externo con esta sintaxis:

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

Hay dos tipos especiales de clases internas:

1. Clases internas locales
2. Clases internas anónimas

// Java program to demonstrate accessing
// a inner class
 
// outer class
class OuterClass
{
    // static member
    static int outer_x = 10;
     
    // instance(non-static) member
    int outer_y = 20;
     
    // private member
    private int outer_private = 30;
     
    // inner class
    class InnerClass
    {
        void display()
        {
            // can access static member of outer class
            System.out.println("outer_x = " + outer_x);
             
            // can also access non-static member of outer class
            System.out.println("outer_y = " + outer_y);
             
            // can also access a private member of the outer class
            System.out.println("outer_private = " + outer_private);
         
        }
    }
}
 
// Driver class
public class InnerClassDemo
{
    public static void main(String[] args)
    {
        // accessing an inner class
        OuterClass outerObject = new OuterClass();
        OuterClass.InnerClass innerObject = outerObject.new InnerClass();
         
        innerObject.display();
         
    }
}

Producción:

outer_x = 10
outer_y = 20
outer_private = 30

Comparación entre clase normal o regular y clase anidada estática