Les deux mots-clés “final” et “static” de Java sont au cœur du langage et il est important d’avoir une compréhension approfondie de leur fonction.

Variables static :

Si vous avec déjà touché à du code Java, vous êtes forcément tombé sur le fameux mot-clé “static“.
Nous avons tous commencé par ici :

public class Unicorn {
    public static void main(String[] args) {
        System.out.println("Hello Unicorn !");
    }
}

“static” est en plein dans la méthode main.
En bref, les champs avec le mot-clé “static” appartiennent à la classe, ce sont des méthodes et des variables de classe.

Lorsque vous apprenez la programmation orientée objet à partir d’un livre ou d’autres ressources, vous avez probablement rencontré l’analogie selon laquelle les classes sont comme des plans.
Continuons à nous appuyer sur cette analogie : si nous avons un plan pour une maison (vous pouvez construire de nombreuses maisons avec ce plan, tout comme vous pouvez créer de nombreux objets/instances en utilisant la classe), sur ce plan, vous pouvez avoir des informations qui décrivent le plan lui-même et non la maison.

Par conséquent, si nous avons une variable static dans une classe, cette variable contient des informations sur la classe elle-même.
J’espère que l’analogie le rend plus facile à comprendre, sinon, regardez l’exemple ci-dessous :

public class Unicorn {
    private String name;
    private static String description;
    public Unicorn() {
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static String getDescription() {
        return description;
    }
    public static void setDescription(String description) {
        Unicorn.description = description;
    }
}

Les variables sans le mot-clé “static” sont appelées variables d’instance, donc la variable “name” est référencée comme variable d’instance de la classe Unicorn.

Maintenant, pour la méthode principale (main) :

public class Main {
        public static void main(String[] args) {
            Unicorn uni1 = new Unicorn();
            Unicorn uni2 = new Unicorn();
            uni1.setName("Marguerite");
            uni2.setName("Brigitte");
            Unicorn.setDescription("Class Unicorn");
        }
    }

Remarquez la différence dans la façon dont nous définissons la variable d’instance “name” par rapport à la variable static “description”.

Lorsque nous définissons la variable d’instance ‘name’, nous le faisons en créant d’abord un objet/instance de la classe Unicorn, puis en définissant sa variable ‘name’.
Afin de définir la variable static “description”, nous le faisons en la définissant sur la classe elle-même via « Unicorn.setDescription (« Class Unicorn »); ».

Par conséquent, en définissant la variable “description” sur static, il n’y a qu’un seul champ par classe alors qu’il existe de nombreux champs “name” (un par objet créé).

Comment est-ce que cela pourrait être utile ?

Eh bien, un objectif pratique qu’une variable de classe pourrait servir est de compter le nombre d’instances de cette classe que nous avons, par exemple :

public class Unicorn {
    private String name;
    private static int count;
    public Unicorn() {
        Unicorn.count++;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static int getCount() {
        return count;
    }

Nous avons ajouté une variable static “count” à la classe Unicorn, et nous l’incrémentons dans notre constructor.
Désormais, chaque fois que nous créons une instance de la classe Unicorn, nous aurons une variable qui gardera une trace du nombre d’instances créées.

Une dernière chose à noter est que si les variables static ne sont pas initialisées avec une valeur, elles sont automatiquement initialisées avec une valeur par défaut qui sont :

• Entiers primitifs (long, short) : 0
• Virgules flottantes primitives (float, double) : 0,0
• Boolean : false, référence d’objet : null

Méthodes static

Les méthodes static sont des méthodes qui appartiennent à la classe.
Une chose importante à noter est que les méthodes static n’ont pas accès aux variables d’instance, elle ne peuvent accéder qu’à d’autres champs static.

Si vous essayez d’accéder à un champ d’instance depuis une méthode statique, pas d’inquiétudes : le compilateur vous enverra bouler :

java: non-static variable this cannot be referenced from a static context

En effets, les variables d’instance n’existent pas tant qu’une instance n’a pas été initialisée : alors que les variables static sont créées lorsqu’une classe est déclarée.
Les méthodes d’instance quant à elles, peuvent accéder à des variables static.

Accessibilité : Les champs / méthodes static peuvent être étiquetés comme “private” uniquement s’ils sont destinés à une utilisation en class uniquement.
S’ils doivent être utilisés en dehors de la classe, ils doivent être étiquetés “protected” ou “public“.

final

En un mot, le mot-clé “final” est la version Java de l’étiquetage d’une variable en tant que constante.

Le mot clé “final” empêche la variable d’être réaffectée à une valeur différente, donc une fois qu’une valeur est affectée, elle ne peut être réaffectée à autre chose.
Lorsque vous déclarez une variable et l’étiquetez “final“, elle doit également être initialisée.

Convention de code :
En Java, comme dans de nombreux autres langages, les noms de variables constantes sont TOUJOURS écrites en majuscules.

Un bon exemple existant est le fameux Pi :

public class Main {
        public static void main(String[] args) {
            System.out.println(Math.PI);
            Math.PI = 111;
        }
    }

Si vous essayez d’exécuter ce merveilleux code, vous aurez cette erreur :

java: cannot assign a value to final variable PI

Dans la classe Math de Java, la variable Pi est étiquetée avec une mot-clé “final” : ce qui en fait une constante, et comme nous l’avons vu précédemment, les variables final ne peuvent être réaffectées !