Vous êtes sur la page 1sur 51

08/04/2020

POO en Java
Ch. III

Les Classes et les Objets

PLAN
Rappels: Concepts de l’orienté objet avec Java
I. Création d’une classe
II. Création et manipulation d’Objets
1. Introduction
2. Etapes de création des Objets
2.1. Déclaration d’un objet:
2.2. Création d’un objet
2.3. Initialisation par défaut
III. Définition des méthodes
IV. Accès aux membres d’un objet
1. Accès aux attributs(données membres)
2. Accès aux méthodes: appels des méthodes
V. Encapsulation (accessibilité)
IV. Méthodes d’accès aux valeurs des variables depuis
l’extérieur
V. Autoréférences: emploi de this
VI. Champs et méthodes de classe
1. Champs de classe (variable de classe)
2. Méthodes de classe
VII. Le mot clé final

1
08/04/2020

Rappels: Concepts de l’orienté objet avec Java

• La POO permet de concevoir une application sous la forme d'un


ensemble d'objets reliés entre eux par des relations.
• Lorsque l'on programme avec cette méthode, on se pose plus
souvent la question «qu'est-ce que je manipule ? », que « qu'est-
ce que je fais? ».
• L'une des caractéristiques de la POO permet de concevoir de
nouveaux objets à partir d'objets existants.

• On peut donc réutiliser les objets dans plusieurs applications.


• La réutilisation du code fut un argument déterminant pour vanter
les avantages des langages à objets.
3

Rappels: Qu’est ce qu’un objet?


• Un objet est une structure informatique caractérisée par
un état et un ensemble d'opérations exécutables par cet
objet qui caractérise son comportement.

Objet = état + comportement (opérations)

• Exemples:
– Une Fenêtre :
• Etat: position, taille, bordure, titre, couleur,...
• Opérations: dessiner, déplacer, agrandir,...
– Un Fichier
• Etat: nom, directory, id, protections, propriétaire, contenu,…
• Opérations: ouvrir, fermer, détruire,…

2
08/04/2020

Rappels: Représentation graphique d’un objet


en UML

• Exemple un objet Voiture nommé c5


c5:Voiture
couleur=bleue
puissance=130 Etat
curburant=30

démarrer()
accélérer()
Comportement
freiner()

 Les objets ayant les mêmes caractéristiques sont


regroupés dans une structure formelle, appelée
classe
5

Rappels: Classe
• La classe décrit le domaine de définition d’objets.

• Chaque objet appartient à une classe.

• Les généralités sont contenues dans la classe alors


que les particularités dans les objets.

• Les objets informatiques sont construits à partir de


la classe par un processus appelé instanciation.

• De ce fait tout objet est une instance de classe.


6

3
08/04/2020

Rappels: Caractéristiques d’une classe

• Une classe est définie par les attributs et les opérations (méthodes).

1) Attributs:
 Appelés également champs, ou données membres,
correspondent aux propriétés de la classe.
 Ils sont définis par un nom, un type de données et
éventuellement une valeur initiale.
 Un attribut est une variable qui stocke des données.
Employe
code : int
nom : String
nbEmployes : static int
Trois attributs de la classe Employe
7

Rappels: Caractéristiques d’une classe


2) Méthodes :
 Les méthodes permettent de décrire les comportements des objets.
 Elles représentent des procédures ou des fonctions qui permettent d’exécuter un
certain nombre d’instructions.
 Parmi les méthodes d’une classe existe une méthode particulière, qui porte le
même nom que la classe, qui s’appelle le constructeur.
 Le rôle du constructeur étant de créer les objets de la classe en les initialisant.
Employe
Attributs :
Exemple: code : int
afficheCode() et afficheNom() sont deux nom : String
méthodes qui affichent respectivement le nbEmployes : static int
code et le nom d’un employé Constructeur :
Employe()
Méthodes :
afficheCode() : void 8
afficheNom() : void

4
08/04/2020

I. Création d’une classe

Pour créer une classe (un nouveau type d’objets)


on utilise le mot clé class.

La syntaxe pour créer une classe de nom ClasseTest est la suivante:

class ClasseTest{ /* ClasseTest est le nom de la classe à créer */


/* Corps de la classe
- Description des attributs (données membres)
- Description des méthodes
*/
}

Exemple: Rectangle est une classe utilisée pour créer des objets
représentant des rectangles particuliers.
• Elle regroupe 4 données de type entier qui caractérisent le rectangle:
longueur, largeur et origine (x,y) (la position en abscisse et en
ordonnée de son origine).
• On suppose qu’on effectue les opérations de déplacement et de calcul
de la surface du rectangle.
• Les symboles + et – sont les spécificateurs d’accès (voir plus loin)
Exemple (notation UML (Unified Modeling Language)
- : private
Rectangle Nom de la classe # : protected
- longueur + : public
- largeur Description des attributs (champs) $ (ou souligné) : static
-x
-y
+ déplacer(int,int)
+ calculSurface() Description des méthodes (comportements)

10

5
08/04/2020

Code java de la classe Rectangle

Nom de la classe class Rectangle {


int longueur;
int largeur;
Attributs int x;
int y;
void deplace(int dx, int dy) {
x = x + dx;
Méthodes y = y + dy;
}
int surface() {
return longueur * largeur;
}
}

11

Classe : déclaration.
En Java, pour déclarer une classe on utilise le mot-clé class suivi
du nom de la classe.
public class Rectangle {
...
}

Règles
1. La première lettre du nom d’une classe doit toujours être
une lettre Majuscule (ex : Chat).
2. Mélange de minuscule, majuscule avec la première lettre de
chaque mot en majuscule (ex : ChatGris).
3. Une classe se trouve dans un fichier portant son nom
suivi de l’extention .java (ex : ChatGris.java)

12

6
08/04/2020

Classe : écriture
On peut placer une seule classe par fichier source. Mais, Java n’est pas tout à fait aussi
strict, il vous impose seulement de respecter les règles suivantes dans le :

Cas de plusieurs classes dans un même fichier source

Règles
1. un fichier source peut contenir plusieurs classes
mais une seule doit être publique
2. la classe contenant la méthode main doit obligatoirement
être publique, afin que la machine virtuelle y ait accès
3. une classe n’ayant aucun spécificateur d’accès reste accessible à toutes
les classes du même paquetage donc, a fortiori, du même fichier source

13

II. Création et manipulation d’Objets


1. Introduction

• Une fois la classe est définie, on peut créer des objets (=variables)

Donc chaque objet est une variable d’une classe. Il a son


espace mémoire. Il admet une valeur propre à chaque attribut.
Les valeurs des attributs caractérisent l’état de l’objet.

• L’opération de création de l’objet est appelée une instanciation.


Un objet est aussi appelé une instance d'une classe. Il est
référencé par une variable ayant un état (ou valeur).

• On parle indifféremment d’instance, de référence ou d’objet

14

7
08/04/2020

Une classe permet d’instancier plusieurs objets.


• les attributs et les méthodes d’un objet (d’une instance d’une classe) sont
les mêmes pour toutes les instances de la classe.
• Les valeurs des attributs sont propres à chaque objet.
• Par exemple rectangleR1 est une instance de la classe Rectangle

Rectangle Nom de la classe

« instance» Relation d’instanciation

rectangleR1 Nom de l’objet ou de l’instance


- longueur =10
- largeur =2
- x=0 Valeurs des attributs qui caractérisent
- y=0 l’objet rectangleR1

15

• Les valeurs des attributs peuvent être différentes.


Chaque instance d’une classe possède ses propres valeurs pour chaque attribut

Rectangle

« instance»

rectangleR1 rectangleR2 rectangleR3


- longueur =10 - longueur =5 - longueur =3
- largeur =2 - largeur =7 - largeur =5
- x=0 - x=1 - x=2
- y=0 - y=2 - y=0

(chaque objet a son propre état)


16

8
08/04/2020

• Les valeurs des attributs peuvent être différentes.


Chaque instance d’une classe possède ses propres valeurs pour chaque attribut

Voiture

« instance»

VW BM Honda
- Marque: Polo - Marque: X5 - Marque: Civic
- Coleur: Rouge - Coleur: Blanche - Coleur: Noire
- Vitesse: 5 - Vitesse: 6 - Vitesse: 5
- Porte: 3 - Porte: 5 - Porte: 5

(chaque objet a son propre état)


17

2. Etapes de création des Objets


Contrairement aux types primitifs, la création d’objets se passe en deux étapes:

- Déclaration de l’objet
- Création de l’objet

2.1. Déclaration d’un objet:


Chaque objet appartient à une classe. C’est une variable comme les
autres. Il faut notamment qu’il soit déclaré avec son type.

Syntaxe: NomDeClasse objetId;


NomDeClasse objetId1, objetId2,….;

- NomDeClasse est le nom de la classe.


- Déclare objetId1, objetId2, … comme variables de type NomDeClasse

18

9
08/04/2020

Attention:
- La déclaration d’une variable de type primitif réserve un emplacement
mémoire pour stocker la variable

- Par contre, la déclaration d’un objet, ne réserve pas une place mémoire
pour l’objet, mais seulement un emplacement pour une référence
à cet objet
les objets sont manipulés avec des références

19

Exemple:
Considérons la classe ClasseTest
class ClasseTest {
// corps de la classe ClasseTest
}
l’instruction:
ClasseTest objA;
- Déclare objA comme objet (variable) de type ClasseTest
- Définit le nom et le type de l’objet.
- Déclare que la variable objA est une référence à un objet de la classe
ClasseTest. Cela veut dire qu’on va utiliser une variable objA qui
référencera un objet de la classe ClasseTest.
- Aucun objet n’est créé: un objet seulement déclaré vaut « null ».

objA null

20

10
08/04/2020

2.2. Création d’un objet

Après la déclaration d’une variable, on doit faire la création (et


allocation) de la mémoire de l’objet qui sera référencé par cette variable

- La création doit être demandée explicitement dans le programme en


faisant appel à l’opérateur new.
- La création réserve de la mémoire pour stocker l’objet et initialise
les attributs

L’expression new NomDeClasse() crée un emplacement pour


stocker un objet de type NomDeClasse.

21

Exemple
class ClasseTest {
/* Corps de la classe ClasseTest */
}

ClassTest objA ; /* déclare une référence sur l’objet objA */


objA= new ClasseTest(); /* crée un emplacement pour stocker l’objet objA */

Les deux expressions précédentes peuvent être remplacées par :

ClassTest objA = new ClasseTest();

En générale:
1. Chaque objet met ses données membres dans sa propre zone mémoire.
2. Les données membres ne sont pas partagées entre les objets de la même classe.

22

11
08/04/2020

Exemple : Considérons la classe Rectangle

public class Rectangle{


int longueur;
int largeur;
int x;
int y;
public static void main (String args[]) {
Rectangle rectangleR1; /* déclare une référence sur l’objet rectangleR1 */
rectangleR1 = new Rectangle(); /* création de l’objet rectangleR1 */
// rectangle R1 est une instance de la classe Rectangle
// Les deux expressions peuvent être remplacées par :
// Rectangle rectangleR1= new Rectangle();
}
}

23

Attention déclaration / création


Il ne faut pas confondre
– déclaration d’une variable
– création d’un objet référencé par cette variable

Rectangle rectangleR1;
– déclare que l’on va utiliser une variable rectangleR1
qui référencera un objet de la classe Rectangle
– mais aucun objet n’est créé

rectangleR1 = new Rectangle();


Cette instruction permet la création de l’objet rectangleR1

24

12
08/04/2020

Référence d’un objet

Réellement Par analogie


 Une référence nous permet  Une adresse nous permet
de trouver l’objet. de trouver une maison.

 En utilisant la référence, on  En utilisant l’adresse, on


peut accéder aux attributs et peut envoyer une lettre à
méthodes de l’objet. cette maison.

Création des objets

Plan de construction

17, Bd Alqods 9, Rue Ifni 23, Rue Albasatine

Classe « Chemise »

Objet 1 Objet 2

Référence 1 Référence 2

13
08/04/2020

2.3. Initialisation par défaut


La création d’un objet entraîne toujours une initialisation par
défaut de tous les attributs de l’objet même si on ne les
initialise pas:
----------------------------------------------------------------
Type | Valeur par défaut |
-----------------------------|-----------------------------------|
boolean | false |
char | ‘\u0000’ (null) |
byte | (byte) 0 |
short | (short) 0 |
int | 0 |
long | 0L |
float | 0.0f |
double | 0.0 |
Class | null |
-----------------------------------------------------------------|

27

Attention:
Cette garantie d’initialisation par défaut
ne s’applique pas aux variables locales
(variables déclarées dans un bloc, par exemple
variables locales d’une méthode)
(voir plus loin)

28

14
08/04/2020

III. Définition des méthodes


En Java, chaque fonction est définie dans une classe . Elle est définie par:

– un type de retour
– un nom
– une liste (éventuellement vide) de paramètres typés en entrée
– une suite d’instructions (un bloc d’instructions) qui constitue le corps
de la méthode

Syntaxe: typeRetour nomMethode ( «Liste des paramètres » ) {

/*
corps de la méthode qui peut contenir l’instruction
*/
}

29

- nomMethode : c’est le nom de la méthode


(sa 1ère lettre doit être écrite en minuscule)
- « Liste des paramètres » : liste des arguments de la méthode.
Elle définit les types et les noms des informations qu’on
souhaite passer à la méthode lors de son appel.
- typeRetour : c’est le type de la valeur qui sera retournée par
la méthode après son appel. Si la méthode ne fournit aucun
résultat, alors typeRetour est remplacé par le mot clé void.
Remarque:
La valeur retournée par la fonction est spécifiée dans le corps
de la méthode par l’instruction de retour:
return expression;
ou
return; // (possible uniquement pour une fonction de type void)

30

15
08/04/2020

- La signature d’une méthode est: le nom de la méthode et


l’ensemble des types de ses paramètres.
- En Java, le type de la valeur de retour de la méthode ne fait pas
partie de sa signature (au contraire de la définition habituelle
d'une signature)
Passage des paramètres
Le mode de passage des paramètres dans les méthodes dépend de
la nature des paramètres :
- par valeur pour les types primitifs.
- par valeur des références pour les objets: la référence est
passée par valeur (i.e. le paramètre est une copie de la
référence), mais le contenu de l’objet référencé peut être
modifié par la fonction (car la copie de référence pointe vers
le même objet…) :

31

Méthodes et paramètres : à retenir


exemple : public, type de la valeur couples d'un type et d'un
static renvoyée ou void identificateur séparés par des « , »

<modificateur> <type-retour> <nom> (<liste-param>) {<bloc>}

public double add (double number1, double number2)


{ Notre méthode
retourne ici une
return (number1 +number2); valeur
}
Définition d’une méthode en Java
32

16
08/04/2020

Remarques importantes
1) La portée d’une variable locale est limitée au bloc constituant la
méthode où elle est déclarée. De plus, une variable locale ne doit pas
posséder le même nom qu’un argument muet de la méthode :
void f(int n)
{ float x ; // variable locale à f
float n ; // interdit en Java
.....
}
void g ()
{ double x ; // variable locale à g, indépendante de x locale à f
.....
}

2) Les variables locales ne sont pas initialisées de façon implicite


(contrairement aux champs des objets). Toute variable locale, y
compris une référence à un objet, doit être initialisée avant d’être
utilisée, faute de quoi on obtient une erreur de compilation.
33

IV. Accès aux membres d’un objet

1. Accès aux attributs(données membres)


Considérons la classe ClassTest suivante:
class ClasseTest {
boolean b;
double x;
}
ClasseTest objA = new ClasseTest();
// créer un objet de référence objA
// on peut dire aussi objA est une instance de la classe ClassTest
// ou tous simplement créer un objet objA

ClasseTest objB = new ClasseTest();

34

17
08/04/2020

Maintenant l’objet dont la référence objA existe.


Pour accéder à une donnée membre, on indique le nom de la
référence à l’objet suivi par un point suivi par le nom du
membre dans l’objet de la manière suivante:

nomObjet.nomAttibut
nomObjet = nom de la référence à l’objet
nomAttribut =nom de la donnée membre (attribut).

35

class ClasseTest {
Exemple 1: boolean b;
double x;
Pour les objets objA et objB }
ClasseTest objA = new ClasseTest();
de la classe ClassTest ClasseTest objB = new ClasseTest();
qui sont déjà créés:

objA.b=true; // affecte true à l’attribut b de l’objet objA.


objA.x=2.3; // affecte le réel 2.3 au membre x de l’objet objA.

objB.b=false; // affecte false à l’attribut b de l’objet objB.


objB.x=0.35; // affecte le réel 0.35 au membre x de l’objet objB.

36

18
08/04/2020

class Etudiant {
Exemple 2: String nom;
int age;
Soient 2 objets Etud1 et Etud2 }
Etudiant etud1 = new Etudiant();
de la classe Etudiant Etudiant etud2 = new Etudiant();

etud1.nom=ʺKamalʺ ; // affecte Kamal à l’attribut nom de l’objet etud1


etud1.age=22 ; // affecte l’entier 22 à l’attribut age de l’objet etud1

etud1.nom=ʺHasnaʺ ; // affecte Hasna à l’attribut nom de l’objet etud2


etud2.age=30 ; // affecte l’entier 30 à l’attribut age de l’objet etud2

37

Exercice: Soit Rectangle une classe utilisée pour créer des objets représentant
des rectangles particuliers
• Elle regroupe 4 données de type entier qui caractérisent le rectangle: longueur,
largeur et origine (x,y) (la position en abscisse et en ordonnée de son origine).
• On suppose qu’on effectue l’opération d’instanciation suivante:

Rectangle

rectangleR1 rectangleR2 rectangleR3


longueur =10 longueur =5 longueur =3
largeur =2 largeur =7 largeur =5
x=0 x=1 x=2
y=0 y=2 y=0

(Ecrire le code Java correspondant)


38

19
08/04/2020

Solution :
public class Rectangle{
int longueur, largeur;
int x, y;
public static void main (String args[]) {
Rectangle rectangleR1=new Rectangle ();
rectangleR1.longueur=10; rectangleR1.largeur=2;
rectangleR1.x=0; rectangleR1.y=0;
Rectangle rectangleR2=new Rectangle ();
rectangleR2.longueur=5; rectangleR2.largeur=7;
rectangleR2.x=1; rectangleR2.y=2;
Rectangle rectangleR3=new Rectangle ();
rectangleR3.longueur=3; rectangleR3.largeur=5;
rectangleR3.x=2; rectangleR3.y=0;
}
} 39

Classe chemise
public class Chemise{
int id;
char couleur;
float prix;
String description;
int quantite;
}

Création des objets


Classe « Chemise »

Objet 1 Objet 2

Référence 1 Référence 2

20
08/04/2020

Référence d’un objet

Réellement Par analogie


 Une référence nous permet  Une adresse nous permet
de trouver l’objet. de trouver une maison.

 En utilisant la référence, on  En utilisant l’adresse, on


peut accéder aux attributs et peut envoyer une lettre à
méthodes de l’objet. cette maison.

Notion de référence1/5

public class Test{ Mémoire

public static void main(String[] args){

Chemise maChemise;

maChemise=new Chemise();
maChemise
maChemise.couleur=‘R’;
}
}

Stack Heap
(pile) (tas)

Création d’une variable maChemise de type Chemise

21
08/04/2020

Notion de référence 2/5

public class Test{ Mémoire

public static void main(String[] args){


0x034009
Chemise maChemise;
id 0
'\u0000’
maChemise=new Chemise(); couleur
maChemise prix 0.0f
maChemise.couleur=‘R’; description null
} quantite 0
}

Stack Heap

Instanciation de la classe Chemise Création d’un objet.


Cet objet possède une adresse de son emplacement dans la mémoire (0x034009)

Notion de référence 3/5

public class Test{ Mémoire

public static void main(String[] args){


0x034009
Chemise maChemise;
id 0
'\u0000’
maChemise=new Chemise(); couleur
maChemise prix 0.0f
maChemise.couleur=‘R’; 0x034009 description null
} quantite 0
}

Stack Heap

Lier l’objet créé et la variable maChemise


maChemise est la référence de l’objet créé

22
08/04/2020

Notion de référence 4/5

public class Test{ Mémoire

public static void main(String[] args){


0x034009
Chemise maChemise;
id 0
maChemise=new Chemise(); couleur R
maChemise prix 0.0f
maChemise.couleur=‘R’; 0x034009 description null
} quantite 0
}

Stack Heap

En utilisant la référence maChemise, on peut accéder aux attributs de l’objet

Notion de référence 5/5

Mémoire
0x034009
public class Test{
id 0
public static void main(String[] args){ maChemise couleur R
prix 0.0f
Chemise maChemise=new Chemise() 0x034009
description null
quantite 0
maChemise.couleur=‘R’;

Chemise taChemise=new Chemise(); 0x99f311

} id 0
} taChemise
couleur '\u0000’

0x99f311 prix 0.0f


description null
quantite 0

Stack Heap

23
08/04/2020

Notion de référence 5/5

Mémoire
0x034009
public class Test{
id 0
public static void main(String[] args){ maChemise couleur R
prix 0.0f
Chemise maChemise=new Chemise() 0x034009
description null
quantite 0
maChemise.couleur=‘R’;

Chemise taChemise=new Chemise(); 0x99f311

maChemise.couleur=‘B’; id 0
taChemise B
couleur
maChemise.quantite=1; 0x99f311 prix 0.0f
} description null
} quantite 1

Stack Heap

2. Accès aux méthodes: appels des méthodes


• Les méthodes ne peuvent être définies que comme des
composantes d’une classe.
• Une méthode ne peut être appelée que pour un objet.
• L’appel d’une méthode pour un objet se réalise en
nommant l’objet suivi d’un point suivi du nom de la
méthode et de sa liste d’arguments:
nomObjet.nomMethode(arg1, ….)

nomObjet : nom de la référence à l’objet
nomMethode : nom de la méthode.

48

24
08/04/2020

Exemple 1: soit div() une méthode qui prend deux paramètres de


type int et qui retourne une valeur de type double.

class ClasseTest {
float x;
int i;
boolean b;
double div(int x, int y) {
// corps de la fonction div()
return x/y;
}
}
ClasseTest objA = new ClasseTest(); // créer un objet objA
double j = objA.div(5,3); // affecte à j la valeur retournée par div()

49

Exemple 2: Considérons la classe Rectangle dotée de la méthode


initialise qui permet d’affecter des valeurs à l’origine (aux attributs x et y).
public class Rectangle{
int longueur, largeur;
int x, y;
void initialiseOrigine(int x0, int y0) {
x=x0; y=y0;
}
public static void main (String args[]) {
Rectangle r1;
r1.longueur=4; r1.largeur=2;
r1. initialiseOrigine(0,0); // affecte 0 aux attributs x et y
// Erreur car l’objet n’est pas encore créé. Il faut tout d’abord le créer
}
r1=new Rectangle ();
}

50

25
08/04/2020

Exemple 3 : crée à l’origine un rectangle r1 de longueur 4 et de largeur 2

public class Rectangle{


int longueur, largeur;
int x, y;
void initialiseOrigine(int x0, int y0) {
x=x0; y=y0;
}
public static void main (String args[]) {
Rectangle r1=new Rectangle ();
r1.longueur=4; r1.largeur=2;
r1. initialiseOrigine(0,0);
}
}

51

Exercice: Soit Rectangle une classe utilisée pour créer des objets représentant
des rectangles particuliers
• Elle regroupe 4 données de type entier qui caractérisent le rectangle: longueur,
largeur et origine (x,y) (la position en abscisse et en ordonnée de son origine).
• On suppose qu’on effectue l’opération d’instanciation suivante sachant que
tous les rectangles auront initialement la même origine (0,0):
Rectangle

rectangleR1 rectangleR2 rectangleR3


longueur =10 longueur =5 longueur =3
largeur =2 largeur =7 largeur =5
x=0 x=0 x=0
y=0 y=0 y=0

(Ecrire le code Java correspondant)


52

26
08/04/2020

Solution :
public class Rectangle{
int longueur, largeur;
int x, y;
void initialiseOrigine(int x0, int y0) {
x=x0; y=y0;
}
public static void main (String args[]) {

Rectangle rectangleR1=new Rectangle ();


rectangleR1.longueur=10; rectangleR1.largeur=2;
rectangleR1.initialiseOrigine(0,0);

Rectangle rectangleR2=new Rectangle ();


rectangleR2.longueur=5; rectangleR2.largeur=7;
rectangleR2.initialiseOrigine(0,0);

Rectangle rectangleR3=new Rectangle ();


rectangleR3.longueur=3; rectangleR3.largeur=5;
rectangleR3.initialiseOrigine(0,0);
} 53
}

Exercice: Soit Rectangle une classe utilisée pour créer des objets représentant
des rectangles particuliers
• Elle regroupe 4 données de type entier qui caractérisent le rectangle: longueur,
largeur et origine (x,y) (la position en abscisse et en ordonnée de son origine).
• On suppose qu’on effectue l’opération d’instanciation suivante sachant que
tous les rectangles auront initialement des origines différentes:
Rectangle

rectangleR1 rectangleR2 rectangleR3


longueur =10 longueur =5 longueur =3
largeur =2 largeur =7 largeur =5
x=0 x=10 x=20
y=0 y=10 y=20

(Ecrire le code Java correspondant)


54

27
08/04/2020

Solution :
public class Rectangle{
int longueur, largeur;
int x, y;
void initialiseOrigine(int x0, int y0) {
x=x0; y=y0;
}
public static void main (String args[]) {

Rectangle rectangleR1=new Rectangle ();


rectangleR1.longueur=10; rectangleR1.largeur=2;
rectangleR1.initialiseOrigine(0,0);

Rectangle rectangleR2=new Rectangle ();


rectangleR2.longueur=5; rectangleR2.largeur=7;
rectangleR2.initialiseOrigine(10,10);

Rectangle rectangleR3=new Rectangle ();


rectangleR3.longueur=3; rectangleR3.largeur=5;
rectangleR3.initialiseOrigine(20,20);
} 55
}

Méthode d’affichage: print()


public class Affichage {
public static void main(String args[]) {
int x=10;
int y=16;
System.out.println(" La valeur de x est: " + x );
System.out.println(" La valeur de y est : " + y);

System.out.println(" La valeur de x est: " + x + " et la valeur de y est : " +y);


System.out.println(" Les valeurs de x et y sont: (" + x +" , " +y + ")" );
}
}

La valeur de x est: 10 println () avec retour à la ligne


La valeur de y est : 16
print () sans retour à la ligne
La valeur de x est: 10 et la valeur de y est : 16
Les valeurs de x et y sont: (10 , 16)
56

28
08/04/2020

Exercice: classe chemise ID:1234


Chemise1

Prix:20.5 Dh
Une société de textile vend des chemises par catalogue.
Couleur:B
On veut développer un programme pour cette société.
Taille:XL
On sait qu’une chemise possède les caractéristiques suivantes:
Description:40%P,35%N, Slim Fit
• un identifiant- code à barre
Quantité:10
• est disponible en plusieurs coloris– bleu, vert, etc
• est disponible en plusieurs tailles
Chemise2
• a un prix
• a une description – type du tissu, style, etc ID:1266
• une quantité dans le stock Prix:28.5 Dh
Couleur:V
On peut ajouter ou diminuer des chemises du stock. Taille:L
On peut afficher les informations de chaque chemise. Description:30%P,45%N, Large
Quantité:20

Chemise1
ID:1234
Prix:20.5 Dh
Créer les objets chemise 1 et 2 et afficher les Couleur:B
informations les concernant Taille:XL
Description:40%P,35%N, Slim Fit
Quantité:60
57

Classe chemise
public class Chemise{
int id;
char couleur;
float prix;
String description;
int quantite;

void ajouterChemise (int nombre) {


quantite += nombre;
}

void dimunierChemise (int nombre) {


quantite - = nombre;
}

void afficherInfoChemise() {
System.out.println(id+ info);
}
}

29
08/04/2020

V. Encapsulation (accessibilté)
• Une classe permet d’envelopper les objets : un objet est vu par le
reste du programme comme une entité opaque.
• L'enveloppement [wrapping] des attributs et méthodes à l'intérieur
des classes plus (+) le contrôle d'accès aux membres de l’objet est
appelé encapsulation.
• Le contrôle d'accès aux membres de l’objet est appelé cacher
l'implémentation: les membres publiques sont vus de l'extérieur
mais les membres privés sont cachés.
L'encapsulation est un mécanisme consistant à rassembler les
données et les méthodes au sein d'une structure en cachant
l'implémentation de l'objet, c'est-à-dire en empêchant l'accès aux
données par un autre moyen que les services proposés.

59

• Possibilité d’accéder aux attributs d’une classe Java mais


ceci n’est pas recommandé car contraire au principe
d’encapsulation: les données (attributs) doivent être
protégés.
• Accessibles pour l’extérieur par des méthodes particulières
(sélecteurs)
• Plusieurs niveaux de visibilité peuvent être définis en
précédant, la déclaration d’un attribut, d’une méthode ou
d’un constructeur, par un modificateur : private, public ou
protected.

60

30
08/04/2020

Spécificateurs d’accès:
L'encapsulation permet de définir 3 niveaux de visibilité des éléments de
la classe.
Ces 3 niveaux de visibilité (public, private et protected) définissent les
droits d'accès aux données suivant le type d’accès:
• public: accès depuis l’extérieure (par une classe quelconque)
• private : accès depuis l’intérieure (accès par une méthode de la classe
elle-même)
• protected: se comporte comme private avec moins de restriction. Une
classe dérivée a un accès aux membres protected mais pas aux
membres private.
• Accès par défaut: lorsqu’aucun de ces spécificateurs n’est mentionné.

Encapsulation "usuelle": les attributs sont privés,


et les méthodes sont publiques

61

Constitution d’un programme Java

• Un programme Java utilise un ensemble de classes


• Les classes sont regroupées par package
• Une classe regroupe un ensemble d’attributs
et de méthodes

62

31
08/04/2020

C’est quoi un package?

Projet • Package = répertoire.


• Les classes Java peuvent être regroupées dans des packages.
package 1

ClassA
Déclaration d’un package
ClassB
package pack1;
Package 2
Import d’un package
ClassC
import pack2.ClassC;
ClassD
import pack2.*;
Package 21

ClassE • Importe toutes les classe du package 2 (ClassC et ClassD)


• N’importe pas les classes du sous package 21 (ClassE)

Exemple 1: modification depuis l’extérieur d’un champs private


class ClasseTest {
public int x;
private int y;
public void initialise (int i, int j){
x=i;
y=j; // accès à l’attribut private y depuis l’intérieur de la classe OK
}
}
public class TestA{ // fichier source de nom TestA.java
public static void main (String args[]) {
ClasseTest objA;
objA=new ClasseTest(); // On peut aussi déclarer ClasseTest objA=new ClasseTest();
objA.initialise(1,3); // x vaut 1 et y vaut 3
objA.x=2; // x vaut maintenant 2. On peut accéder à x car il est public
objA.y=3;
// ne compile pas car accès à un attribut y privé de la classe ClasseTest
// depuis l’extérieur (classe TestA)
}
}

64

32
08/04/2020

Exemple 2: affichage depuis l’extérieur d’un champs private


class ClasseTest {
public int x;
private int y;
public void initialise (int i, int j){
x=i;
y=j; // accès à l’attribut private y depuis l’intérieur OK
}
}
public class TestA{ // fichier source de nom TestA.java
public static void main (String args[]) {
ClasseTest objA;
objA=new ClasseTest(); // On peut aussi déclarer ClasseTest objA=new ClasseTest();
objA.initialise(1,3); // x vaut 1 et y vaut 3
System.out.println(" x= "+objA.x); // affiche x = 1 puisque x public, on peut y accéder
System.out.println(" y= "+objA.y);
// ne compile pas car accès à un attribut y privé de la classe ClasseTest
} // depuis l’extérieur (classe TestA)
}

65

Exemple 2: affichage depuis l’extérieur d’un champs private

66

33
08/04/2020

Exemple 3: affichage depuis l’intérieur d’un champs private

67

Encapsulation des attributs


L’attribut private
Package 1 Package 2

class A class C
public int x;
private int y;
int z;
protected w; class B class D

private int y La variable private n'est accessible que depuis l'intérieur même de la classe.

public class A { class B { class C extends A { class D {


private int y; A a=new A(); A a=new A(); A a=new A();
A a=new A(); int t=a. y ; int t=a. y ; int t=a. y ;
int t=a. y ; … … …
… } } }
}

34
08/04/2020

IV. Méthodes d’accès aux valeurs des variables depuis l’extérieur


Comment peut on accéder à la valeur d’une variable protégée ??
Considérons la classe Etudiant qui a les champs nom et prenom private.
Exemple:
class Etudiant {
private String nom, prenom;
public void initialise(String st1, String st2){
nom=st1; prenom=st2;
}
}
public class EtudiantTest{
public static void main(String[] args) {
Etudiant e= new Etudiant();
e.initialise("Mohd","Ali");
System.out.println("Nom = "+e.nom);
// ne compile pas car le champs nom est privé
/* comment faire pour afficher le nom de l’étudiant e ??
}
} 69

Méthodes d’accès aux valeurs des variables depuis l’extérieur

Accesseur Mutateur
Getters Setters
getNomDonnee() setNomDonnee ()

70

35
08/04/2020

Pour afficher la valeur de l’attribut nom (champs private), on définie


Un accesseur (méthode getNom) qui est une méthode permettant de
lire, depuis l’extérieur, le contenu d'une donnée membre protégée.
Exemple:
class Etudiant {
private String nom, prenom;
public void initialise(String nom, String prenom){
this.nom=nom; this.prenom=prenom;
}
public String getNom (){
return nom;
}
public String getPrenom (){
return prenom;
}
}
public class EtudiantTest{
public static void main(String[] args) {
Etudiant e= new Etudiant();
e.initialise("Mohd","Ali");
System.out.println("Nom = "+e.getNom());
System.out.println("Prenom = "+e.getPrenom());
}
}
71

Comment peut-on modifier (depuis l’extérieur) le contenu d'un attribut privé?

Exemple:
class Etudiant {
private int cne;
}

public class EtudiantTest{


public static void main(String[] args) {
Etudiant e= new Etudiant();
// Modifier le champs cne (attribut private)
e.cne=23541654;
// ne compile pas car le champ cne est un champ protégé (private)
}
}

72

36
08/04/2020

Pour modifier la valeur de l’attribut nom (champs private), on défine


Un modificateur (mutateur) qui est une méthode permettant de
modifier le contenu d'une donnée membre protégée.
Exemple:

class Etudiant {
private int cne;
public void setCNE (int cne){
this.cne=cne;
}
}
public class EtudiantTest{
public static void main(String[] args) {
Etudiant e= new Etudiant();
e.setCNE(23541654);
}
}

73

Encapsulation des attributs/méthodes


Dans le but de renforcer le contrôle d’accès aux variables d'une classe, il
est recommandé de les déclarer private.

Pour la manipulation des attributs private, on utilise:


• Un mutateur (setter): est une méthode qui permet de définir la valeur
d'une variable particulière
• Un accesseur (getter): est une méthode qui permet d'obtenir la valeur
d'une variable particulière.

Le setter et le getter doivent être déclarés public

private float prix; private boolean absent;

public void setPrix(float prix){ public void setAbsent(boolean absent){


this.prix=prix; this.absent=absent;
} }
public float getPrix(){ public boolean isAbsent(){
return prix; return absent;
} }

37
08/04/2020

Encapsulation des attributs


Package 1 Package 2

class A class C
public int x;
private int y;
int z;
protected w; class B class D

Visibilité à partir Classe Package Classe fille Tout le


de: reste
A B C D
public (x)
private (y)
default (z)
protected (w)

Encapsulation des méthodes


Package 1 Package 2

class A class C
public void meth1(){};
private void meth2(){};
void meth3(){};
protected void meth4(){}; class B class D

Visibilité à partir de: Classe Package Classe fille Tout le


reste
C D
A B
public (meth1)
private (meth2)
default (meth3)
protected (meth4)

38
08/04/2020

V. Autoréférences: emploi de this


- Possibilité au sein d’une méthode de désigner explicitement
l'instance courante : faire référence à l’objet qui a appelé cette
méthode.
- Par exemple pour accéder aux attributs "masqués" par les
paramètres de la méthode.

class ClasseA {
….
public void f(….) {
…… // ici l’emploi de this désigne la référence à l’objet
// ayant appelé la méthode f
}
}

77

Exemple:
class Etudiant {
private String nom, prenom;
public initialise(String st1, String st2) {
nom = st1;
class Etudiant {
prenom = st2; private String nom, prenom;
} public initialise(String nom, String prenom){
} this.nom=nom;
this.prenom=prenom;
}
}

Comme les identificateurs st1 et st2 sont des arguments muets pour
la méthode initialise(), alors on peut les noter nom et prenom qui
n’ont aucune relation avec les champs private nom et prenom.
Dans ce cas la classe Etudiant peut s’écrire comme suit:

78

39
08/04/2020

L’autoréférence (this) est utilisée principalement :


 pour lever une ambiguïté,
 dans un constructeur, pour appeler un autre constructeur de la même classe,
 lorsqu'une référence à l'instance courante doit être passée en paramètre à une méthode.

class Personne
{
public String nom; Pour lever l’ambiguïté sur le mot « nom »
Personne (String nom) et déterminer si c’est le nom du paramètre
{ ou de l’attribut
this.nom=nom;
}
}

public MaClasse(int a, int b) {...}


Appelle le constructeur
public MaClasse (int c) MaClasse(int a, int b)
{
this(c,0);
}
public MaClasse () Appelle le constructeur
{ MaClasse(int c)
this(10);
}

79

VI. Champs et méthodes de classe


1. Champs de classe (variable de classe)
Considérons la définition simpliste suivante:
class ClasseTest {
int n;
double y;
}
Chaque objet de type ClasseTest possède ses propres champs n et y.
Par exemple avec les déclarations
ClasseTest objA1=new ClasseTest(), objA2= new ClasseTest();

objA1.n et objA2.n désignent deux données différentes.


objA1.y et objA2.y désignent aussi deux données différents.

objA1.n objA2.n
objA1.y objA2.y
objet objA1 objet objA2 80

40
08/04/2020

Certains attributs peuvent être partagés par toutes les


instances d’une classe. C’est-à-dire ils peuvent être définis
indépendamment des instances (objets):
Par exemple le nombre d’étudiants = le nombre d’objets
étudiant créés.

Ces attributs sont nommés champs de classe ou variables de


classe. Ils sont comparables aux «variables globales ».

Ces variables n’existent qu’en un seul exemplaire,


quel que soit le nombre d’objets de la classe. Elles sont
définies comme les attributs mais précédés du mot-clé static.
Les attributs statiques ne sont pas instanciés dans les objets

81

Considérons la classe:
class ClasseTest {
static int n; // la valeur de n est partagée par toutes les instances
double y;
}
Soient objA1 et objA2 deux instances différentes.
ClasseTest objA1=new ClasseTest(), objA2=new ClasseTest();
objA1 et objA2 partagent la même variable n:
objA1.n et objA2.n désignent la même donnée.
La valeur de l’attribut n est indépendante de l’instance (objet).
- Pour y accéder, on utilise le nom de la classe
ClasseTest.n // champs (statique) de la classe ClasseTest

objA1.n ou ClasseTest.n objA2.n ou ClasseTest.n


objA1.y objA2.y
82
objet objA1 objet objA2

41
08/04/2020

Champs de classe (variable de classe)

83

Exemple1:
class ClasseTest {
int n;
double y;
}
public class MethodeStatic{
public static void main(String[] args) {
ClasseTest objA1=new ClasseTest();
objA1.n +=4; // objA1.n vaut 4 puisque n vaut 0
// initialisation par défaut des attributs
ClasseTest objA2=new ClasseTest();
// objA2.n = ?
// objA2.n vaut 0 : initialisation par défauts des attributs.
}
}

84

42
08/04/2020

Exemple2:
class ClasseTest {
static int n; // la valeur de n est partagée par toutes les instances
float y;
}
public class MethodeStatic{
public static void main(String[] args) {
ClasseTest objA1=new ClasseTest();
objA1.n +=4; // objA1.n vaut 4
// équivalent à ClasseTest.n=4;
ClasseTest objA2=new ClasseTest();
// objA2.n = ?
// objA2.n vaut 4 car champs statique .
}
}
85

Les attributs d’instance

Variable d’instance:
Etudiant [class]
Chaque instance de la classe possède
ses propres valeurs des variables.

Class Etudiant{
String nom;
etud1 [instance1] etud2 [instance2]
Etudiant(String nom){ nom nom
this.nom=nom; Ahmed Sara
}
}

Etudiant etud1 = new Etudiant (“Ahmed");


Etudiant etud2 = new Etudiant (“Sara");

43
08/04/2020

Les attributs static


Variable de classe:
 n'appartient pas à une instance particulière, elle appartient à la classe
 est partagée par toutes les instances de la classe
Etudiant [class]
Class Etudiant{ nbrEtudiants
String nom;
0
3
2
1
static int nbrEtudiants;

Etudiant(String nom){
this.nom=nom; etud1 [instance1]
nbrEtudiants++; nom etud3 [instance3]
Ahmed
} nom
} Fatima

Etudiant etud1 = new Etudiant (“Ahmed"); etud2 [instance2]


Etudiant etud2 = new Etudiant (“Sara"); nom
Sara
Etudiant etud3 = new Etudiant (“Fatima");

Un attribut statique d’une classe est un attribut qui appartient à la classe et qui est partagé par
tous les objets de cette classe.
Un attribut statique est considéré comme étant une variable globale à tous les objets.
Les attributs statiques ne sont pas instanciés dans les objets.

Les attibuts static

Variable de classe:
On invoque les variables static avec le nom de la classe

class Etudiant{
String nom;
class Test{
static int nbrEtudiants;
public static void main(String[] args){
Etudiant(String nom){
System.out.println(Etudiant.nbrEtudiants);
this.nom=nom;
nbrEtudiants++;
}
}
}
}

44
08/04/2020

Qu’affiche le programme Java suivant après son exécution ?


Au début lors de la création des 3 objets chacun
des champs x vaut -58 et des champs y vaut 20,
l'affichage par System.out.println(...) donne les
résultats suivants qui démontrent le partage de
la variable x par tous les objets.

Après exécution :
obj1.x = 101
obj1.y = 100
obj2.x = 101
obj2.y = 20
obj3.x = 101
obj3.y = 20
AppliStatic.x = 99

Une variable de classe (précédée du mot clef static) est


partagée par tous les objets de la même classe.
89

Qu’affiche le programme Java suivant après son exécution ?


Au début lors de la création des 3 objets chacun
des champs x vaut -58 et des champs y vaut 20,
l'affichage par System.out.println(...) donne les
résultats suivants qui démontrent le partage de
la variable x par tous les objets.

Après exécution :
obj1.x = 101
obj1.y = 100
obj2.x = 101
obj2.y = 20
obj3.x = 101
obj3.y = 20
AppliStatic.x = 99

Une variable de classe (précédée du mot clef static) est


partagée par tous les objets de la même classe.
90

45
08/04/2020

Variables de classe

Variable de classe
public class UneClasse
{
public static int compteur = 0;
public UneClasse () Utilisation de la variable de classe
{
compteur++; compteur dans le constructeur de
} la classe
}
class AutreClasse
{
public void uneMethode() Utilisation de la variable de classe
{ compteur dans une autre classe
int i = UneClasse.compteur;
}
}

91

Exemple 1 d’utilisation d’un champ de classe

class Obj
{ private static long nb=0 ;
public Obj()
{ System.out.print ("++creation objet Obj ; ") ;
nb ++ ;
System.out.println ("il y en a maintenant " + nb) ;
}
}
public class TstObj
{ public static void main (String args[])
Exécution
{ Obj a ;
System.out.println ("Main 1") ; Main 1
a = new Obj() ; ++ creation objet Obj ; il y en a maintenant 1
System.out.println ("Main 2") ; Main 2
Obj b ;
Exécution ???
Main 3
System.out.println ("Main 3") ; ++ creation objet Obj ; il y en a maintenant 2
b = new Obj() ; ++ creation objet Obj ; il y en a maintenant 3
Obj c = new Obj() ;
Main 4
System.out.println ("Main 4") ;
}
} 92

46
08/04/2020

Exemple 1 d’utilisation d’un champ de classe

class Obj
{ private static long nb=0 ;
public Obj()
{ System.out.print ("++creation objet Obj ; ") ;
nb ++ ;
System.out.println ("il y en a maintenant " + nb) ;
}
}
public class TstObj
{ public static void main (String args[])
Exécution
{ Obj a ;
System.out.println ("Main 1") ; Main 1
a = new Obj() ; ++ creation objet Obj ; il y en a maintenant 1
System.out.println ("Main 2") ; Main 2
Obj b ;
Exécution ???
Main 3
System.out.println ("Main 3") ; ++ creation objet Obj ; il y en a maintenant 2
b = new Obj() ; ++ creation objet Obj ; il y en a maintenant 3
Obj c = new Obj() ;
Main 4
System.out.println ("Main 4") ;
}
} 93

2. Méthodes de classe/statique
 Ce sont des méthodes qui ont un rôle indépendant d’un objet
spécifique. Elles exécutent une action indépendante d’une
instance particulière de la classe.
 La déclaration d’une méthode de classe se fait à l’aide du
mot clé static.
 L’appel d’une telle méthode ne nécessite que le nom de la
classe correspondante.

 Une méthode de classe ne peut utiliser que des variables de


classe et jamais des variables d'instance. Par contre, une méthode
d'instance peut accéder aux deux catégories de variables.
 Une méthode de classe ne peut avoir la même signature
qu’une méthode d’instance
94

47
08/04/2020

Exemple
class Test{

private static int n; // attribut de classe
private float x; // attribut d’instance
public static void f() { // méthode de classe
… //ici, on ne peut pas accéder au champs x car champs d’instance
… // ici on peut accéder au champs statique n
}
………
Test obj=new Test() ;
Test.f() ; // appel la méthode de classe f() de la classe Test
obj.f() ; // reste autorisé, mais déconseillé

95

Les méthodes de classe ou static

class MaClassMath{ Utilisation:


L'appel à une méthode statique se fait en
static int min(int a , int b){ utilisant le nom de la classe.
if(a<b){
return a; class Test {
}else{ public static void main ( String [] args ){
return b; int x = MaClassMath.min (21 , 4);
} }
} }
}

Puisque les méthodes static appartiennent à la classe, elles


ne peuvent en aucun cas accéder aux variables d'instances
qui appartiennent aux instances de la classe.

48
08/04/2020

Exemple d’utilisation d’une méthode de classe


class ClObj
{ private static long nb=0 ;
public ClObj()
{ System.out.print ("++ creation objet Obj ; ") ;
nb ++ ; Exécution
System.out.println ("il y en a maintenant " + nb) ;
} Main 1 : nb objets = 0
public static long nbObj () ++ creation objet Obj ; il y en a maintenant 1
{ return nb ; Main 2 : nb objets = 1
} Exécution
Main 3 : nb objets =1
} ++ creation objet Obj ; il y en a maintenant 2
public class TstClObj2 ++ creation objet Obj ; il y en a maintenant 3
{ public static void main (String args[]) Main 4 : nb objets = 3
{ ClObj a ;
System.out.println ("Main 1 : nb objets = " + ClObj.nbObj() ) ;
a = new ClObj() ;
System.out.println ("Main 2 : nb objets = " + ClObj.nbObj() ) ;
ClObj b ;
System.out.println ("Main 3 : nb objets = " + ClObj.nbObj() ) ;
b = new ClObj() ;
ClObj c = new ClObj() ;
System.out.println ("Main 4 : nb objets = " + ClObj.nbObj() ) ;
}
} 97

Exemple d’utilisation d’une méthode de classe


class ClObj
{ private static long nb=0 ;
public ClObj()
{ System.out.print ("++ creation objet Obj ; ") ;
nb ++ ; Exécution
System.out.println ("il y en a maintenant " + nb) ;
} Main 1 : nb objets = 0
public static long nbObj () ++ creation objet Obj ; il y en a maintenant 1
{ return nb ; Main 2 : nb objets = 1
} Exécution
Main 3 : nb objets =1
} ++ creation objet Obj ; il y en a maintenant 2
public class TstClObj2 ++ creation objet Obj ; il y en a maintenant 3
{ public static void main (String args[]) Main 4 : nb objets = 3
{ ClObj a ;
System.out.println ("Main 1 : nb objets = " + ClObj.nbObj() ) ;
a = new ClObj() ;
System.out.println ("Main 2 : nb objets = " + ClObj.nbObj() ) ;
ClObj b ;
System.out.println ("Main 3 : nb objets = " + ClObj.nbObj() ) ;
b = new ClObj() ;
ClObj c = new ClObj() ;
System.out.println ("Main 4 : nb objets = " + ClObj.nbObj() ) ;
}
} 98

49
08/04/2020

VII. Le mot clé final


L’attribut final indique que la valeur de la variable ne peut être
modifiée : on pourra lui donner une valeur une seule fois dans
le programme.

Variable d’instance final


• Une variable d’instance final est une constante pour chaque
objet.

• Une variable d'instance final peut ne pas être initialisée à sa


déclaration mais elle doit avoir une valeur à la sortie de tous
les constructeurs

99

Constantes de classe
• Usage
– Ce sont des variables de classes déclarées avec le mot-clé final
– Ce sont des constantes liées à une classe
– Elles sont écrites en MAJUSCULES
– Pour y accéder, il faut utiliser non pas un identificateur d’objet
mais le nom de la classe
Exemple:
public class Galerie {
public static final int MASSE_MAX = 150;
}
if (maVoiture.getPoidsLimite() <= Galerie.MASSE_MAX)
{...}

100

50
08/04/2020

Le mot réservé final

 Une classe est déclarée final lorsqu'on ne souhaite pas


qu'elle puisse être sous-classée. Par conséquent, ses
méthodes ne peuvent pas être redéfinies.

 Une méthode est déclarée final lorsqu'on ne souhaite


pas qu'elle puisse être redéfinie dans les classes
dérivées.

 Une variable déclarée final est une constante.

101

Classe java type


Une classe java types contient trois grands types de membres :

public class Rectangle {


// ( 1 ) A ttributs
private double L , l ;
// ( 2 ) Constructeurs
public Rectangle (double L , double l ) { . . . }
// ( 3 ) Méthodes
public double surface (double L , double l) { . . . }
}
Remarque
Les constructeurs sont des méthodes particulières, vous devez
toujours déclarer les constructeurs après les attributs et
avant les autres méthodes.
102

51