Les classes et les objets en Java
M. Berthouzoz
Cours préparé par L. Nerima
Université de Genève
Références
* Conception objet en Java avec BlueJ, David Barnes et
Michael Kölling, 4e édition, Pearson Education, 2009
Version anglaise : Objects First with Java, A Practical
Introduction using BlueJ, 6th Edition, Pearson, 2016
* Bersini, Hugues, La programmation orientée objet, 7e
édition, Eyrolles, 2017.
JAVA : de l’esprit à la méthode, Michel Bonjour, Gilles
Falquet, Jacques Guyot et André Legrand, 2e édition,
Vuibert, 1999 (Chapitre 6). PDF disponible sur le site Web
du séminaire Java.
Programmer en Java, Claude Delannoy, 10e édition,
Eyrolles, 2017.
I
S * Idées de lecture pour la semaine de lecture !
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 2
La modélisation orientée objet
Approche centrée sur les objets et les classes d’objets (regroupement
d’objets de même type).
Tout est objet : le système informatique sera constitué (uniquement)
d’objets. Les objets communiquent entre eux et avec l’extérieur ([Link].
interface utilisateur)
Les objets sont :
Les objets du domaine de l’application
les objets du monde (réel perçu) du domaine d’application
Les artefacts du système informatique
fenêtres, menus, boîtes de dialogue
I événements, transactions, règles
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 3
Rappel : Les classes en Java
Tout ce que nous avons vu concernant les classes et les objets en UML
et en Python demeure vrai en Java (seule la syntaxe change), à savoir :
La notion de classe étend celle de type de données
Une classe est un moule pour fabriquer des objets de même
structure et de même comportement
Un objet est une instance d’une et d’une seule classe
Une méthode définit une action élémentaire que l’on peut
effectuer sur un objet
Un message est une demande d’exécution d’une méthode à un
objet
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 4
Rappel : Classes et instances
Rectangle Disque
largeur rayon CLASSES
hauteur perimetre()
perimetre() surface()
surface() doubler()
diagonale()
doubler()
r1:Rectangle INSTANCES
r3:Rectangle (OBJETS)
d1:Disque
r2:Rectangle d2:Disque
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 5
Classes en Java : Déclaration (1)
En Java, la déclaration d’une classe s’écrit :
class Rectangle {
…
}
Une classe peut posséder des variables d’instance (propres à chaque
instance) :
class Rectangle {
double largeur, hauteur;
…
}
Une classe peut posséder des variables (ou constantes) de classe, qui
ne seront pas créées dans ses instances. La déclaration est précédée
du mot static :
class Disque {
static final double pi=3.141595;
…
I }
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 6
Classes en Java : Déclaration (2)
Les méthodes de classe déterminent le comportement des instances
(objets). La déclaration d’une méthode est composée des éléments
suivants :
Le type du résultat, ou void si la méthode ne produit pas de
résultat
Le nom de la méthode
Le type et le nom des paramètres entre ()
Le bloc d’instructions délimité par {}
Exemples :
double perimetre() {return 2*(largeur+hauteur);}
double surface() {return largeur*hauteur;}
double diagonale() {
[Link](largeur*largeur+hauteur*hauteur)}
I void doubler() {largeur*=2; hauteur*=2;}
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 7
Classes en Java : Constructeur
Le constructeur de classe est une méthode spéciale qui indique comment
initialiser une instance
Règle de nommage : le constructeur doit porter le même nom que la classe
class Rectangle {
double largeur, hauteur;
Rectangle(double initL, double initH){
largeur=initL;
hauteur=initH;
}
…
}
Ce constructeur initialise les deux variables d’instance largeur et hauteur
Constructeur par défaut : si aucun constructeur n’est défini pour une
classe, implicitement Java en crée un (mais qui n’initialise pas les variables
I d’instance)
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 8
La classe Rectangle complète
public class Rectangle {
double largeur, hauteur;
public Rectangle(double initL, double initH){
largeur=initL;
hauteur=initH;
}
double perimetre() {return 2*(largeur+hauteur);}
double surface() {return largeur*hauteur;}
double diagonale() {
return [Link](largeur*largeur+hauteur*hauteur)}
void doubler() {largeur*=2; hauteur*=2;}
}
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 9
La classe Disque
class Disque {
double diametre;
static final double pi=3.14159;
Disque(double initD) {diametre=initD;}
double perimetre() {return pi*diametre;}
double surface() {return
(pi*diametre*diametre)/ 4;}
double rayon() {return diametre/2;}
void doubler() {diametre*=2;}
}
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 10
Les classes dans l’environnement BlueJ
Le bouton New Class / Nouvelle classe de BlueJ génère
automatiquement :
public class Rectangle
{
private int x; // une variable d ’instance
public Rectangle() // un constructeur d ’objets Rectangle
{
x=0;
}
public int sampleMethod(int y) //un exemple de méthode
{
return x + y;
I }
S }
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 11
Création d’instances en Java
Pour créer une instance (objet), on invoque un constructeur avec
l’instruction new. [Link]. :
new Rectangle(5, 10); // création d’un rectangle de larg. 5, haut. 10
Pour se référer à l’objet créé, nous avons besoin d’une référence (ou
variable). La déclaration d’une référence se fait comme pour les types de
base (int, double, char, boolean…) en faisant précéder le nom de la
référence par le nom de la classe :
Rectangle r1, r2; // déclaration de deux rectangles
L’assignation se fait au moment de la création de l’instance
r1 = new Rectangle(5, 10); r2 = new Rectangle(2, 2);
Il est possible de déclarer la référence et de créer l’objet en même temps:
Rectangle r1 = new Rectangle(5, 10)
Dans BlueJ, on peut créer des instances « à la main » :
I click droit sur le rectangle de la classe > new nomConstructeur(param)
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 12
Invocation des méthodes sur une instance
L’invocation d’une méthode se fait en désignant l’instance (par la
référence) et en la faisant suivre du nom de la méthode et des
paramètres effectifs donnés sous forme d’expression, s’il y a lieu :
instance.méthode(expr1, expr2, …)
Par exemple, pour obtenir la surface du rectangle r1, on écrira :
[Link]()
Si la méthode possède des paramètres, les expressions passées en
paramètres sont évaluées puis affectées aux paramètres
correspondants de la méthode
Si l’on veut invoquer une méthode sur l’instance courante, on écrira:
this.méthode(expr1, expr2, …)
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 13
Un exemple de programme complet
class TestRectDisk1{
public static void main (String args[]) {
Rectangle r1=new Rectangle(2,4);
Rectangle r2=new Rectangle(3,4);
[Link]("diagonale de r1: "+[Link]());
[Link]("périmètre de r2: "+[Link]());
[Link]();
[Link]("périmètre de r2: "+[Link]());
Disque d1,d2; d1=new Disque(2); d2=new Disque(4);
[Link]("rayon de d1: "+[Link]());
[Link]("périmètre de d2: "+[Link]());
[Link]();
[Link]("périmètre de d2: "+[Link]());
I }
}
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 14
Déclaration de plusieurs constructeurs (1)
Il est parfois pratique de proposer plusieurs constructeurs pour
une même classe (permettant plusieurs formes de
représentations selon les utilisateurs)
Pour ce faire, il suffit de définir un nouveau constructeur devant
se distinguer des autres par le nombre et / ou le type de ses
paramètres
Par exemple, pour la classe Rectangle : nous pouvons ajouter
un constructeur qui construit un rectangle à partir du coin
supérieur gauche (x1,y1) et du coin inférieur droit (x2, y2)
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 15
Déclaration de plusieurs constructeurs (2)
class Rectangle {
double largeur, hauteur;
Rectangle(double initL, double initH){
largeur=initL;
hauteur=initH;
}
Rectangle(double x1, double y1, double
x2, double y2){
largeur=[Link](x2-x1);
hauteur=[Link](y2-y1);
}
…
}
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 16
Méthodes de classe (1)
Nous avons vu qu’il était possible de déclarer des variables de
classe
Il est également possible de déclarer des méthodes de classe
Ces méthodes sont destinées à agir sur la classe (plutôt que sur
les instances)
Tout comme pour les variables de classe, la déclaration des
méthodes de classe est précédée du mot static
L’invocation à une méthode de classe se fait en faisant précéder
le nom de la méthode par celui de la classe
nom_de_la_classe.méthode(expr1, expr2, …)
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 17
Méthodes de classe (2)
Exemple :
class Rectangle {
static double echelle=1.0; // variable de classe
double largeur, hauteur;
// méthode de classe
static void modifierEchelle(double e) {
echelle=e;
}
}
Invocation :
[Link](4)
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 18
Méthodes de classe : commentaires
La « célèbre » méthode main que nous avons utilisé jusqu’à
maintenant pour écrire nos programmes était en fait une
méthode de classe
Déclaration:
static void main(String args[])
La programmation avec des classes qui contiennent
exclusivement des variables de classes et des méthodes de
classes nous ramène dans le paradigme de la programmation
procédurale
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 19
Définition de sous-classes en Java
Général
est un est un
Particulier_1 Particulier_2
En Java, le mot réservé extends permet de déclarer une sous-
classe à partir d’une classe de base ou super-classe
La sous-classe hérite de tout ce qui a été défini dans la super-
classe (variables et méthodes)
Déclaration:
class Particulier_1 extends Général {…}
class Particulier_2 extends Général {…}
Le constructeur de la sous-classe peut utiliser le constructeur de
I la super classe en invoquant super(…)
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 20
Exemple : Carré extension de Rectangle
Rectangle
largeur
hauteur
perimetre()
surface()
class Carré extends Rectangle{ diagonale()
doubler()
Carre(double initC){
super(initC,initC); est un
}
double côté() {return [Link];} Carré
} côté()
super est utilisée pour atteindre le constructeur de la super-classe
Rectangle
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 21
Utilisation de la classe Carré
class TestCarré {
public static void main (String args[]) {
Carré c1=new Carré(4);
[Link]("dimension c1 : "+[Link]+
"/"+[Link]);
[Link]("surface c1 : "+[Link]());
[Link]( "côté de c1 : "+c1.côté());
}
}
Sortie :
dimension c1: 4/4
surface c1: 16
coté de c1: 4
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 22
Assignation et compatibilité des types
Affectation des objets : supposons qu’une variable (référence) soit de type
(classe) C ; on peut alors lui affecter un objet de la classe C ou d’une sous-
classe de C
Exemple:
Rectangle r;
r = new Carré(4);
Par contre, l’inverse n’est pas possible:
Carré c;
c = new Rectangle(5, 0); // Erreur à la compilation !!
Lorsqu’on est sûr du type, on peut le changer (garde de type):
Rectangle r;
Carré c;
r = new Carre(4); // r désigne bien un carré
…
c = (Carré) r; // c = r aurait été refusé à la compilation
Attention : à l’exécution, un contrôle de type est exécuté et si r n’est pas de
I type carré, un erreur d’exécution se produira
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 23
La référence en Java
En Java :
8 types primitifs : boolean, char, int, float, double…
Tous les autres types sont des types « référence », comprenant
les classes (comme les chaînes de caractères) et les tableaux
(array)
Le but d’une variable référence et de référencer un objet, c’est-
à-dire un moyen de désigner un objet
Une variable de type référence stocke l ’adresse
mémoire où un objet réside
On appelle plus simplement « référence » une variable
de type référence
Si une référence ne se réfère à aucun objet, sa valeur
I est « null »
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 24
La référence : exemple
Déclaration de la classe Tamagotchi (voir série 3 d’exercices Java)
public class Tamagotchi {
String nom; // variable d ’instance
Int age; // idem
…
public Tamagotchi(String n) // constructeur de
Tamagotchi
…
}
Déclaration de trois références et instanciation de deux objets :
Tamagotchi t1 = new Tamagotchi("Louis");
Tamagotchi t2 = new Tamagotchi("Louis");
Tamagotchi t3 = t1;
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 25
La référence : exemple (suite)
Après ces instructions, il y a en mémoire:
3 références (t1, t2 et t3)
2 objets de type Tamagotchi (avec le même nom : Louis)
t1 et t3 se réfèrent tous les deux au premier objet Tamagotchi
t2 se réfère au deuxième objet Tamagotchi
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 26
Opérateurs pour les références
En Java, il existe seulement 3 opérateurs pour les
références :
= pour l’affectation
== et != pour tester l’égalité et l’inégalité
Toutes les autres opérations souhaitées sont à définir
avec des méthodes
Exception : les références de type String possèdent
deux opérateurs supplémentaires : + et +=
(concaténation de chaînes de caractères)
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 27
Référence : la signification de =
La signification de = (affectation) pour les références est
exactement la même que pour les types primitifs : la
valeur contenue dans la référence de droite est
recopiée dans la référence de gauche
Comme la référence contient l’adresse mémoire où
réside l’objet référencé, c’est cette adresse qui est
recopiée dans la référence affectée (et non les valeurs
stockées dans l’objet !)
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 28
Référence : la signification de == et !=
L’expression t1==t2 teste si la valeur contenue dans la
variable t1 est égale à la valeur contenue dans t2
Comme les valeurs des références sont des adresses
mémoire d’objets, cela revient à tester si t1 et t2 se
réfèrent au même objet
L’opérateur != teste l’inégalité
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 29
Référence : la signification de == et != (suite)
Pour tester l’égalité du contenu de deux objets, on
utilise la méthode :
.equals()
définie sur dans la classe Object (et donc utilisable sur
n’importe quelle référence)
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 30
Exemple
Soit les déclarations:
Tamagotchi t1 = new Tamagotchi("Louis");
Tamagotchi t2 = new Tamagotchi("Louis");
Tamagotchi t3 = t1;
que valent les expressions suivantes ?
t1 == t2 // rép : …
t1 != t2 // rép : …
t1 == t3 // rép : …
[Link](t2) // rép : …
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 31
Exemple
Soit les déclarations:
Tamagotchi t1 = new Tamagotchi("Louis");
Tamagotchi t2 = new Tamagotchi("Louis");
Tamagotchi t3 = t1;
que valent les expressions suivantes ? Réponses:
t1 == t2 // faux car t1 et t2 référencent des objets diff.
t1 != t2 // vrai
t1 == t3 // vrai car t1 et t3 référencent le même objet
[Link](t2) // vrai car l’objet référencé par t1 et l’objet
// référencé par t2 contiennent la même valeur
// (dans la variable nom)
I
S
I Automne 2024 - M. Berthouzoz,
d'après le cours de L. Nerima Classes 32