Notes de cours Java

Ce document présente les notions essentielles sur les modifieurs d’accès, les variables locales, le modifieur final, les membres statiques, les constructeurs ainsi que les paramètres et types de retour en Java. Il s’adresse aux étudiants en informatique souhaitant comprendre les bases de la gestion des membres de classe et de l’instanciation en Java.

Modifieurs d’accès au niveau des membres des classes

En Java, les méthodes et attributs d’une classe sont appelés membres. Ces membres peuvent avoir quatre niveaux d’accès : public, protected, private et l’accès par défaut (package-private).

Le niveau d’accès détermine :

• Si un code dans une classe peut accéder à un membre d’une autre classe.
• Si une classe fille peut hériter un membre de sa classe mère.

Important :

• Si une classe n’est pas accessible (non visible), ses membres ne le sont pas non plus, quel que soit leur niveau de visibilité.
• La visibilité de la classe doit être déterminée avant celle de ses membres.
• Un membre public d’une classe mère est hérité par les sous-classes, quel que soit le paquetage.
• À l’intérieur d’une classe, les membres peuvent être utilisés sans l’opérateur « . ».
• this fait référence à l’objet en cours d’exécution. Par exemple, this.uneMethode() est équivalent à un appel direct uneMethode().
• Les membres private ne sont accessibles qu’à l’intérieur de la classe où ils sont déclarés, ils ne sont pas visibles ni hérités par les classes filles.
• Les membres protected et ceux avec accès par défaut diffèrent uniquement dans le contexte d’une classe fille.

Variables locales

• Les variables locales ne peuvent pas avoir de modifieurs d’accès.
• Seul le modifieur final peut être appliqué aux variables locales.
• Les variables locales n’ont pas de valeurs par défaut et doivent être initialisées avant utilisation.

Le modifieur final

Le mot-clé final peut qualifier les classes, méthodes et attributs :

• Une classe final ne peut pas être dérivée (pas de sous-classes).
• Une méthode déclarée final ne peut pas être redéfinie dans une classe fille.
• Les attributs peuvent être déclarés final, quel que soit leur niveau d’accès.

Pour les variables ou attributs final :

• Ils ne peuvent pas changer de valeur après leur initialisation (généralement lors de la déclaration).
• Les références final ne peuvent plus référencer un autre objet une fois affectées.
• Les attributs final doivent être initialisés avant la fin du constructeur.
• Un objet référencé par une référence final peut changer d’état (valeurs de ses attributs), seule la référence doit rester constante.

Variables et méthodes statiques (modifieur static)

Les variables et méthodes statiques appartiennent à la classe elle-même et non à ses instances :

• Pour accéder à une variable statique : NOMClasse.variableStatique.
• Pour accéder à une méthode statique : NomClasse.méthodeStatique(…).
• Il est possible d’accéder aux membres statiques via une instance, mais le compilateur remplace la référence par le nom de la classe.
• Il n’est pas nécessaire d’avoir une instance pour accéder aux membres statiques.
• Il existe une seule copie des variables et méthodes statiques, partagée par toutes les instances.
• Les méthodes statiques ne peuvent pas accéder directement aux membres non statiques.
• Les méthodes statiques sont utilisées pour des comportements indépendants des instances.
• Les variables statiques servent à stocker des données décrivant la classe, partagées par tous les objets.

Constructeurs et initialisation

Un constructeur est une méthode spéciale pour créer des objets :

• Il doit porter le même nom que la classe.
• Il n’a pas de type de retour. S’il y a un type de retour, ce n’est plus un constructeur mais une méthode.
• Il peut avoir n’importe quel modifieur d’accès, y compris private.

Lors de l’instanciation, chaque super-classe dans la hiérarchie a au moins un constructeur appelé :

1. Le constructeur appelle un constructeur de la classe mère (via super()) ou une surcharge dans la même classe (via this()).
2. Les appels s’enchaînent jusqu’à atteindre le constructeur de la classe Object.
3. Le constructeur de Object s’exécute puis retourne la main au constructeur appelant, et ainsi de suite jusqu’au constructeur de la classe instanciée.

Règles importantes :

• Un constructeur ne peut être appelé directement que depuis un autre constructeur avec super() ou this().
• La première instruction d’un constructeur doit être un appel à super() ou this().
• Le compilateur crée un constructeur par défaut (sans paramètres) s’il n’en existe aucun dans la classe.
• Le constructeur par défaut contient un appel implicite à super() sans paramètres.
• Si la classe mère n’a pas de constructeur sans paramètres, les constructeurs de la classe fille doivent appeler explicitement un constructeur de la classe mère avec les bons paramètres.
• Les constructeurs ne sont jamais hérités et ne peuvent pas être redéfinis.
• Les appels à this() et super() sont mutuellement exclusifs dans un même constructeur.

Paramètres et types de retour

• Les méthodes avec un type de retour non primitif (classe) peuvent retourner null ou un sous-type du type de retour (respectant le test « est-un »).
• Un tableau est un type valide pour les paramètres et le type de retour.
• Pour les types primitifs, toute valeur pouvant être implicitement convertie vers le type de retour est acceptée.
• Une méthode avec un type de retour void ne peut pas retourner de valeur, mais peut utiliser return seul pour arrêter l’exécution.
• Il est interdit de ne pas retourner de valeur dans une méthode dont le type de retour est différent de void.

Glossaire des termes clés

• Membre : Méthode ou attribut d’une classe.
• Modifieur d’accès : Spécifie la visibilité d’un membre (public, protected, private, par défaut).
• this : Référence à l’objet courant.
• final : Modifieur empêchant la modification d’une classe, méthode ou variable après sa déclaration.
• static : Modifieur indiquant qu’un membre appartient à la classe et non à une instance.
• Constructeur : Méthode spéciale utilisée pour créer et initialiser un objet.
• super() : Appel au constructeur de la classe mère.
• this() : Appel à un autre constructeur de la même classe.
• Type de retour : Type de donnée renvoyé par une méthode.
• Variable locale : Variable déclarée à l’intérieur d’une méthode ou d’un bloc.

Points clés à retenir

• Les modifieurs d’accès déterminent la visibilité et l’héritage des membres.
• Les variables locales ne peuvent être que finales ou sans modifieur d’accès.
• Le mot-clé final garantit l’immuabilité d’une référence ou empêche la redéfinition.
• Les membres static appartiennent à la classe, pas aux instances.
• Les constructeurs doivent respecter une chaîne d’appels vers la classe Object.
• Les méthodes doivent toujours retourner une valeur si leur type de retour n’est pas void.