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

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

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

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

2. l'utilisation de l'objet en appelant ces méthodes

3. 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

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