Chapitre 5.1 - Modificateurs d'accès

5.1.1 – public

Le modificateur public rend un élément accessible de partout dans le programme, peu importe le package ou la classe. C'est le niveau d'accès le plus permissif.

Exemple : Élément public

public class Personne {
    public String nom;  // Accessible de partout
    public int age;     // Accessible de partout
    
    public void sePresenter() {  // Accessible de partout
        System.out.println("Je suis " + nom);
    }
}

// Utilisation depuis n'importe où
Personne p = new Personne();
p.nom = "Jean";  // OK : attribut public
p.sePresenter();  // OK : méthode public

Quand utiliser public :

Pour les classes qui font partie de l'API publique de votre application
Pour les méthodes qui doivent être accessibles depuis l'extérieur
Pour les constantes (public static final)
Attention : Évitez de rendre les attributs publics (utilisez plutôt private + getters/setters)

5.1.2 – private

Le modificateur private restreint l'accès à la classe elle-même. C'est le niveau d'accès le plus restrictif. Les éléments privés ne sont accessibles que depuis l'intérieur de la classe où ils sont déclarés.

Exemple : Élément privé

public class Personne {
    private String nom;  // Accessible uniquement dans cette classe
    private int age;      // Accessible uniquement dans cette classe
    
    // Méthode publique pour accéder à l'attribut privé
    public void setNom(String nom) {
        this.nom = nom;  // OK : dans la même classe
    }
    
    public String getNom() {
        return nom;  // OK : dans la même classe
    }
}

// Utilisation depuis l'extérieur
Personne p = new Personne();
// p.nom = "Jean";  // ❌ ERREUR : attribut privé
p.setNom("Jean");   // OK : utilise le setter public

Quand utiliser private :

Pour les attributs internes (encapsulation)
Pour les méthodes utilitaires internes à la classe
Pour cacher les détails d'implémentation
Recommandation : Rendez les attributs privés et utilisez des getters/setters publics pour y accéder

5.1.3 – protected

Le modificateur protected permet l'accès dans la classe elle-même, dans le même package, et dans les sous-classes (même si elles sont dans un autre package). C'est un niveau d'accès intermédiaire entre public et package-private.

Exemple : Élément protected

// Dans le package com.monapp
public class Personne {
    protected String nom;  // Accessible dans la classe, le package et les sous-classes
    protected int age;
    
    protected void afficherInfo() {
        System.out.println(nom + " - " + age);
    }
}

// Dans le même package
class AutreClasse {
    void test() {
        Personne p = new Personne();
        p.nom = "Test";  // OK : même package
    }
}

// Dans un autre package, mais sous-classe
package com.monapp.autre;
import com.monapp.Personne;

public class Etudiant extends Personne {
    public void afficher() {
        System.out.println(nom);  // OK : sous-classe (même dans un autre package)
        afficherInfo();            // OK : méthode protected héritée
    }
}

Quand utiliser protected :

Pour les attributs et méthodes qui doivent être accessibles aux sous-classes
Quand vous voulez permettre l'héritage mais pas l'accès public
Pour les méthodes qui sont destinées à être redéfinies dans les sous-classes
Utile dans les hiérarchies de classes où les sous-classes ont besoin d'accéder aux membres de la classe mère

5.1.4 – Accès par défaut (package-private)

Quand aucun modificateur n'est spécifié, l'élément a un accès package-private (aussi appelé accès par défaut). Il est accessible uniquement dans le même package. C'est le niveau d'accès par défaut si vous ne spécifiez pas de modificateur.

Exemple : Accès package-private

// Dans le package com.monapp.utilitaire
class Utilitaire {  // Pas de modificateur = package-private
    String nom;     // Accès par défaut
    
    void afficher() {  // Accès par défaut
        System.out.println(nom);
    }
}

// Dans le même package
class AutreClasse {
    void test() {
        Utilitaire u = new Utilitaire();  // OK : même package
        u.nom = "Test";                   // OK : même package
        u.afficher();                     // OK : même package
    }
}

Dans un autre package


package com.monapp.autre;
import com.monapp.utilitaire.Utilitaire;

class Test {
    void test() {
        // ❌ ERREUR : accès package-private
        // Utilitaire u = new Utilitaire();
        // u.nom = "Test";
    }
}

Important :

L'accès par défaut est souvent utilisé pour des classes utilitaires internes à un package
Si vous voulez que votre classe soit accessible depuis d'autres packages, utilisez public
L'accès par défaut est utile pour créer une API interne au package

Quand utiliser l'accès par défaut :

Pour les classes utilitaires qui ne doivent être utilisées que dans le même package
Pour créer une API interne au package
Pour limiter la visibilité sans utiliser private (qui serait trop restrictif)
Pour les classes helper ou les implémentations internes

📊 Tableau de comparaison des modificateurs d'accès

Voici un tableau récapitulatif qui compare tous les modificateurs d'accès en Java :

Modificateur	Même classe	Même package	Sous-classe (autre package)	Autre package	Exemple
public	✅	✅	✅	✅	`public String nom;`
protected	✅	✅	✅	❌	`protected String nom;`
package-private (par défaut)	✅	✅	❌	❌	`String nom;`
private	✅	❌	❌	❌	`private String nom;`

💡 Règles de visibilité

public : Accessible de partout (classe, package, sous-classes, autres packages)
protected : Accessible dans la classe, le package et les sous-classes (même dans d'autres packages)
package-private : Accessible uniquement dans le même package
private : Accessible uniquement dans la classe elle-même

Conseil pratique :

Utilisez private pour les attributs internes (encapsulation)
Utilisez public pour les méthodes et classes qui font partie de l'API publique
Utilisez protected quand vous voulez permettre l'accès aux sous-classes
Utilisez l'accès par défaut pour les classes utilitaires internes au package