enténdese por alcance, alcance ou alcance dun Variable, a parte do programa onde a variable é accesible. Veremos os tipos que existen.
Como C / C ++, en Java, todos os identificadores teñen un alcance léxico (ou estático). Os programas Java están organizados en forma de clases. Cada clase forma parte dun paquete. As regras de alcance Java pódense cubrir nas seguintes categorías.
1. Variables membros (alcance na clase Nivel)
Estas variables deben ser declaradas dentro da clase (fóra de calquera método). Pódese acceder directamente a eles en calquera lugar da clase. Vexamos un exemplo:
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 calquera parte da clase, pero fóra dos métodos.
- O acceso especificado das variables membros non afecta o alcance deles dentro dunha clase.
- As variables membros pódense acceder a unha clase coas seguintes regras
Regras para variables de membros fóra dunha clase.
| modificador |
paquete |
subclase |
| Público |
Si |
Se |
TD
| protexido |
Se |
Se |
| Predeterminado (sen modificador) |
Se |
NO |
| Privado |
non |
non |
2. Local Variables (método a nivel de método)
Declaradas variables D Introduza un método é o alcance ao nivel do método e non se pode acceder fóra do método.
public class Test{ void method1() { // Variable local (ámbito a nivel de método) int x; }}
× nota: as variables locais non existen despois de que remata a execución do método.
Aquí hai outro exemplo do alcance do método, agás que esta vez a variable é aprobada como parámetro para o método:
class Test{ private int x; public void setX(int x) { this.x = x; }}
O código anterior usa a palabra clave para diferenciar entre as variables locais e as variables de clase.
Palabra clave
Como un exercicio, prevén o resultado do seguinte 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); }}
saída:
Test.x: 22t.x: 22t.y: 33y: 44
3. variables de loop (alcance de bloque)
unha variable declarada Dentro dun torque “{” e “}” nun método ten un rango só dentro dos parénteses.
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); }}
saída:
10
como outro exemplo, considere a execución do programa cun para.
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); }}
saída:
11: error: cannot find symbol System.out.println(x);
A forma correcta de facer o anterior é:
// El programa después de corregir el errorclass Test{ public static void main(String args) { int x; for (x = 0; x < 4; x++) { System.out.println(x); } System.out.println(x); }}
saída:
01234
como exercicio, prevén o resultado do seguinte programa Java.
class Test{ public static void main(String args) { { int x = 5; { int x = 10; System.out.println(x); } } }}
Algúns puntos importantes sobre o alcance das variables en Java:
- En xeral, un conxunto de teclas {} define un intervalo.
- en Java, generalmente podemos acceder a unha variable sempre que se definiu dentro do mesmo conxunto de parénteses que o código que estamos escribindo ou dentro dos parénteses dentro dos parénteses onde se definiu a variable.
- Calquera variable definida nunha clase fóra de calquera método pode ser utilizada por todos os métodos de membros.
- Cando un método ten a mesma variable local como membro, a palabra clave “isto” para ser usado para referirse á variable de clase actual.
- para que unha variable sexa lida despois da rescisión dun ciclo, debe ser declarado antes do corpo do ciclo.