Alcance de las variables en Java

El alcance de una variable es la parte del programa donde se puede acceder a la variable. Al igual que C/C++, en Java, todos los identificadores tienen un alcance léxico (o estático), es decir, el alcance de una variable puede determinarse en tiempo de compilación e independientemente de la pila de llamadas a funciones. 
Los programas Java están organizados en forma de clases. Cada clase es parte de algún paquete. Las reglas de alcance de Java se pueden cubrir en las siguientes categorías.
 

Variables miembro (ámbito de nivel de clase)

Estas variables deben declararse dentro de la clase (fuera de cualquier función). Se puede acceder directamente desde cualquier lugar de la clase. Echemos un vistazo a un ejemplo: 

public class Test
{
    // All variables defined directly inside a class 
    // are member variables
    int a;
    private String b;
    void method1() {....}
    int method2() {....}
    char c;
}

• Podemos declarar variables de clase en cualquier parte de la clase, pero fuera de los métodos.
• El acceso especificado de las variables miembro no afecta el alcance de ellas dentro de una clase.
• Se puede acceder a las variables miembro fuera de una clase con las siguientes reglas

Modifier      Package  Subclass  World

public          Yes      Yes     Yes

protected       Yes      Yes     No

Default (no
modifier)       Yes       No     No

private         No        No     No

Variables locales (alcance de nivel de método)

Las variables declaradas dentro de un método tienen un alcance de nivel de método y no se puede acceder a ellas fuera del método. 

public class Test
{
    void method1() 
    {
       // Local variable (Method level scope)
       int x;
    }
}

Nota: las variables locales no existen después de que finaliza la ejecución del método. 

Aquí hay otro ejemplo del alcance del método, excepto que esta vez la variable se pasó como parámetro al método: 

class Test
{
    private int x;
    public void setX(int x)
    {
        this.x = x;
    }
}

El código anterior usa esta palabra clave para diferenciar entre las variables locales y de clase.

Como ejercicio, prediga la salida del siguiente programa Java.  

public class Test
{
    static int x = 11;
    private int y = 33;
    public void method1(int x)
    {
        Test t = new Test();
        this.x = 22;
        y = 44;
 
        System.out.println("Test.x: " + Test.x);
        System.out.println("t.x: " + t.x);
        System.out.println("t.y: " + t.y);
        System.out.println("y: " + y);
    }
 
    public static void main(String args[])
    {
        Test t = new Test();
        t.method1(5);
    }
}

Producción: 

Test.x: 22
t.x: 22
t.y: 33
y: 44

Variables de bucle (alcance de bloque) 
Una variable declarada dentro de un par de corchetes «{» y «}» en un método tiene alcance solo dentro de los corchetes.

public class Test
{
    public static void main(String args[])
    {
        {
            // The variable x has scope within
            // brackets
            int x = 10;
            System.out.println(x);
        }
         
        // Uncommenting below line would produce
        // error since variable x is out of scope.
 
        // System.out.println(x);
    }
}

Producción: 

10

Como otro ejemplo, considere el siguiente programa con un bucle for. 

class Test
{
    public static void main(String args[])
    {
        for (int x = 0; x < 4; x++)
        {
            System.out.println(x);
        }
 
        // Will produce error
        System.out.println(x);
    }
}

Producción: 

11: error: cannot find symbol
        System.out.println(x);      

La forma correcta de hacerlo arriba es, 

// Above program after correcting the error
class Test
{
    public static void main(String args[])
    {
        int x;
        for (x = 0; x < 4; x++)
        {
            System.out.println(x);
        }
 
       System.out.println(x);
    }
}

Producción: 

0
1
2
3
4

Veamos un ejemplo complicado de alcance de bucle. Prediga la salida del siguiente programa. Puede que se sorprenda si es un programador habitual de C/C++. 

class Test
{
    public static void main(String args[])
    {
        int a = 5;
        for (int a = 0; a < 5; a++)
        {
            System.out.println(a);
        }
    }
}

Producción :

6: error: variable a is already defined in method go(int)
       for (int a = 0; a < 5; a++)       
                ^
1 error

Nota: – En C++, se ejecutará. Pero en Java es un error porque en Java, el nombre de la variable del bucle interno y externo debe ser diferente.
Un programa similar en C++ funciona. Mira esto .

Como ejercicio, prediga la salida del siguiente programa Java. 

class Test
{
    public static void main(String args[])
    {
        {
            int x = 5;
            {
                int x = 10;
                System.out.println(x);
            }
        }
    }
}

P. A partir del conocimiento anterior, indique si el siguiente código se ejecutará o no.

class Test {
    public static void main(String args[])
    {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
        int i = 20;
        System.out.println(i);
    }
}

Producción : 

1
2
3
4
5
6
7
8
9
10
20

¡Sí, funcionará! 
Vea el programa cuidadosamente, el ciclo interno terminará antes de que se declare la variable del ciclo externo. Por lo tanto, la variable del ciclo interno se destruye primero y luego se crea la nueva variable con el mismo nombre.

Algunos puntos importantes sobre el alcance de las variables en Java:  

• En general, un conjunto de corchetes { } define un ámbito.
• En Java, generalmente podemos acceder a una variable siempre que se haya definido dentro del mismo conjunto de corchetes que el código que estamos escribiendo o dentro de cualquier corchete dentro de los corchetes donde se definió la variable.
• Cualquier variable definida en una clase fuera de cualquier método puede ser utilizada por todos los métodos miembros.
• Cuando un método tiene la misma variable local que un miembro, la palabra clave «esta» se puede usar para hacer referencia a la variable de clase actual.
• Para que una variable se lea después de la finalización de un ciclo, debe declararse antes del cuerpo del ciclo.

 Este artículo es una contribución de Rishabh Mahrsee . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo 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.