1. Introduction
En Java, comme dans la vie, tout ne doit pas être accessible à tout le monde et tout le temps. Imaginez un appartement : vous ne voulez pas que les voisins se promènent dans votre chambre, n'est-ce pas ? De même, dans les programmes, nous voulons parfois « fermer la porte » à certaines variables ou méthodes, afin qu'on ne puisse pas y accéder depuis l'extérieur.
Pour cela, en Java il existe des modificateurs d'accès — des mots-clés spéciaux qui indiquent où l'on peut utiliser telle ou telle variable ou méthode : par exemple, public ou private.
Modificateurs d'accès principaux
| Modificateur | Visibilité |
|---|---|
|
Partout où la classe est visible (dans d'autres packages et dans d'autres fichiers) |
|
Uniquement à l'intérieur de la même classe |
|
Uniquement à l'intérieur du même package (c.-à-d. dans les classes du même répertoire) |
Il existe d'autres modificateurs, mais nous en parlerons plus tard, lorsque nous aborderons l'héritage.
Exemple pratique
public class User
{
public String name; // visible par tous
private int age; // visible uniquement à l'intérieur de la classe User
public void sayHello()
{
System.out.println("Bonjour, je m'appelle " + name);
}
private void secretMethod()
{
System.out.println("C'est une méthode secrète !");
}
}
Explication :
- name — visible partout où l'on peut utiliser la classe User.
- age — visible uniquement à l'intérieur de la classe User elle-même.
- sayHello() — méthode publique, elle peut être appelée depuis n'importe quelle autre classe.
- secretMethod() — méthode privée, elle ne peut pas être appelée depuis l'extérieur.
Comment cela fonctionne-t-il dans des cas réels ?
Supposons que nous ayons une classe décrivant un compte bancaire. Nous ne voulons évidemment pas que n'importe qui puisse modifier le solde directement ! La variable du solde sera donc private, et des méthodes dédiées permettront de la manipuler.
Pourquoi ne pas tout mettre en public ?
La tentation peut surgir : « Et si on mettait tout en public pour ne pas se compliquer la vie ? » Mais c'est la voie du chaos. Imaginez que n'importe qui puisse modifier votre solde, le nom d'utilisateur ou même appeler une méthode qui ne devait être utilisée qu'en interne. Dans les grands programmes, cela conduit à des erreurs et à des bugs « magiques ».
Règle d'or du développeur Java :
Commencez par tout mettre en private, puis n'exposez que ce qui est réellement nécessaire.
2. Portée des variables
La portée est la zone du code où une variable « existe » et peut être utilisée. En dehors de cette zone, la variable « disparaît » — comme si elle n'avait jamais existé.
En Java, il existe plusieurs types de variables selon leur portée :
- Variables locales — déclarées à l'intérieur d'une méthode ou d'un bloc de code { ... }.
- Paramètres de méthode — déclarés entre parenthèses de la méthode.
- Champs de classe — déclarés à l'intérieur de la classe, mais en dehors des méthodes.
Si une variable est déclarée à l'intérieur { du bloc },
elle n'est visible qu'à l'intérieur de ce bloc
et n'est pas accessible en dehors.Variables locales
Une variable locale ne vit qu'à l'intérieur de la méthode ou du bloc dans lequel elle est déclarée.
void printSum(int a, int b)
{
int sum = a + b; // variable locale
System.out.println(sum);
}
// sum n'existe plus ici !
Toute tentative d'accéder à sum en dehors de la méthode provoquera une erreur de compilation : « Impossible de trouver la variable sum ».
Paramètres de méthode
Les paramètres sont aussi des variables, mais elles ne vivent qu'à l'intérieur de la méthode.
void greet(String name)
{
System.out.println("Bonjour, " + name);
}
// name n'existe plus ici !
Champs de classe (membres)
Les champs de classe sont déclarés à l'intérieur de la classe, mais en dehors des méthodes. Ils sont visibles dans toutes les méthodes de cette classe.
public class Counter
{
private int count = 0; // champ de classe
public void increment()
{
count++; // nous pouvons utiliser le champ
}
public int getCount()
{
return count; // nous pouvons aussi utiliser le champ
}
}
3. Masquage des variables (shadowing)
Le masquage (shadowing) est une situation où, dans une zone de portée, on déclare une variable (ou un paramètre) avec le même nom qu'à l'extérieur. À l'intérieur de ce bloc, le « nouveau » nom masque l'ancien, et on ne peut plus accéder directement à la valeur externe.
Exemple de masquage :
class ShadowDemo
{
int value = 10; // champ de classe
void printValue()
{
System.out.println(value); // 10 — affiche le champ de classe
int value = 5; // la variable locale masque le champ de classe
System.out.println(value); // affiche 5, pas 10
}
}
Dans cet exemple, lorsque nous écrivons int value = 5;, nous déclarons une nouvelle variable locale qui a la priorité sur le champ de classe du même nom. En accédant à value dans la méthode printValue(), c'est la variable locale qui sera utilisée, et non le champ de classe.
S'il faut tout de même accéder à un champ de classe statique, utilisez le nom de la classe comme préfixe :
class ShadowDemo
{
static int value = 10; // champ de classe statique
void printValue()
{
System.out.println(value); // 10 — champ de classe
int value = 5;
System.out.println(value); // 5 — variable locale
System.out.println(ShadowDemo.value); // 10 — champ de classe statique, accès via 'ShadowDemo'
}
}
S'il faut accéder à un champ de classe non statique, utilisez le mot-clé this. Il désigne l'instance courante de l'objet.
class ShadowDemo
{
int value = 10;
void printValue()
{
System.out.println(value); // 10 — champ de classe
int value = 5;
System.out.println(value); // 5 — variable locale
System.out.println(this.value); // 10 — champ de classe, accès via 'this'
}
}
4. Pratique : modificateurs d'accès et portée
Continuons à développer l'application d'apprentissage : un simple système de gestion des étudiants. Créons des champs et des méthodes avec différents modificateurs d'accès.
Exemple : classe Student
public class Student
{
public String name; // nom de l'étudiant (visible par tous)
private int age; // âge (visible uniquement à l'intérieur de la classe)
public Student(String name, int age)
{
this.name = name;
this.age = age;
}
public void sayHello()
{
System.out.println("Bonjour, je m'appelle " + name);
}
private void printSecret()
{
System.out.println("Mon âge : " + age);
}
public void revealSecret()
{
printSecret(); // on peut appeler une méthode privée à l'intérieur de la classe
}
}
Utilisation de la classe Student
public class Main
{
public static void main(String[] args)
{
Student s = new Student("John", 20);
s.sayHello(); // OK : méthode publique
s.revealSecret(); // OK : méthode publique qui appelle une privée en interne
s.age = 30; // Erreur ! Le champ age est privé
s.printSecret(); // Erreur ! La méthode printSecret est privée
}
}
5. Erreurs courantes avec les modificateurs d'accès et la portée
Erreur n° 1 : Tout en public — bonjour le chaos !
Si vous rendez tous les champs et toutes les méthodes publics, vous risquez de perdre le contrôle sur qui modifie vos données et comment. Mettez les champs en private et n'exposez que le nécessaire.
Erreur n° 2 : Tenter d'utiliser une variable en dehors de sa portée.
Par exemple, vous déclarez une variable à l'intérieur d'une méthode, puis vous tentez d'y accéder depuis l'extérieur — vous obtiendrez une erreur de compilation. Les variables locales ne vivent que dans leur bloc { ... }.
Erreur n° 3 : Conflit de noms (masquage des variables).
Si, dans une méthode, vous déclarez une variable portant le même nom qu'un champ de classe, il est facile de s'y perdre. Utilisez this pour indiquer explicitement le champ de classe : this.value.
Erreur n° 4 : Tenter d'accéder à une méthode ou à un champ private depuis une autre classe.
Si une méthode ou un champ est marqué private, il n'est accessible qu'à l'intérieur de la même classe. Toute tentative d'y accéder depuis l'extérieur provoquera une erreur de compilation.
Erreur n° 5 : Oublier la portée dans une boucle ou un bloc.
Une variable déclarée à l'intérieur d'une boucle ou de n'importe quel bloc { } ne vit qu'à l'intérieur de ce bloc. En dehors du bloc, elle n'existe pas.
GO TO FULL VERSION