« Passons à un nouveau sujet. Maintenant, je voudrais discuter des variables et des méthodes static. »

« Ellie, j'ai déjà étudié les variables et les méthodes static. Mais je voudrais connaître plus de détails. »

« Quand on déclare des variables dans une classe, on définit si ces variables sont créées une seule fois, ou si chaque instance (objet) de la classe aura sa propre copie. Par défaut, une nouvelle copie de la variable est créée pour chaque objet. Voici comment ça se passe : »

Déclaration de classe
class Cat                        // Class
{
    String name;                 // Variable

    Cat(String name)             // Constructor
    {
        this.name = name;        // Variable initialization
    }
}
Code dans la méthode main :
Cat cat1 = new Cat("Oscar"); // Create one object whose name variable contains "Oscar"
Cat cat2 = new Cat("Missy"); // Create one object whose name variable contains "Missy"
System.out.println(cat1.name);
System.out.println(cat2.name);
Sortie écran
Oscar
Missy

« Bien que déclarées dans la même classe (Chat), les variables cat1.name et cat2.name contiennent des valeurs différentes, car elles font référence à des objets différents. »
« Ça me paraît logique. »
« Cependant, une seule copie d'une variable static existe pour chaque instance d'une classe, et tu dois y accéder en utilisant le nom de la classe. »

Java university
Déclaration de classe
class Cat                   // Сlass
{
    String name;            // Instance (non-static) variable
    static int catCount;    // Static variable

    Cat(String name)
    {
        this.name = name;
        Cat.catCount++;   // Increment the static variable by 1
    }
}
Code dans la méthode main :
System.out.println(Cat.catCount);
Cat cat1 = new Cat("Oscar");

System.out.println(Cat.catCount);
Cat cat2 = new Cat("Missy");

System.out.println(cat1.name);
System.out.println(cat2.name);
System.out.println(Cat.catCount);
Sortie écran :
0
1
Oscar
Missy
2

« OK, je comprends ça aussi. »

« Les méthodes Java sont divisées en deux catégories. Les méthodes d'instance sont appelées sur un objet et ont accès à ses données. Les méthodes static n'ont pas cet accès, car elles n'ont tout simplement pas de référence à un objet. Cependant, elles sont en mesure de faire référence aux variables static et aux autres méthodes static de la classe.

Les méthodes static ne peuvent pas faire référence à des méthodes non static ou à des variables non static ! »

« Pourquoi ça, Ellie ? »

« Chaque variable d'instance est contenue dans un objet. Elle n'est accessible que si tu as une référence à cet objet. Aucune référence de ce genre n'est disponible dans une méthode static. »

« Est-ce que les méthodes d'instance ont une référence de ce genre ? »

« Oui, elle est passée indirectement aux méthodes d'instance. Une référence à l'objet sur lequel une méthode d'instance est appelée est indirectement passée à la méthode d'instance. La variable qui stocke cette référence est appelée this. Cela permet à la méthode de toujours accéder aux données de l'objet ou d'appeler une autre méthode non static sur le même objet.

Au lieu d'une référence d'objet, null est transmis aux méthodes static. Voilà pourquoi elles ne peuvent pas faire référence à des variables et méthodes non static. Elles n'ont tout simplement pas de référence à un objet associé à ces variables et méthodes. »

« OK, Ellie, je comprends. »

« Voici comment une méthode non static fonctionne :

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. »

« Voici comment les méthodes static fonctionnent :

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 static, aucun objet n'est passé. En d'autres termes, 'this' équivaut à null. C'est pourquoi une méthode static ne peut pas accéder à des variables et méthodes non static (car elle n'a rien à passer implicitement aux des méthodes non static). »

« Une variable ou méthode est static si elle a le mot-clé static devant elle. »

« Pourquoi ces méthodes sont nécessaires si elles sont autant limitées ? »

« Eh bien, ces méthodes ont leurs avantages. »

« Premièrement, nous n'avons pas besoin de passer une référence d'objet à utiliser aux méthodes et variables static. »

« Deuxièmement, il est parfois nécessaire d'avoir une seule et unique copie d'une variable. Par exemple, System.out (la variable static out de la classe System). »

« Troisièmement, tu auras parfois besoin d'appeler une méthode avant de pouvoir créer des objets. »

« Ellie, tu pourrais me donner un exemple pour illustrer ça ? »

« Pourquoi penses-tu que la méthode main() est static ? Elle est static pour que le programmeur puisse l'appeler immédiatement après le chargement d'une classe en mémoire, avant que des objets soient créés. »