Hasta ahora, todas la variables que hemos usado se declararon al principio del método main(). Sin embargo, Java permite que las variables se declaren dentro de cualquier bloque. El inicio de un bloque se marca con un carácter '{', y el fin del bloque, con el correspondiente carácter '}'. Un bloque puede contener otro bloque (o cualquier número de bloques) dentro de él, estos se denominan bloques anidados. Un bloque define el alcance; por lo tanto, cada vez que inicia un nuevo bloque, está creando un nuevo alcance. Un alcance determina cuáles objetos son visibles a otras partes de su programa. Así mismo, determina la vida de dichos objetos.
Casi todos los demás lenguajes de cómputo definen dos categorías generales de alcance: global y local. Aunque están soportadas por Java, no constituyen las mejores formas de categorizar los alcances de Java. Los alcances más importantes son los definidos por una clase y los definidos por un método.
El alcance definido por un método inicia con su llave de apertura. Sin embargo, si dicho método contiene parámetros, éstos se incluyen también dentro de su alcance.
Como regla general, las variables que están declaradas dentro de un alcance no son visibles (es decir, accesibles) a un código que esté definido fuera de este alcance. Por lo tanto, cuando declara una variable dentro del un alcance, localiza esa variable y la protege de acceso no autorizado, de modificación o de ambas posibilidades. Por supuesto, las reglas de alcance proporcionan la base del encapsulamiento.
Así mismo, los alcances pueden están anidados. Por ejemplo, cada vez crea un bloque de código, crea un nuevo alcance anidado. Cuando esto ocurre, el alcance exterior encierra al interior. Esto significa que los objetos declarados en el alcance exterior se volverán visibles al código dentro del alcance interno. Sin embargo, la situación contraria no aplica: los objetos declarados dentro del alcance interior no serán visibles fuera de él.
Para comprender el efecto del los alcances anidados, considere el siguiente programa:
// Demuestra el alcance del bloque.
class AlcanceDemo {
public static void main(String args[]) {
int x; // conocido a todo el código en main
x = 10;
if (x == 10) { //inicia nuevo alcance
int c = 20; //conocido sólo a este bloque
// x y c son conocidos aquí.
System.out.println(“ x y c : “+ x +” “+ c);
x= c * 2;
}
c = 100 // Error. A c no se le conoce aquí, está fuera de su alcance.
// x es aún conocido aquí.
System.out.pritnln(“x es “ + x);
}
}
Como lo indica el comentario, la variable x se declara al principio del alcance de main() y es accesible a todo el código posterior dentro de main(). Dentro del bloque if, está declarada c. Debido a que un bloque define un alcance, c sólo es visible dentro del código de su bloque. Por tal motivo, fuera de su bloque, la línea c = 100; hará que ocurra un error en tiempo de ejecución porque c no es visible fuera de su bloque. Dentro del bloque if, x puede usarse porque el código dentro del bloque (es decir, un alcance anidado) tiene acceso a variables declaradas por un alcance incluido.
Dentro de un bloque, las variables pueden declararse en cualquier punto; sin embargo, sólo son válidas después de ser declaradas. De manera que, si define una variable al inicio de un método, ésta estará disponible para todo el código dentro del método . Por el contrario, si declara un variable al final de un bloque, ésta carecerá de uso porque ningún código tendrá acceso a ella.
A este respecto, hay que recordar otro elemento: las variables se crean cuando se introduce su alcance y se destruye cuando se abandona su alcance. Esto significa que una variable no contendrá su valor una vez que se haya salido de sus alcance. Por lo tanto, las variables declaradas dentro de un bloque perderán su valor cuando se abandone el bloque. Así, la vida de una variable está confinada a su alcance.
