Portée Java

Nous savons tous que les pays ont des frontières et leurs propres lois. Les lois du pays fonctionnent à l'intérieur des frontières. Dans le pays également, il existe, par exemple, des organisations, telles que des écoles ou des musées, qui ont leurs propres règles locales. Ils ne contredisent pas les lois du pays, mais n'opèrent que dans le cadre de l'organisation spécifiée. Il en est de même en programmation. Ainsi en programmation, et particulièrement en langage Java, il existe un terme "portée". Il fait référence aux zones du programme où certaines données, telles que des variables ou des méthodes, fonctionnent. Dans cet article, nous allons découvrir quelles sont les portées des variables en Java et comment les définir.

Portée Java en général

Pourquoi est-il nécessaire de séparer les portées des variables et des méthodes ? Le fait est que parfois les programmes sont très volumineux et il peut être difficile de suivre l'une ou l'autre variable. De plus, dans les grands projets, il est souhaitable de nommer clairement les variables afin qu'il soit clair à quoi elles servent. Scope vous permet spécifiquement d'avoir différentes variables avec le même nom dans différentes parties du programme. Un tel code est plus facile à maintenir et à lire. La portée Java définit où une certaine variable ou méthode est accessible dans un programme. Brièvement:

• Une variable déclarée dans une méthode est visible du début de la déclaration à la fin de la méthode (portée de la méthode).
• Une variable déclarée dans un bloc de code existe jusqu'à la fin de ce bloc de code.
• Les variables qui sont des arguments de méthode existent jusqu'à la fin de la méthode.
• Les variables de classe/objet existent pour la durée de vie de l'objet contenant. Leur visibilité est régulée par des modificateurs d'accès spéciaux.
• Les variables de classe statiques existent tout le temps que le programme s'exécute. Leur visibilité est également déterminée par des modificateurs d'accès.

Portée du niveau de la méthode

Toute variable déclarée dans une méthode, y compris les arguments, n'est pas accessible en dehors de cette méthode. Toutes les variables déclarées à l'intérieur des méthodes sont visibles du début de leur déclaration à la fin de la méthode. Voici un exemple de portée de variable de méthode :

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;
   }
}

Ici, nous avons secondArg , une variable locale ou un argument de méthode. Nous ne pouvons pas utiliser cette variable en dehors de la méthode myMethod ou avant qu'elle ne soit déclarée. Si une variable est un argument de fonction, elle est visible dans tout le corps de cette méthode. Dans l'exemple ci-dessus, nous avons deux arguments de ce type : arg dans myMethod et args dans la méthode principale.

Portée du niveau de classe

Portée au niveau de la classe (variables d'instance) — toute variable déclarée dans une classe est disponible pour toutes les méthodes de cette classe. Selon son modificateur d'accès (c'est-à-dire public ou privé), il peut parfois être accessible en dehors de la classe. Donc, si une variable est une variable de classe, alors elle est liée à un objet spécifique et existe tant qu'il y a un objet de cette classe. S'il n'y a pas d'objet, alors il n'y a pas de copie de la variable. La variable est visible de toutes les méthodes de la classe, qu'elles soient déclarées avant ou après. Chaque objet a sa propre variable indépendante des autres objets. L'accès à une variable à partir de méthodes statiques n'est pas possible.

Exemple de code

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));
   }
}

Surname , name , secondName et birthday sont des variables d'instance.

Portée du bloc

Si une variable est définie/déclarée dans un bloc de code, alors elle existe jusqu'à la fin de ce bloc de code. Typiquement, de telles variables existent entre les accolades dans lesquelles elles sont définies. Très souvent, la portée du bloc peut être une variable de boucle. Une variable déclarée dans une condition de boucle for n'est pas accessible en dehors de la boucle, sauf si vous l'avez définie au préalable.

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);
   }
}

Les premières variables sum et i sont déclarées à l'intérieur de la boucle et n'existent pas en dehors de cette boucle. Cependant, la deuxième somme a été déclarée en dehors de la boucle, donc cette variable particulière va être imprimée.

Variables statiques

Si une variable est déclarée comme statique (marquée avec le mot-clé static), alors elle existe tant que sa classe existe. En règle générale, la JVM charge une classe en mémoire lors de la première utilisation, lorsque les variables statiques sont initialisées.

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);
   }

}

Vous ne devez pas créer une nouvelle instance de la classe Student pour utiliser la variable statique aujourd'hui . Ici « 2022 » sera imprimé.

Modificateurs d'accès

Java a 4 modificateurs d'accès pour restreindre l'accès à la méthode ou à la variable. Vous pouvez les utiliser à l'intérieur des classes, pas à l'intérieur des méthodes.

• private est le modificateur le plus restrictif. Il limite l'accès aux méthodes et aux variables à la classe dans laquelle elles ont été déclarées. S'il n'est pas nécessaire d'utiliser certaines méthodes ou variables en dehors de la classe, utilisez private. Les variables de classe sont généralement privées en Java.

• Si aucun modificateur d'accès n'est spécifié, la méthode ou la variable acceptera le modificateur par défaut . default n'autorise l'accès qu'à partir du package actuel.

• Le modificateur protégé autorise l'accès à une méthode ou à une variable uniquement à partir du package actuel, à moins qu'il ne soit accessible via une classe enfant en dehors du package.

• public est le modificateur le moins restrictif. Il permet d'accéder à une classe, une méthode ou une variable non seulement depuis la classe où elles sont déclarées, mais aussi depuis l'extérieur. Ce modificateur est très souvent utilisé.