Ámbito de Variables en Java

Basico

Se entiende por alcance, ámbito o scope de una variable, la parte del programa donde la variable es accesible. Veremos los tipos que existen.

Al igual que C/C ++, en Java, todos los identificadores tienen un ámbito léxico (o estático). Los programas de Java están organizados en forma de clases. Cada clase es parte de un paquete. Las reglas de ámbito de Java se pueden cubrir en las siguientes categorías.

1. Variables miembro (Ámbito a nivel de clase)

Estas variables deben declararse dentro de la clase (fuera de cualquier método). Se puede acceder directamente a ellas en cualquier parte de la clase. Echemos un vistazo a un ejemplo:

public class Test
{
    //Todas las variables definidas directamente dentro de una clase
    //son variables miembro
    int a;
    private String b;
    void method1() {....}
    int method2() {....}
    char c;
}
  • Podemos declarar variables de clase en cualquier lugar 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
Reglas para variables miembro fuera de una clase.
ModificadorPaqueteSubclase
publicsisi
protectedsisi
default (sin modificador)sino
privatenono

2. Variables locales (Ámbito a nivel de método)

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

public class Test
{
    void method1() 
    {
       // Variable local (ámbito a nivel de método)
       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 de método, excepto que esta vez la variable se pasa como parámetro para el método:

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

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

Aprende más
Palabra Clave This

Como ejercicio, prediga el resultado 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);
    }
}

Salida:

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

3. Variables de bucle (Ámbito de bloque)

Una variable declarada dentro de un par de corchetes “{” y “}” en un método tiene alcance solamente dentro de los corchetes.

public class Test
{
    public static void main(String args[])
    {
        {
            // La variable x tiene alcance dentro
            // los corchetes
            int x = 10;
            System.out.println(x);
        }
         
        // La línea de código comentada debajo produciría
        // error ya que la variable x está fuera del alcance.
 
        // System.out.println(x); 
    }
}

Salida:

10

Como otro ejemplo, considere correr el programa con un ciclo for.

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

Salida:

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

La forma correcta de hacer lo anterior es:

// El programa después de corregir el 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);
    }
}

Salida:

0
1
2
3
4

Como ejercicio, prediga el resultado del siguiente programa Java.

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

Algunos puntos importantes sobre el ámbito de las variables en Java:

  • En general, un conjunto de llaves {} define un alcance.
  • 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 paréntesis 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 “this” se puede usar para hacer referencia a la variable de clase actual.
  • Para que una variable se lea después de la terminación de un ciclo, debe declararse antes del cuerpo del ciclo.
Ámbito de Variables en Java
  • 10/10
    Tipos y Ejemplos - 10/10

Sobre el Autor:

Hey hola! Yo soy Alex Walton y tengo el placer de compartir conocimientos hacía ti sobre el tema de Programación en Java, desde cero, Online y Gratis.

0 comentarios

Deja una Respuesta

*

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.