Embed Size (px)
Citation preview
POO en JavaCh. III
Les Classes et les Objets
Rappels: Concepts de l’orienté objet avec JavaI. Création d’une classeII. Création et manipulation d’Objets
1. Introduction2. Etapes de création des Objets
2.1. Déclaration d’un objet:2.2. Création d’un objet2.3. Initialisation par défaut
III. Définition des méthodesIV. 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 (accessibilté)IV. Méthodes d’accès aux valeurs des variables depuis l’extérieur V. Autoréférences: emploi de thisVI. Champs et méthodes de classe
1. Champs de classe (variable de classe)2. Méthodes de classe
VII. Le mot clé final
PLAN
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.
Employécode : intnom : StringnbEmployés : static int
Trois attributs de la classe Employé3
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 créer les objets de la classe en les initialisant.
2) Méthodes :
4
Rappels: Caractéristiques d’une classe
EmployéAttributs :
code : intnom : StringnbEmployés : static int
Constructeur :Employé()
Méthodes :afficheCode() : voidafficheNom() : void
Exemple:afficheCode() et afficheNom() sont deux méthodes qui affichent respectivement le code et le nom d’un employé
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
*/}
5
Exemple: Rectangle est une classe utilisée pour créer des objetsreprésentant des rectangles particuliers.
• Elle regroupe 4 données de type réel qui caractérisent le rectangle:longueur, largeur et origine (x,y) (la position en abscisse et enordonnée de son origine).• On suppose qu’on effectue les opérations de déplacement et de calculde la surface du rectangle.• Les symboles + et – sont les spécificateurs d’accès (voir plus loin)
Exemple (notation UML (Unified Modeling Language)
Rectangle- longueur- largeur-x-y
+ déplacer(int,int)+ calculSurface()
Nom de la classe
Description des attributs (champs)
Description des méthodes (comportements)
- : private# : protected+ : public$ (ou souligné) : static
6
Code java de la classe Rectangle
Nom de la classe
Attributs
Méthodes
class Rectangle {int longueur;int largeur;int x;int y;void deplace(int dx, int dy) {
x = x+ dx;y = y + dy;
}int surface() {
return longueur * largeur;}
}
7
Classe : déclaration.En Java, pour déclarer une classe on utilise le mot-clé class suividu nom de la classe.
public class Rectangle {...
}
Règles
1. La première lettre du nom d’une classe doit toujours êtreune lettre Majuscule (ex : Chat).
2. Mélange de minuscule, majuscule avec la première lettre dechaque mot en majuscule (ex : ChatGris).
3. Une classe se trouve dans un fichier portant son nomsuivi de l’extention .java (ex : ChatGris.java)
8
Classe : écriture
Règles
1. un fichier source peut contenir plusieurs classes mais une seule doit être publique2. la classe contenant la méthode main doit obligatoirement être publique, afin que la machine virtuelle y ait accès3. une classe n’ayant aucun attribut d’accès reste accessible à toutes les classes du même paquetage donc, a fortiori, du même fichier source
Cas de plusieurs classes dans un même fichier source
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 :
9
II. Création et manipulation d’Objets1. 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 sonespace 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 estréférencé par une variable ayant un état (ou valeur).
• On parle indifféremment d’instance, de référence ou d’objet
10
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
« instance»
rectangleR1- longueur =10- largeur =2- x=0- y=0
Nom de la classe
Relation d’instanciation
Nom de l’objet ou de l’instance
Valeurs des attributs qui caractérisentl’objet rectangleR1
11
• Les valeurs des attributs peuvent être différentes.
Chaque instance d’une classe possède ses propres valeurs pour chaque attribut
(chaque objet a son propre état)
Rectangle
« instance»
rectangleR1- longueur =10- largeur =2- x=0- y=0
rectangleR2- longueur =5- largeur =7- x=1- y=2
rectangleR3- longueur =3- largeur =5- x=2- y=0
12
• Les valeurs des attributs peuvent être différents.
Chaque instance d’une classe possède ses propres valeurs pour chaque attribut
Voiture
« instance»
VW- Marque: Polo- Coleur: Rouge- Vitesse: 5- Porte: 3
BM Honda
- Marque: X5- Coleur: Blanche- Vitesse: 6- Porte: 5
- Marque: Civic- Coleur: Noire- Vitesse: 5- Porte: 5
(chaque objet a son propre état)
13
2. Etapes de création des ObjetsContrairement 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 est une variable comme lesautres. Il faut notamment qu’il soit déclaré avec son type.
Syntaxe: NomDeClasse objetId;NomDeClasse objetId1, objetId2,….;
- NomDeClasse est la nom de la classe.- Déclare objetId1, objetId2, … comme variables de type NomDeClasse
14
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émoirepour l’objet, mais seulement un emplacement pour une référence à cet objet
les objets sont manipulés avec des références
15
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 quiréférencera un objet de la classe ClasseTest.
- Aucun objet n’est créé: un objet seulement déclaré vaut « null ».
objA null
16
2.2. Création d’un objet
Après la déclaration d’une variable, on doit faire la création (etallocation) 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 enfaisant 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 pourstocker un objet de type NomDeClasse.
17
Exempleclass ClasseTest {
/* Corps de la classe ClasseTest */}
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.
ClassTest objA ; /* déclare une référence sur l’objet objA */objA= new ClasseTest(); /* crée un emplacement pour stocker l’objet objA */
18
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();
}}
19
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éé
20
rectangleR1 = new Rectangle();Cette instruction permet la création de l’objet rectangleR1
2.3. Initialisation par défautLa création d’un objet entraîne toujours une initialisation pardéfaut de tous les attributs de l’objet même si on ne lesinitialise 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 |-----------------------------------------------------------------|
21
Attention:
Cette garantie d’initialisation par défaut ne s’applique pas aux variables locales
(variables déclarées dans un bloc, par exemplevariables locales d’une méthode)
(voir plus loin)
22
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 corpsde la méthode
Syntaxe: typeRetour nomMethode ( «Liste des paramètres » ) {
/*corps de la méthode qui peut contenir l’instruction
*/}
23
- 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’onsouhaite passer à la méthode lors de son appel.
- typeRetour : c’est le type de la valeur qui sera retournée parla méthode après son appel. Si la méthode ne fournit aucunrésultat, alors typeRetour est remplacé par le mot clé void.
Remarque:La valeur retournée par la fonction est spécifiée dans le corpsde la méthode par l’instruction de retour:
return expression;ou
return; // (possible uniquement pour une fonction de type void)
24
- En Java, le type de la valeur de retour de la méthode ne fait paspartie de sa signature (au contraire de la définition habituelled'une signature)
Passage des paramètresLe mode de passage des paramètres dans les méthodes dépend dela 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 laréférence), mais le contenu de l’objet référencé peut êtremodifié par la fonction (car la copie de référence pointe versle même objet…) :
25
- La signature d’une méthode est: le nom de la méthode etl’ensemble des types de ses paramètres.
Méthodes et paramètres : à retenir
exemple : public,static
type de la valeurrenvoyée ou void
couples d'un type et d'unidentificateur séparés par des « , »
<modificateur> <type-retour> <nom> (<liste-param>) {<bloc>}
public double add (double number1, double number2)
{return (number1 +number2);
}Définition d’une méthode en Java
Notre méthoderetourne ici unevaleur
26
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 a ffloat n ; // interdit en Java.....}void g (){ double x ; // variable locale à g, indépendante de x locale à f.....}
Remarques importantes
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.
27
IV. Accès aux membres d’un objet
1. Accès aux attributs(données membres)Considérons la classe ClassTest suivante:
class ClasseTest {double x;boolean b;
}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();
28
Maintenant l’objet dont la référence objA existe.Pour accéder à une donnée membre on indique le nom de laréférence à l’objet suivi par un point suivi par le nom dumembre dans l’objet de la manière suivante:
nomObjet = nom de la référence à l’objetnomAttribut =nom de la donnée membre (attribut).
29
nomObjet.nomAttibut
Pour les objets objA et objBde la classe ClassTestqui 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.
Exemple:
ClasseTest objA = new ClasseTest();
class ClasseTest {double x;boolean b;
}
ClasseTest objB = new ClasseTest();
30
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 laméthode et de sa liste d’arguments:
nomObjet.nomMethode(arg1, ….)
oùnomObjet : nom de la référence à l’objetnomMethode : nom de la méthode.
31
Exemple 1: soit f() une méthode qui prend un paramètre detype double et qui retourne une valeur de type int.
class ClasseTest {float x;int i;boolean b;
}ClasseTest objA = new ClasseTest(); // créer un objet objA
int f(double x) {int n;// corps de la fonction f()return n;
}
int j = objA.f(5.3); // affecte à j la valeur retournée par f()
32
Exemple 2: Considérons la classe Rectangle dotée de la méthodeinitialise qui permet d’affecter des valeurs à l’origine (aux attributs x et y).
public class Rectangle{int longueur, largeur;int x,y;
Rectangle r1;r1.longueur=4; r1.largeur=2;
// Erreur car l’objet n’est pas encore créé. Il faut tout d’abord le créer}
}
void initialiseOrigine(int x0, int y0) {x=x0; y=y0;
}public static void main (String args[]) {
r1. initialiseOrigine(0,0); // affecte 0 aux attributs x et y
r1=new Rectangle ();
33
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;}
r1. initialiseOrigine(0,0);}
}
public static void main (String args[]) {
r1.longueur=4; r1.largeur=2;Rectangle r1=new Rectangle ();
34
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 membre de l’objet estappelé encapsulation.
• Le contrôle d'accès aux membre de l’objet est appelé cacherl'implémentation: les membres publiques sont vus de l'extérieurmais les membres privés sont cachés.
• L'encapsulation est un mécanisme consistant à rassembler lesdonnées et les méthodes au sein d'une structure en cachantl'implémentation de l'objet, c'est-à-dire en empêchant l'accès auxdonnées par un autre moyen que les services proposés.
35
• Possibilité d’accéder aux attributs d’une classe Java maisceci n’est pas recommandé car contraire au principed’encapsulation: les données (attributs) doivent êtreprotégés.
• Accessibles pour l’extérieur par des méthodes particulières(sélecteurs)
• Plusieurs niveaux de visibilité peuvent être définis enprécédant, la déclaration d’un attribut, d’une méthode oud’un constructeur, par un modificateur : private, public ouprotected.
36
Spécificateurs d’accès:L'encapsulation permet de définir 3 niveaux de visibilité des éléments dela classe.Ces 3 niveaux de visibilité (public, private et protected) définissent lesdroits 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 auxmembres private.
• Accès par défaut: lorsqu’aucun de ces spécificateurs n’est mentionné.
37
Encapsulation "usuelle": les attributs sont privés, et les méthodes sont publiques.
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
38
• Permet de distinguer les services offerts (interface) de l’implémentation
• L’encapsulation des classes Java est définie au niveau du package
• L’encapsulation agit au niveau des classes et non des objets – Un attribut « private » dans un objet sera accessible depuis
un autre objet de la même classe• Pour une bonne encapsulation, il est préférable de définir les
attributs comme « private »• On définit alors des méthodes «publiques » (accesseurs)
permettant de lire et/ou de modifier les attributs
Visibilité - Encapsulation
39
Exemple 1: modification depuis l’extérieur d’un champs privateclass ClasseTest {
public int x;
public void initialise (int i, int j){x=i;
}}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 3objA.x=2; // x vaut maintenant 2. On peut accéder à x car il est publicobjA.y=3;// ne compile pas car accès à un attribut y privé de la classe ClasseTest// depuis l’extérieur (classe TestA)
}}
private int y;
y=j; // accès à l’attribut private y depuis l’intérieure OK
40
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érieure 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 3System.out.println(" x= "+objA.x); // affiche x = 1 puisque x public, on peut y accéderSystem.out.println(" y= "+objA.y);
}}
41
// ne compile pas car accès à un attribut y privé de la classe ClasseTest// depuis l’extérieur (classe TestA)
Exemple 2: affichage depuis l’extérieur d’un champs private
42
43
Exemple 3: affichage depuis l’intérieur d’un champs private
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 MethodeStatic{
public static void main(String[] args) {Etudiant e= new Etudiant();
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 ??
}} 44
e.initialise("Mohd","Ali");
Méthodes d’accès aux valeurs des variables depuis l’extérieur
45
AccesseurGettersget()
MutateurSettersset()
Pour afficher la valeur de l’attribut nom (champs private), on définieUn accesseur (méthode getNom) qui est une méthode permettant delire, 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 MethodeStatic{
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());
}}
46
public class MethodeStatic{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());
}}
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;}
}
47
Comment peut-on modifier (depuis l’extérieur) le contenu d'un attribut privé?
Exemple:
class Etudiant {private int cne;
}
public class MethodeStatic{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)
}}
48
Pour modifier la valeur de l’attribut nom (champs private), on défineUn modificateur (mutateur) qui est une méthode permettant demodifier 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 MethodeStatic{
public static void main(String[] args) {Etudiant e= new Etudiant();e.setCNE(23541654);
}}
49
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é cetteméthode.
- Par exemple pour accéder aux attributs "masqués" par lesparamè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
}}
50
Exemple:class Etudiant {
private String nom, prenom;public initialise(String st1, String st2) {
nom = st1;prenom = st2;
}}
Comme les identificateurs st1 et st2 sont des arguments muets pourla méthode initialise(), alors on peut les noter nom et prenom quin’ont aucune relation avec les champs private nom et prenom.Dans ce cas la classe Etudiant peut s’écrire comme suit:
class Etudiant {private String nom, prenom;public initialise(String nom, String prenom){
this.nom=nom;this.prenom=prenom;
}}
51
class Personne{
public String nom;Personne (String nom)
{this.nom=nom;
}}
Pour lever l’ambiguïté sur le mot « nom »et déterminer si c’est le nom du paramètreou de l’attribut
public MaClasse(int a, int b) {...}
public MaClasse (int c){
this(c,0);}
public MaClasse (){
this(10);}
Appelle le constructeurMaClasse(int a, int b)
Appelle le constructeurMaClasse(int c)
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.
52
