Programmation orientée objet
Chapitre 4 : Construction des classes et instanciations des objets en Java 1. Déclaration des classes en Java
La classe contient le modèle de construction d’un objet. La structure générale d’une classe en Java est la suivante :
Exemple
Public class Etudiant {
….. }
Les modificateurs de classe (ClassModifiers) sont :
public La classe est accessible partout
private la classe n'est accessible qu'à partir du fichier où elle est définie
final La classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est interdite. Les classes déclarées final ne peuvent donc pas avoir de classes filles.
abstract La classe contient une ou des méthodes abstraites, qui n'ont pas de définition explicite. Une classe déclarée abstract ne peut pas être instanciée : il faut définir une classe qui hérite de cette classe et qui implémente les méthodes nécessaires pour ne plus être abstraite.
Les modificateurs abstract et final ainsi que public et private sont mutuellement exclusifs ( on ne peut spécifier qu’un seul modificateur) .
15 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
Une classe est dite « Exécutable » si elle contient une méthode « public static void main (String Args[]) ».
Les classes non-exécutables peuvent être instanciables ou non-instaciables.
Les classes non-instanciables doivent être précédées par le modificateur « abstract ». Ces classes ne possèdent pas une définition complète pour être instanciées..
1.1. Les attributs
Les données d'une classe sont contenues dans attributs. Les attributs sont les propriétés d’une classe, ils sont tous visibles à l’intérieur de la classe. Les attributs sont donc des variables relatives à une instance (d’une classe) et qui sont accessibles dans toute la classe. La syntaxe générale de déclaration des attributs sont : ( Les Champs entre « [ ] » sont optionnels)
Exemple
Remarques
Les modificateurs de visibilité pour les attributs sont : « public », « private » et « protected ». On peut aussi utiliser le modificateur « Final » si l’attributs est une constante.
Les types des attributs peuvent être des type primitif (int, double, …) ou bien des type références (object, …)
1.2. Les méthodes
Pour écrire un programme avec un langage orienté-objet, le programmeur écrit uniquement des classes correspondant aux objets de son système. Les traitements à effectuer sont programmés dans les méthodes de ces classes qui peuvent faire appel à des méthodes d’autres classes.
La syntaxe générale de déclaration d’une méthode est la suivante :
16 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
Les modificateurs de méthodes sont :
public : la méthode est accessible aux méthodes des autres classes
private : l'usage de la méthode est réservé aux autres méthodes de la même classe
protected : la méthode ne peut être invoquée que par des méthodes de la classe ou de ses sous
classes
- final : la méthode ne peut être modifiée (redéfinition lors de l'héritage interdite)
Le type retourné peut être élémentaire (primitif) ou correspondre à un objet. Si la méthode ne retourne
rien, alors on utilise « void » . Il n'est pas possible d'indiquer des valeurs par défaut dans les
paramètres.
Les arguments sont passés par valeur : la méthode fait une copie de la variable qui lui est locale.
Lorsqu'un objet est transmis comme argument à une méthode, cette dernière reçoit une référence qui
désigne son emplacement mémoire d'origine et qui est une copie de la variable. Il est possible de
Publicité
modifier l'objet grâce à ces méthodes mais il n'est pas possible de remplacer la référence contenue
dans la variable passée en paramètre : ce changement n'aura lieu que localement à la méthode.
Lorsqu'un objet est passé en paramètre, ce n'est pas l'objet lui même qui est passé mais une référence
sur l'objet. La référence est bien transmise par valeur et ne peut pas être modifiée mais l'objet peut être
modifié via un message (appel d'une méthode).
Pour transmettre des arguments par référence à une méthode, il faut les encapsuler dans un objet qui
prévoit les méthodes nécessaires pour les mises à jour.
Exemple de déclaration de méthodes :
17 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
Remarques
Toutes les méthodes sauf les «constructeurs » doivent avoir un type de retour.
Les méthodes qui ne renvoient rien, utilisent « void » comme type de retour.
Une méthode peut ne pas avoir besoin d’arguments, ni de variables à déclarer.
Les méthodes agissent sur les attributs définis à l’intérieur de la classe.
Sans modificateur, la méthode peut être appelée par toutes autres méthodes des classes du package
auquel appartient la classe.
- La valeur de retour de la méthode doit être transmise par l'instruction return. Elle indique la valeur
que prend la méthode et termine celle ci : toutes les instructions qui suivent return sont donc ignorées.
1.3. Les constructeurs
La déclaration d'un objet est suivie d'une sorte d'initialisation par le moyen d'une méthode particulière
appelée constructeur pour que les variables aient une valeur de départ. Elle n'est systématiquement
invoquée que lors de la création d'un objet.
Le constructeur suit la définition des autres méthodes excepté que son nom doit obligatoirement
correspondre à celui de la classe et qu'il n'est pas typé, pas même void, donc il ne peut pas y avoir
d'instruction return dans un constructeur. On peut définir plusieurs constructeurs pour une classe
(surcharge). La définition d'un constructeur est facultative. Si aucun constructeur n'est explicitement
18 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
défini dans la classe, le compilateur va créer un constructeur par défaut sans argument. Dès qu'un
constructeur est explicitement défini, le compilateur considère que le programmeur prend en charge la
création des constructeurs et que le mécanisme par défaut, qui correspond à un constructeur sans
paramètres, n'est pas mis en oeuvre.
Si on souhaite maintenir ce mécanisme, il faut définir explicitement un constructeur sans paramètres
en plus des autres constructeurs.
Il existe plusieurs manières de définir un constructeur :
1) le constructeur simple : ce type de constructeur ne nécessite pas de définition explicite : son
existence découle automatiquement de la définition de la classe.
2) le constructeur avec initialisation fixe : il permet de créer un constructeur par défaut
3) le constructeur avec initialisation des variables : pour spécifier les valeurs de données à initialiser on peut les passer en paramètres au constructeur
Remarques :
Les objets déclarés en mémoire centrale ne peuvent pas être supprimé manuellement (pour libérer la
Publicité
mémoire). C’est le Garbage Collector qui gère automatiquement l’espace mémoire. Les objets qui ne
sont plus référencés seront supprimés automatiquement.
19 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
1.4. Les accesseurs
L'encapsulation permet de sécuriser l'accès aux données d'une classe. Ainsi, les données déclarées
private à l'intérieur d'une classe ne peuvent être accédées et modifiées que par des méthodes définies
dans la même classe.
Si une autre classe veut accéder aux données de la classe, l'opération n'est possible que par
l'intermédiaire d'une méthode de la classe prévue à cet effet. Ces appels de méthodes sont appelés «
échanges de message ».
Un accesseur est une méthode publique qui donne l'accès à une variable d'instance privée. Pour une
variable d'instance, il peut ne pas y avoir d'accesseur, un seul accesseur en lecture ou un accesseur en
lecture et un autre en écriture. Par convention, les accesseurs en lecture commencent par « get » et les
accesseurs en écriture commencent par « set ».
2. Instanciation des objets en Java
En Java, une application est un ensemble d’objets en interactions. Les objets sont des instanciations
des classes. Chaque objet est construit à partir d’un modèle (une classe). La classe est donc la
description d'un objet. Pour chaque instance d'une classe, le code est le même, seules les données sont
différentes à chaque objet.
20 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
2.1. La création d'un objet : instancier une classe
Il est nécessaire de définir la déclaration d'une variable ayant le type de l'objet désiré. La déclaration
est de la forme
Exemple :
L'opérateur new se charge de créer une instance de la classe et de l'associer à la variable. Il est possible
de tout réunir en une seule déclaration (comme pour l’objet E3).
Chaque instance d'une classe nécessite sa propre variable. Plusieurs variables peuvent désigner un
même objet. En Java, tous les objets sont instanciés par allocation dynamique. Dans l'exemple, la
variable E1 contient une référence sur l'objet instancié (contient l'adresse de l'objet qu'elle désigne :
attention toutefois, il n'est pas possible de manipuler ou d'effectuer des opérations directement sur
cette adresse comme en C).
Si E2 désigne un objet de type Etudiant, l'instruction « E2 = E1 » ne définit pas un nouvel objet mais
E1 et E2 désignent tous les deux le même objet.
L'opérateur new permet d'instancier des objets et d'appeler une méthode particulière de cet objet : le
constructeur . Il fait appel à la machine virtuelle pour obtenir l'espace mémoire nécessaire à la
représentation de l'objet puis appelle le constructeur pour initialiser l'objet dans l'emplacement obtenu.
Il renvoie une valeur qui référence l'objet instancié. Si l'opérateur new n'obtient pas l'allocation
mémoire nécessaire, il lève l'exception OutOfMemoryError.
21 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
Les objets ne sont pas des éléments statiques et leur durée de vie ne correspond pas forcément à la
Publicité
durée d'exécution du programme.
La durée de vie d'un objet passe par trois étapes :
1. la déclaration de l'objet et l'instanciation grâce à l'opérateur new
l'utilisation de l'objet en appelant ces méthodes
la suppression de l'objet : elle est automatique en Java grâce à la machine virtuelle. La
restitution de la mémoire inutilisée est prise en charge par le récupérateur de mémoire
( garbage collector ). Il n'existe pas d'instruction « delete » comme en C++.
2.2. Appel des attributs et des méthodes à partir des objets
L’échange des données entre les objets (les messages) est réalisé à travers l’exécution des méthodes de
chaque objet ou bien à travers l’accès à ses attributs. Pour accéder à la valeur d’un attribut d’un objet,
il faut utiliser le modèle de construction de l’objet (la classe) en utilisant la syntaxe suivante :
« Objet. nom_attribut ». Cette opération n’est autorisée sauf si l’attribut est déclaré « Public ».
Exemple : (supposant que l’attribut Nom de la classe Etudiant est déclaré public)
22 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
Concernant l’appel des méthodes, il est réalisé de la même façon que pour les attributs.
Après la création d’un objet, l’appel des méthodes est effectué selon la syntaxe
suivante « Objet.NomMethodes(arg1, arg2,…) ». Si la méthode retourne un résultat, il faut
que la variable déclarée soit de même type. Il est à remarquer aussi que le nombre des
arguments doit correspondre à la définition de la méthode dans la classe correspondante. Si
la méthode ne contient aucun argument, les parenthèses sont maintenues à vide.
« Objet.NomMethodes() ».
Exemple 1
appelés en local dans de la fonction calculMoyenne() ).
23 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
Exemple 3 (on suppose que les attributs privés de l’étudiants3 (note1 et notePFE sont appelés en local dans de la fonction calculMoyenne() et que ses ).
24 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
2.3. La comparaison des objets
Pour créer des objets identiques il faut utiliser la méthode « clone() » qui est héritée de la classe
« Object » qui est la classe mère de toutes les classes crées en Java. L’opérateur « = » ne permet pas
des créer des objets identiques. Il permet seulement de créer des références identiques pointant sur le
même objet.
Exemple 1 :
25 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
Dans le premier exemple E1 et E2 contiennent la même référence et pointent donc tous les deux sur le
même objet : les modifications faites à partir d'une des variables modifient l'objet en question.
L'opérateur « == » compare ces références. E1 et E2 sont donc egaux.
Dans le deuxième exemple, une copie de l’objet E1 est créée en la référençant par E2 à travers
l’utilisation de la méthode clone() . Cette méthode permet de créer un deuxième objet indépendant
Publicité
mais identique à l'original. L'opérateur « == » compare ces références. E1 et E2 donc porte des
propriétés identiques mais sont deux objets distincts (E1==E2) est faux :
Pour comparer l'égalité des variables de deux instances (objets), il faut munir la classe d'une méthode à
cet effet : la méthode equals() héritée de Object.
Exemple
Pour s'assurer que deux objets sont de la même classe, il faut utiliser la méthode getClass() de la
classe Object dont toutes les classes héritent.
Exemple
3. Les mots clefs et les méthodes spécifiques (relatives aux méthodes et classes)
3.1. Le mot clé « final »
Le mot clé final s'applique aux variables, aux méthodes et aux classes. Une variable qualifiée de final signifie que la variable est constante . Une variable déclarée final ne peut etre initialisée qu’une seule fois. On ne peut déclarer de variables final locales à une méthode. Les constantes sont généralement qualifiées de final et static .
Exemple :
26 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
Ou bien
Une méthode final ne peut pas être redéfinie dans une sous classe. Une méthode possédant le modificateur final pourra être optimisée par le compilateur car il est garanti qu'elle ne sera pas sous classée. Lorsque le modificateur final est ajouté à une classe, il est interdit de créer une classe qui en hérite. Il existe 2 types d’utilisations des attributs finaux : ou bien on initialise la valeur de la variable dés la déclaration, ou bien on initialise plus tard cette variable et son contenu ne sera jamais modifiée.
3.2. Le mot clefs « this »
Le mot clef « this » (considéré comme variable) sert à référencer dans une méthode l'instance de l'objet en cours d'utilisation. « this » est un objet qui est égale à l'instance de l'objet dans lequel il est utilisé.
La référence « this » peut être utile lorsqu’une variable locale (ou un paramètre) cache, en portant le même nom, un attribut de la classe.
This est aussi utilisé quand l'objet doit appeler une méthode en se passant lui même en paramètre de l'appel.
27 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
3.3. Le mot clefs « static »
Le mot clé static s'applique aux variables et aux méthodes . Les variables d'instance sont des variables propres à un objet. Il est possible de définir une variable de classe qui est partagée entre toutes les instances d'une même classe : elle n'existe donc qu'une seule fois en mémoire. Une telle variable permet de stocker une constante ou une valeur modifiée tour à tour par les instances de la classe. Elle se définit avec le mot clé « static » .
Une méthode static est une méthode qui n'agit pas sur des variables d'instance mais uniquement sur des variables de classe. Ces méthodes peuvent être utilisées sans instancier un objet de la classe. Les méthodes ainsi définies peuvent être appelées avec la notation « classe.methode() » au lieu de « objet.methode() » : la première forme est fortement recommandée pour éviter toute confusion.
Un exemple d’utilisation des variables « static » est le compteur d’instanciation d’objets d’une classe.
28 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
3.4. Le mot clefs « instanceof »
Le mot clef « instanceof » est un opérateur qui permet de déterminer la classe de l'objet qui lui est passé en paramètre. La syntaxe est : « objet instanceof classe »
Exemple :
3.5. Le mot clefs « null »
Le mot clef « NULL », qui référence un objet null, est utilisable dans les classes et les méthodes. Il n'appartient pas à une classe mais il peut être utilisé à la place d'un objet de n'importe quelle classe ou comme paramètre. « null » ne peut pas être utilisé comme un objet normal : il n'y a pas d'appel de méthodes et aucune classe ne peut en hériter.
Le fait d'initialiser une variable référant un objet à null permet au « Garbge Collector » de libérer la mémoire allouée à l'objet.
4. La surcharge des méthodes
La surcharge d'une méthode permet de définir plusieurs fois une même méthode avec des arguments différents. Le compilateur choisi la méthode qui doit être appelée en fonction du nombre et du type des arguments. Ceci permet de simplifier l'interface des classes vis à vis des autres classes.
Une méthode est surchargée lorsqu'elle exécute des actions différentes selon le type et le nombre de paramètres transmis. Il est donc possible de donner le même nom à deux méthodes différentes à condition que les signatures de ces deux méthodes soient différentes. La signature d'une méthode comprend le nom de la classe, le nom de la méthode et les types des paramètres.
Exemple de surcharge de constructeur et de la méthode afficherEtudiant() :
29 Chiheb-Eddine Ben N’Cir
Programmation orientée objet
30 Chiheb-Eddine Ben N’Cir