Alcance de Java

Todos sabemos que los países tienen fronteras y sus propias leyes. Las leyes del país operan dentro de las fronteras. También en el país existen, por ejemplo, organizaciones, como escuelas o museos, que tienen sus propias reglas locales. No contradicen las leyes del país, pero operan solo dentro del marco de la organización especificada. Lo mismo es cierto en la programación. Entonces, en programación, y particularmente en lenguaje Java, existe un término "alcance". Se refiere a áreas del programa donde funcionan ciertos datos, como variables o métodos. En este artículo, vamos a descubrir qué ámbitos son para las variables en Java y cómo definirlos.

Ámbito de Java en general

¿Por qué es necesario separar los alcances de las variables y los métodos? El caso es que a veces los programas son muy grandes y puede ser difícil rastrear una u otra variable. Además, en proyectos grandes, es deseable una denominación clara de las variables para que quede claro para qué sirven. Scope específicamente le permite tener diferentes variables con el mismo nombre en diferentes partes del programa. Dicho código es más fácil de mantener y leer. El alcance de Java define dónde se puede acceder a una determinada variable o método en un programa. Brevemente:

• Una variable declarada en un método es visible desde el principio de la declaración hasta el final del método (alcance del método).
• Una variable declarada en un bloque de código existe hasta el final de ese bloque de código.
• Las variables que son argumentos de método existen hasta el final del método.
• Las variables de clase/objeto existen durante la vida útil del objeto que las contiene. Su visibilidad está regulada por modificadores de acceso especiales.
• Las variables de clase estática existen todo el tiempo que se ejecuta el programa. Su visibilidad también está determinada por los modificadores de acceso.

Ámbito de nivel de método

No se puede acceder a ninguna variable declarada en un método, incluidos los argumentos, fuera de ese método. Todas las variables declaradas dentro de los métodos son visibles desde el comienzo de su declaración hasta el final del método. Aquí hay un ejemplo de alcance de variable de método:

public class JScopeTest1 {


   public static void main(String[] args) {

       System.out.println(myMethod(5));
       System.out.println(myMethod(17));

   }
   public static int  myMethod(int arg) {
       int secondArg = 100; //local method variable
       return secondArg + arg;
   }
}

Aquí tenemos secondArg , una variable local o argumento de método. No podemos usar esta variable fuera del método myMethod o antes de que se declarara. Si una variable es un argumento de función, entonces es visible en todo el cuerpo de este método. En el ejemplo anterior, tenemos dos argumentos de este tipo: arg en myMethod y args en el método principal.

Alcance de nivel de clase

Ámbito de nivel de clase (variables de instancia): cualquier variable declarada en una clase está disponible para todos los métodos de esa clase. Dependiendo de su modificador de acceso (es decir, público o privado), a veces se puede acceder fuera de la clase. Entonces, si una variable es una variable de clase, entonces está vinculada a un objeto específico y existe mientras haya un objeto de esta clase. Si no hay objeto, entonces no hay copia de la variable. La variable es visible desde todos los métodos de la clase, independientemente de si se declaran antes o después. Cada objeto tiene su propia variable independiente de otros objetos. No es posible acceder a una variable desde métodos estáticos.

ejemplo de código

public class Student {
   
//class level variables
   public String surname;
   String name;
   String secondName;
   private Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

   @Override
   public int hashCode(){
       //TODO: check for nulls
       //return surname.hashCode() ^ name.hashCode() ^ secondName.hashCode() ^ (birthday.hashCode());
       return (surname + name + secondName + birthday).hashCode();
   }
   @Override
   public boolean equals(Object other_) {
       Student other = (Student)other_;
       return (surname == null || surname.equals(other.surname) )
               && (name == null || name.equals(other.name))
               && (secondName == null || secondName.equals(other.secondName))
               && (birthday == null || birthday.equals(other.birthday));
   }
}

El apellido , el nombre , el segundo nombre y el cumpleaños son variables de instancia.

Ámbito de bloque

Si una variable se define/declara en algún bloque de código, entonces existe hasta el final de ese bloque de código. Por lo general, tales variables existen entre las llaves en las que se definen. Muy a menudo, el alcance del bloque podría ser una variable de bucle. Una variable que se declara en una condición de bucle for no es accesible fuera del bucle, a menos que la haya definido de antemano.

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

Las variables first sum e i se declaran dentro del ciclo y no existen fuera de este ciclo. Sin embargo, la segunda suma se declaró fuera del bucle, por lo que se imprimirá esta variable en particular.

Variables estáticas

Si una variable se declara como estática (marcada con la palabra clave estática), entonces existe mientras exista su clase. Normalmente, la JVM carga una clase en la memoria en el primer uso, cuando se inicializan las variables estáticas.

import java.util.Date;

public class Student {
   public static int today = 2022;
   String surname;
   String name;
   String secondName;
   Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

 
   public static void main(String[] args) {
       System.out.println(today);
   }

}

No debe crear una nueva instancia de la clase Estudiante para usar la variable estática hoy . Aquí se imprimirá “2022”.

Modificadores de acceso

Java tiene 4 modificadores de acceso para restringir el acceso al método o variable. Puede usarlos dentro de clases, no dentro de métodos.

• private es el modificador más restrictivo. Restringe el acceso a métodos y variables a la clase en la que fueron declarados. Si no hay necesidad de usar ciertos métodos o variables fuera de la clase, use private. Las variables de clase suelen ser privadas en Java.

• Si no se especifica ningún modificador de acceso, el método o variable aceptará el modificador predeterminado . por defecto permite el acceso solo desde el paquete actual.

• El modificador protected permite el acceso a un método o variable solo desde el paquete actual, a menos que se acceda a través de una clase secundaria fuera del paquete.

• public es el modificador menos restrictivo. Te permite acceder a una clase, método o variable no solo desde la clase en la que están declaradas, sino también desde fuera. Este modificador se usa muy a menudo.