« Le professeur s'entête avec ses idées préhistoriques. Les vieux enseignants habitués à donner des leçons sont toujours comme ça. Il ne t'enseignera rien que tu ne peux pas trouver dans un livre. Tu as appris à nager en écoutant des conférences sur la natation, toi ? Les cours ne sont utiles que lorsque tu connais déjà le sujet presque autant que ton professeur. »

« Je trouve quand même ses leçons utiles. »

« Oui. Enfin, on espère qu'elles le sont. Plus tu entendras de points de vue sur un sujet, plus tu seras proche de la vérité. Si tu n'entends qu'une version, tu n'as que le choix entre croire ou ne pas croire. Bref, revenons à nos affaires. »

« Observons une image que je t'ai déjà montrée avant. »


public class Variables

{
   private static String TEXT = "The end.";
  ┗━━━━━━━━━━━━━━━━━━━┛
   public static void main (String[] args)
                          ┗━━━━━━━┛
  {
     System.out.println("Hi");
     String s = "Hi!";
   ┏┗━━━━┛
    System.out.println(s);
    if (args != NULL)
    {
       String s2 = s;
      ┗━━━━┛
   
      System.out.println(s2);
     
    }
    Variables variables = new Variables();
    System.out.println(variables.instanceVariable);
    System.out.println(TEXT);
   
  }
 
   public String instanceVariable;
  ┗━━━━━━━━━━━━━━━┛
   public Variables()
   {
      instanceVariable = "Instance variable test.";
   }
}

1. Une variable déclarée dans une méthode existe (est visible) de sa déclaration à la fin de la méthode.

2. Une variable déclarée dans un bloc de code existe jusqu'à la fin du bloc de code.

3. Les paramètres d'une méthode existent jusqu'à la fin de la méthode.

4. Les variables dans un objet existent pendant la durée de vie entière de l'objet qui les contient. Leur visibilité est également définie par des modificateurs d'accès spéciaux.

5. Les variables static (de classe) existent pendant toute l'exécution du programme. Leur visibilité est également définie par des modificateurs d'accès. »

« Exact. Je me souviens de cette image. »

« Parfait. Permets-moi de te rappeler quelques points essentiels. »

« Toutes les variables déclarées à l'intérieur de méthodes existent (sont visibles) du moment où elles sont déclarées à la fin de la méthode (exemple 1). »

« Si une variable est déclarée dans un bloc de code, elle existe jusqu'à la fin du bloc de code (exemple 2). »

« Si une variable est un paramètre de méthode, elle existe (est visible) dans l'ensemble du corps de la méthode (exemple 3). »

« Si une variable est une variable d'instance (exemple 4), elle est liée à un certain objet et existe tant que l'objet existe. Si aucun objet n'existe, il n'y a pas d'instances de la variable. Tu peux accéder à la variable (la variable est visible) à partir de toutes les méthodes de la classe, qu'elles aient été déclarées avant ou après. Une nouvelle variable est créée pour chaque objet. Elle est indépendante des autres objets. Tu ne peux pas accéder à une variable d'instance à partir de méthodes static. »

« Si une variable est marquée avec le mot-clé static, elle existe aussi longtemps que sa classe existe. La machine virtuelle Java charge généralement une classe en mémoire lors de sa première utilisation. C'est également à ce moment que les variables statiques sont initialisées. »

Plus de détails sur l'étendue des variables - 1

« L'exemple ci-dessus déclare la classe Chat, qui dispose de quatre variables : a, b, s (variables non statiques), et total (une variable statique). Si nous créons plusieurs objets de cette classe (disons trois), chacun d'eux contiendra ses propres instances des variables non statiques de la classe. Une variable statique est partagée par tous les objets d'une classe. Techniquement parlant, elle ne se trouve même pas à l'intérieur de ces objets, car elle existait avant la création des objets Chat. »

« Voici ce qui se passe si nous rendons la variable s statique : »

Plus de détails sur l'étendue des variables - 2

« OK. Je crois que j'ai compris. »

« Est-ce que tu peux déclarer des variables avec le même nom ? »

« Pas à l'intérieur d'une méthode. Toutes les variables déclarées dans une méthode doivent avoir des noms uniques. Les arguments d'une méthode sont également considérés comme des variables locales. »

« Qu'en est-il des variables membres ? »

« Les variables membres doivent être uniques pour chaque classe. »

« Mais il existe une exception : les noms des variables locales et des variables membres peuvent être identiques. »

« Si nous changeons cette variable, laquelle des deux variables portant le même nom sera modifiée ? »

« S'il y a plusieurs variables visibles (accessibles) dans notre code, disons une variable d'instance et une variable locale, la variable locale sera accessible. »

Exemple avec deux variables de total
class Main
{
    public int count = 0;     // Declare an instance variable

    public void run()
    {
        count = 15;           // Access the instance variable
        int count = 10;       // Declare a local method variable
        count++;             // Access the method variable
    }
}

« Ce code déclare deux variables de total. La ligne 3 déclare une variable d'instance, et la ligne 8 une variable locale. »

« Voici ce qui se passe lorsque la méthode executer est exécutée : »

« À la ligne 7, nous accédons à la variable d'instance et lui affectons la valeur 15. »

« À la ligne 8, nous déclarons (créons) une nouvelle variable locale : count. Elle masque la variable d'instance. La variable locale est ce que tout le code qui suit dans la méthode verra (aura accès à). »

« Je vois. »

« La variable locale masque la variable d'instance. En d'autres termes, la variable locale est celle à laquelle on accède. Cependant, tu peux accéder à la variable d'instance aussi. C'est juste un peu plus compliqué à faire. »

Static (Classe) variable
ClassName.variableName

// Here are some examples:
Cat.catsCount
Variable non statique (instance)
this.variableName

// Here are some examples:
this.catsCount

« Que d'autre peux-tu me dire sur les méthodes statiques et les variables statiques ? »

« Les méthodes et les variables statiques ne sont pas liées à des objets de la classe, mais à la classe elle-même. Si nous créons dix objets Variables (regarde l'exemple au début de ce niveau), nous aurons dix variables variableInstance (une pour chaque objet) et une seule variable partagée (statique) TEXTE. »

« J'ai une question. »

« Quelle est la différence entre les méthodes statiques et non statiques ? »

« Jetons un œil au fonctionnement d'une méthode non statique : »

Voici à quoi ressemble le code
Cat cat = new Cat();
String name = cat.getName();
cat.setAge(17);
cat.setChildren(cat1, cat2, cat3);
Ce qui se passe vraiment
Cat cat = new Cat();
String name = Cat.getName(cat);
Cat.setAge(cat,17);
Cat.setChildren(cat, cat1, cat2, cat3);

« Quand tu appelles une méthode en utilisant le format <objet> point <nom de la méthode>, tu appelles en fait une méthode de classe et tu passes ce même objet comme premier argument. Dans la méthode, l'objet est appelé 'this'. Toutes les opérations de la méthode sont effectuées sur cet objet et ses données. »

« Ouah ! Alors c'est comme ça que ça marche ! »

« Et voici comment une méthode statique fonctionne. »

Voici à quoi ressemble le code
Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount();
Ce qui se passe vraiment
Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount(null);

« Lorsque tu appelles une méthode statique, aucun objet n'est transmis. En d'autres termes, 'this' équivaut à null. C'est pourquoi une méthode statique ne peut pas accéder à des variables et méthodes non statiques (car elle ne peut pas passer 'this' à ces méthodes). »

« Hmmm. Je crois que j'ai compris. Du moins un peu. »

« Et voici tonton Diego... avec ses missions. »