CHAPITRE 3 :

MANIPULATION DES
CLASSES ET OBJETS

Dr. A. Nejeoui

! POO JAVA: GI2

 INTRODUCTION
objectifs :
• Création et manipulation des variables d’instance / variables de classe
• Déclaration et manipulation des méthodes d’instance / méthodes de
classe
• Le mot clé this
• Passage d’arguments à une méthode
• La surcharge des méthodes
• Déclaration et manipulation des Constructeurs
• Création des objet / Opérateur new
• La redéfinition des méthodes
• Les tableaux
• Le transtypage

" POO JAVA: GI2

 DÉFINITION D’UNE CLASSE
Une classe est définie par le mot clé class suivi du nom de la classe
comme suit :
class UneClasse {
// le corps de la classe
}
Par défaut toute classe hérite de la classe Object. C’est la super-classe
dans la hiérarchie des classes Java.
Si une classe hérite d’une super classe on utilise le mot clés extends.
class UneClasse extends UneSuperClasse {
// le corps de la classe
}

# POO JAVA: GI2

 VARIABLES D'INSTANCE
Une variable est dite variable d’instance si elle est déclarée en dehors du
corps d’une méthode et elle n’est pas modifiée par le mot clé static.
Par convention les variables membres (variables d’instance + variables de
classe) sont déclarées juste après l’accolade ouvrante du corps de la
classe.
Exemple :
class Voiture {
String couleur;
String marque;
int nbrPortes;
Moteur motor;
}
Mais c’est possible de déclarer les variables membres n’import où dans le
corps de la classe en dehors du corps de toute méthode.

$ POO JAVA: GI2

 VARIABLES DE CLASSE
une variables de classe est une variable dont la valeur est partagée par
tous les objets instances de cette classe par opposition à une variable
d’instance qui peut changer de valeur d’un objet à l’autre.
On déclare un variable de classe par le mot clés static
Exemple :
class Voiture {
String couleur;
String marque;
int nbrPortes;
static int nbrRoues;
static int vitesseMax=300;
Moteur motor;
}

% POO JAVA: GI2

 LES MÉTHODES D’INSTANCE/
CLASSE
Une méthode d’instance définit le comportement des objets de la classe
(l’ensemble des tâche que ces objets peuvent accomplir).
En Java la définition d’une méthode comporte quatre parties :
1 Le nom de la méthode
2 La liste des paramètres
3 Le type d’objet ou type primitif retourné par la méthode
4 Le corps de la méthode

TypeRetourné nomMéthode (type1 arg1, type2 arg2, …, typeN argN)

{
// le corps de la méthode
}
Rq: Pour simplifier nous avons ignoré deux parties optionnelles : les
Modificateurs et le mot clés throws.
1 Le nom de la méthode : peut être tout identificateur valide.
2 La liste des paramètres : un ensemble de déclarations de variables
séparées par des virgules délimité par deux parenthèses ().
& POO JAVA: GI2
 LES MÉTHODES D’INSTANCE/
CLASSE
Les paramètres de la méthode sont traités dans le corps de la méthode
comme des variables locales. Ils reçoivent leurs valeurs lors d’un appel à
cette méthode.
3 Le type retourné peut être de type primitif, classe ou void si la méthode ne
renvoie aucun valeur. Si le type retourné est de type tableau, les crochets
doivent être placées soit après le type soit après la liste des paramètres.
Exemple :
String[ ] mots(String paragraphe) { String mots(String paragraphe)[ ] {
String[ ] parts = paragrapahe.split(“ ”); String[ ] parts = paragrapahe.split(“ ”);
return parts; return parts;
} }

Si le type retourné est différent de void la méthode doit obligatoirement

retourner une valeur de type compatible avec le type retourné déclaré.
4 Le Corps de la méthode : Dans le corps de la méthode vous pouvez avoir
des instructions, des expressions, des boucles et des appels à d’autres
méthodes.
' POO JAVA: GI2
 LE MOT CLÉ THIS
this représente l’objet courant, il est utilisé là où un objet instance de la
classe est attendu.
Exemple :
classe Figure2D{
double largeur;
double longueur;
public void setLargeur(double largeur ){ this.largeur=largeur; }
public double getLargeur() {
return this.largeur;
}
public double getLongueur(){
return this.longueur; }
public double surface(){
return this.getLargeur()*this.getLongoeur();
}
}
Les méthodes de classes déclarées avec le mot clé static ne peuvent pas
utiliser this
( POO JAVA: GI2
 PASSAGE D’ARGUMENTS À UNE
MÉTHODE

En java toutes les variables

sont passées par valeur :
La règle générale de Java
est que les arguments sont
passés par valeur. Cela
signifie que l'appel de
méthode se fait par copie
des valeurs passées en
argument et que chaque
appel de méthode dispose
de sa propre version des
paramètres.

) POO JAVA: GI2

 PASSAGE D’ARGUMENTS À UNE
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 l’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.
!* POO JAVA: GI2
 MÉTHODE DE CLASSE

Une méthode de classe définit un comportement de la classe entière et non

d’un objet spécifique. Pour définir une méthode de classe on utilise le
mot clé static. Une méthode de classe n’a pas besoins d’un objet pour
s’exécuter, on peut y accéder directement par le nom de la classe
exemples :
Character.isUpperCase(‘d’);
int n=PassageArguments.changer(102);
On utilise une méthode static lorsqu’on veut définir un comportement de
tous les objets instance de la classe, lorsqu’il s’agit d’un comportement
d’un objet spécifique on utilise une méthode d’instance.

!!POO JAVA: GI2

 SURCHARGE DE MÉTHODES
Surcharger une méthode
consiste à déclarer une
deuxième méthode qui porte
le même nom que la
première avec une liste
d’arguments différente.

Avantages :
▪ Éliminer la recherche des
noms de plusieurs
méthodes qui font la
même chose.
▪ Permettre de définir des
méthode qui agissent
différemment selon les
arguments passés.

!" POO JAVA: GI2

 LES CONSTRUCTEURS
Un constructeur d’une classe est une méthode utilisée par la MVJ lors de la
création des objets instances de cette classe. Par contre aux autres
méthodes les constructeurs ne peuvent être appelés directement dans
une application. Ils sont appelés automatiquement par la MVJ quand un
objet est crée par l’opérateur new.
Java effectue trois tâche lorsque l’opérateur new est utilisé pour créer un
objet instance d’une classe :
1- Allouer la mémoire
2- Initialiser les variables d’instance de cet objet, soit par des valeur initiales
soit par les valeurs par défaut (0 pour les nombres, false pour boolean,
null pour les objets et ‘\0’ pour char).
3- Exécuter les bloques d’initialisation.
4- Appeler l’un des constructeurs de la classe

!# POO JAVA: GI2

 LES CONSTRUCTEURS
Un constructeur diffère d’une
méthode d’instance en trois
points :
1- Il porte toujours le nom de la
classe
2- Il n’a pas un type de retour
3- Il ne renvoi aucun valeur (pas de
mot clé return dans le corps du
constructeur).
La premiere instruction d’un
constructeur doit être l’appel
d’un constructeur de la même
classe ou de sa super classe. Ce
qui assure que les variables
membres des super classes
sont initialisées en premier.
super(arg1,arg2,…,argN) : appel
d’un constructeur de la super
classe.

!$ POO JAVA: GI2 this(arg1,arg2,…,argN) : appel d’un

constructeur de la même
classe.
 LES BLOQUES D’INITIALISATION

!% POO JAVA: GI2

 REDÉFINITION D’UNE MÉTHODE
La redéfinition d’une
méthode consiste à re-
déclarer cette méthode
dans la sous classe avec
le même nom et la même
liste d’arguments (même
signature). et un type
de retour compatible
avec le type de retour de
la super classe.

pour différencier les

méthodes déclarées dans
la super classe de celles
déclarées dans la classe
courante on utilise les mot
clés super et this
respectivement.
!& POO JAVA: GI2
 CRÉATION DES OBJET(NEW)

L’instantiation des objets nécessite l’appel de l’opérateur new suivi par un

constructeur de la classe à instancier. Exemple :

Date date =new Date (1234567890L);

La gestion de mémoire en java se est automatique, Elle est assurée par la

ramasse-miette Java (JGC). Lorsque on crée un nouvel objet par
l’opérateur new , java alloue automatiquement la taille exacte de la
mémoire nécessaire pour stocker cet objet.
Quand l’objet n’est plus référencé dans l’application, java le détruit
automatiquement et libère l’espace mémoire occupé.
NB : les performances du JGC différent d’une JVM a une autres.
Pour des JGC optimisés voir Zing (azul.com).

!' POO JAVA: GI2

 LES TABLEAUX
Dans certains cas on a besoins de gérer plusieurs variables de même type,
par exemple 100 variables de type entier, au lieu de déclarer 100
différentes variables avec 100 identificateurs différents, il convient
d’utiliser un tableau d’entiers de taille 100.
On peut déclarer un tableau qui peut stocker des valeurs primitives, des
références à des objets d’une classe, des références à des interfaces ou
bien des références à des tableaux.
Une fois on a déclaré un tableau d’un type donné on ne peut y stocker que
des valeurs de types compatibles au type déclaré.
Ex : byte[] a=new byte[32];
ce tableau peut stocker des valeurs de type byte.
Object[] b=new Object[64];
ce tableau peut stocker des références à des objets de type Object ou de
type compatible.

!( POO JAVA: GI2

 LES TABLEAUX
Pour créer un tableau en java on suit les étapes suivantes :
1- déclarer une variable qui va stocker une référence au tableau
2- réserver l’espace mémoire pour stocker les éléments du tableau
3- stocker les éléments du tableau
Déclaration d’une variable qui va stocker une référence au tableau
Int [] n;
Point[] pt;
C’est le même principe utilisé pour déclarer une variable régulière (seule
valeur), les deux crochets sont ajoutés pour différencier les tableaux des
autres variables.
On peut aussi mettre les deux crochets après le nom de la variable comme
suit
Int n[];
Point pt[];
Réservation de l’espace mémoire
Car les tableau en java sont aussi des objets, on utilise l’opérateur new pour
créer un tableau.
Point[] pt=new Point[10];
Stockage des éléments du tableau
for (int i=0;i<10;i++) pt[i]=new Point();

!) POO JAVA: GI2

 LES TABLEAUX

"* POO JAVA: GI2

 TRANSTYPAGE IMPLICITE : ELARGISSEMENT
TYPES PRIMITIFS
byte

short
int
long char

float

double

"! POO JAVA: GI2

 TRANSTYPAGE IMPLICITE : ELARGISSEMENT
TYPES PRIMITIFS

• double > float > long > int > short > byte On peut Convertir
implicitement un type plus
• int > char petit en un type plus large

• boolean incompatible avec les autres types NB : Voir Section 5.1.2 de

la Specification du
• char et short sont incompatible language Java

• char et byte sont incompatibles

"" POO JAVA: GI2

 TRANSTYPAGE IMPLICITE : ELARGISSEMENT
INT OU LONG VERS FLOAT

NB : Voir Section 5.1.2 de la

Specification du language Java
"# POO JAVA: GI2
 TRANSTYPAGE EXPLICITE : RÉTRÉCISSEMENT
TYPES PRIMITIFS

"$ POO JAVA: GI2

 TRANSTYPAGE IMPLICITE : ELARGISSEMENT
TYPES RÉFÉRENCES

Une référence à un
objet peut référencer
l’un des trois types
suivants: classe,
interface ou tableau.
Pour les type référence,
le type devient plus
large lorsque vous
naviguez vers le haut
dans la hiérarchie
d’héritage. C’est une
règle générique pour
tout les trois type de
références.(classe,
interface, tableau)

"% POO JAVA: GI2

 TRANSTYPAGE IMPLICITE : ELARGISSEMENT
TYPES RÉFÉRENCES

SuperClasse su=new
SouClasse();
Verification Statique :
Le compilateur vérifie que les
méthodes et attributs invoqués
par la variable su sont déclarés
dans le type statique.
Par exemple l’instruction :
su.d=34; génère une erreur de
compilation
Liaison Dynamique :
Les méthodes invoquées sur
une variable sont liées au type
dynamique.

"& POO JAVA: GI2

 TRANSTYPAGE EXPLICITE : RÉTRÉCISSEMENT
TYPES RÉFÉRENCES
Verification statique :
Lors du transtypage explicite
entre deux types references A et
B : le compilateur vérifie que :
1- A et B sont liées par une
relation d’heritage.
2- A est une interface et B une
classe non finale.
3-Le transtypage entre deux
tableaux de type primitifs
différents est interdit.
4-Le transtypage entre deux
tableaux de type référence A[] et
B[] est possible si A et B
acceptent le transtypage
explicite.
Verification dynamique :
B b;
A a=(A)b;
"' POO JAVA: GI2 le type dynamique de B doit être
un sous type de A.
 CONCLUSION
Dans ce chapitre on a détaillé les points suivants :

Déclaration des classes

différence entre variables d’instance et variables de classe

Déclaration des méthodes

Déclaration des constructeurs

Instanciation des objets (Opérateur new)

Surcharge de méthodes et constructeurs

Redéfinition des méthodes

Transtypage implicite et explicite entre types primitifs et références

"( POO JAVA: GI2