Clase interna local en Java

Requisitos previos: clases anidadas en Java 

Las clases internas locales son las clases internas que se definen dentro de un bloque . Generalmente, este bloque es un cuerpo de método. A veces, este bloque puede ser un bucle for o una cláusula if. Las clases internas locales no son miembros de ninguna clase envolvente. Pertenecen al bloque en el que están definidas, por lo que las clases internas locales no pueden tener ningún modificador de acceso asociado con ellas. Sin embargo, pueden marcarse como finales o abstractos. Esta clase tiene acceso a los campos de la clase que la encierra. La clase interna local debe instanciarse en el bloque en el que están definidas. 

Reglas de Clase Interna Local:

1. El alcance de la clase interna local está restringido al bloque en el que están definidos.
2. No se puede crear una instancia de una clase interna local desde fuera del bloque en el que se crea.
3. Hasta JDK 7, la clase interna local solo puede acceder a la variable local final del bloque adjunto . Sin embargo, desde JDK 8, es posible acceder a la variable local no final del bloque envolvente en la clase interna local.
4. Una clase local tiene acceso a los miembros de su clase envolvente .
5. Las clases internas locales pueden extender una clase abstracta o implementar una interfaz. 
    

Declarar una clase interna local : una clase interna local se puede declarar dentro de un bloque. Este bloque puede ser un cuerpo de método, un bloque de inicialización, un bucle for o incluso una declaración if. 

Acceso a miembros: una clase interna local tiene acceso a los campos de la clase que la encierra, así como a los campos del bloque en el que está definida. Estas clases, sin embargo, pueden acceder a las variables o parámetros del bloque que las encierra solo si se declaran como finales o son efectivamente finales. Una variable cuyo valor no cambia una vez inicializada se denomina efectivamente variable final. Una clase interna local definida dentro del cuerpo de un método tiene acceso a sus parámetros. 

¿Qué sucede en tiempo de compilación?

Cuando se compila un programa que contiene una clase interna local, el compilador genera dos archivos .class, uno para la clase externa y otro para la clase interna que tiene la referencia a la clase externa. Los dos archivos son nombrados por el compilador como: 

• Clase exterior
• Exterior$1Interior.clase

Declaración dentro de un cuerpo de método

// Java program to illustrate
// working of local inner classes
 
public class Outer
{
    private void getValue()
    {
        // Note that local variable(sum) must be final till JDK 7
        // hence this code will work only in JDK 8
        int sum = 20;
         
        // Local inner Class inside method
        class Inner
        {
            public int divisor;
            public int remainder;
             
            public Inner()
            {
                divisor = 4;
                remainder = sum%divisor;
            }
            private int getDivisor()
            {
                return divisor;
            }
            private int getRemainder()
            {
                return sum%divisor;
            }
            private int getQuotient()
            {
                System.out.println("Inside inner class");
                return sum / divisor;
            }
        }
         
        Inner inner = new Inner();
        System.out.println("Divisor = "+ inner.getDivisor());
        System.out.println("Remainder = " + inner.getRemainder());
        System.out.println("Quotient = " + inner.getQuotient());
    }
     
    public static void main(String[] args)
    {
        Outer outer = new Outer();
        outer.getValue();
    }
}

Divisor = 4
Remainder = 0
Inside inner class
Quotient = 5

Nota: una clase local puede acceder a variables y parámetros locales del bloque adjunto que son efectivamente finales . 

Por ejemplo, si agrega la declaración de asignación resaltada en el constructor de la clase interna o cualquier método de la clase interna en el ejemplo anterior: 

public Inner()
{
   sum = 50;
   divisor = 4;
   remainder = sum%divisor;
}

Debido a esta declaración de asignación, la suma variable ya no es definitiva . Como resultado, el compilador de Java genera un mensaje de error similar a «las variables locales a las que se hace referencia desde una clase interna deben ser finales o efectivamente finales».

Declaración dentro de una declaración if

// Java program to illustrate Declaration of
// local inner classes inside an if statement
 
public class Outer
{
    public int data = 10;
    public int getData()
    {
        return data;
    }
    public static void main(String[] args)
    {
        Outer outer = new Outer();
         
        if(outer.getData() < 20)
        {
            // Local inner class inside if clause
            class Inner
            {
                public int getValue()
                {
                    System.out.println("Inside Inner class");
                    return outer.data;
                }
            }
 
            Inner inner = new Inner();
            System.out.println(inner.getValue());
        }
        else
        {
            System.out.println("Inside Outer class");
        }
    }
}

Inside Inner class
10

Demostración de códigos erróneos para la clase interna

// Java code to demonstrate that inner
// classes cannot be declared as static
 
public class Outer
{
    private int getValue(int data)
    {
        static class Inner
        {
            private int getData()
            {
                System.out.println("Inside inner class");
                if(data < 10)
                {
                    return 5;
                }
                else
                {
                    return 15;
                }
            }
        }
         
        Inner inner = new Inner();
        return inner.getData();
    }
     
    public static void main(String[] args)
    {
        Outer outer = new Outer();
        System.out.println(outer.getValue(10));
    }
}

Producción

Compilation error

Explicación: el programa anterior provoca un error de compilación porque la clase interna no se puede declarar estática. Las clases internas están asociadas con el bloque en el que están definidas y no con la clase externa (Externa en este caso).

// Java code to demonstrate
// the scope of inner class
 
public class Outer
{
    private void myMethod()
    {
        class Inner
        {
            private void innerMethod()
            {
                System.out.println("Inside inner class");
            }
        }
    }
     
    public static void main(String[] args)
    {
        Outer outer = new Outer();
        Inner inner = new Inner();
        System.out.println(inner.innerMethod());
    }
}

Producción

prog.java:20: error: cannot find symbol
        Inner inner = new Inner();
        ^
  symbol:   class Inner
  location: class Outer

Explicación: el programa anterior provoca un error de compilación porque el alcance de las clases internas está restringido al bloque en el que están definidas.

Este artículo es una contribución de Mayank Kumar . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.