↑
CHAPITRE 5.4

Mots-clés static et final

Comprendre static (appartenant Ă  la classe) et final (immuable)
Les mots-clĂ©s static et final sont importants en Java. static indique qu'un Ă©lĂ©ment appartient Ă  la classe plutĂŽt qu'Ă  une instance. final indique qu'une valeur ne peut pas ĂȘtre modifiĂ©e.

5.4Mots-clés static et final

5.4 – Mots-clĂ©s static et final

đŸ”č Le mot-clĂ© static

Le mot-clĂ© static indique qu'un Ă©lĂ©ment (variable ou mĂ©thode) appartient Ă  la classe elle-mĂȘme, et non Ă  une instance (objet) de la classe. Cela signifie qu'il n'est pas nĂ©cessaire de crĂ©er un objet pour y accĂ©der.

Variables statiques (variables de classe)

Une variable statique est partagée par toutes les instances de la classe. Il n'y a qu'une seule copie de cette variable, peu importe le nombre d'objets créés.

Exemple : Compteur partagé

public class Personne {
    private String nom;
    static int nombrePersonnes = 0;  // Variable statique partagée
    
    public Personne(String nom) {
        this.nom = nom;
        nombrePersonnes++;  // Incrémente le compteur partagé
    }
    
    public static int getNombrePersonnes() {
        return nombrePersonnes;  // Accessible sans créer d'objet
    }
}

// Utilisation
Personne p1 = new Personne("Jean");
Personne p2 = new Personne("Marie");
System.out.println(Personne.getNombrePersonnes());  // Affiche : 2

Méthodes statiques (méthodes de classe)

Une mĂ©thode statique peut ĂȘtre appelĂ©e directement sur la classe, sans crĂ©er d'objet. Elle ne peut pas accĂ©der aux attributs d'instance (non statiques), mais peut accĂ©der aux variables statiques.

Exemple : Méthodes utilitaires

public class Calculatrice {
    // MĂ©thode statique : peut ĂȘtre appelĂ©e sans crĂ©er d'objet
    public static int additionner(int a, int b) {
        return a + b;
    }
    
    public static double calculerMoyenne(double[] nombres) {
        double somme = 0;
        for (double n : nombres) {
            somme += n;
        }
        return somme / nombres.length;
    }
}

// Utilisation : appel sur la classe
int resultat = Calculatrice.additionner(5, 3);
double moyenne = Calculatrice.calculerMoyenne(new double[]{10, 20, 30});
Important :

đŸ”č Le mot-clĂ© final

Le mot-clĂ© final indique qu'un Ă©lĂ©ment ne peut pas ĂȘtre modifiĂ© aprĂšs son initialisation. Il peut ĂȘtre appliquĂ© aux variables, mĂ©thodes et classes.

Variables finales

Une variable final doit ĂȘtre initialisĂ©e une seule fois et ne peut plus ĂȘtre modifiĂ©e par la suite.

Exemple : Variable finale
public class Personne {
    final String nom;  // Doit ĂȘtre initialisĂ©e dans le constructeur
    
    public Personne(String nom) {
        this.nom = nom;  // OK : initialisation
    }
    
    public void changerNom(String nouveauNom) {
        // this.nom = nouveauNom;  // ❌ ERREUR : ne peut pas modifier une variable finale
    }
}

Constantes (static final)

La combinaison static final crĂ©e une constante : une valeur qui appartient Ă  la classe et qui ne peut jamais ĂȘtre modifiĂ©e.

Exemple : Constantes
public class Mathematiques {
    // Constantes : static final
    public static final double PI = 3.14159265359;
    public static final int MAX_ENTIER = 2147483647;
    public static final String NOM_APPLICATION = "Mon Application";
}

// Utilisation
double perimetre = 2 * Mathematiques.PI * rayon;
System.out.println(Mathematiques.NOM_APPLICATION);
Convention de nommage : Les constantes sont généralement écrites en MAJUSCULES avec des underscores : PI, MAX_ENTIER, NOM_APPLICATION.

Méthodes finales

Une mĂ©thode final ne peut pas ĂȘtre redĂ©finie (overridden) dans les sous-classes.

Exemple : Méthode finale
public class Personne {
    public final void afficherInfo() {
        System.out.println("Informations de la personne");
    }
}

public class Etudiant extends Personne {
    // ❌ ERREUR : ne peut pas redĂ©finir une mĂ©thode finale
    // public void afficherInfo() { ... }
}

Classes finales

Une classe final ne peut pas ĂȘtre hĂ©ritĂ©e (pas de sous-classes possibles).

Exemple : Classe finale
public final class String {
    // ...
}

// ❌ ERREUR : ne peut pas hĂ©riter d'une classe finale
// public class MaString extends String { ... }

📊 Tableau de comparaison : static vs final

Caractéristique static final static final
Appartient Ă  La classe L'instance ou la classe La classe
Peut ĂȘtre modifiĂ© Oui Non (aprĂšs initialisation) Non (constante)
Nombre de copies Une seule (partagée) Une par instance (ou une si static) Une seule (constante partagée)
Utilisation Variables/méthodes de classe Valeurs immuables Constantes
Exemple static int compteur; final String nom; static final double PI;

💡 Points clĂ©s Ă  retenir

Conseils pratiques :