Vous êtes sur la page 1sur 11

POO en Javammm

Pr: Ismaili Alaoui El Mehdi A.U: 2020/2021

Programmation orientée objet en Java


Chapitre 3: Concepts de base de la POO

1 Qu’est-ce qu’un type ?


Dans un langage de programmation, le type d’une donnée détermine :
ç L’ensemble des valeurs admissibles;
ç Le nombre d’octets à réserver en mémoire.
ç L’ensemble des opérateurs qui peuvent y être appliqués.
En plus des types primitifs (char, int, double, float, ...), il est possible en Java de créer ses propres
types. On appelle type construit un type non primitif (classe), c’est-‘a-dire composé de types
primitifs. Certains types construits sont fournis dans les bibliothèques du langage. Si ceux-là ne
vosu satisfont pas, vous avez la possibilité de créer vos propres types.

2 Création d’une classe


Nous verrons d’abord comment créer une classe, c’est-à-dire écrire les instructions permet-
tant d’en définir le contenu (champs + méthodes). Puis nous verrons comment utiliser effecti-
vement cette classe au sein d’un programme.
Nous vous proposons de définir une classe nommée Point dans R2 , destinée à manipuler les
points d’un plan. Un type construit s’appelle une classe. On le définit comme suit :

public class Point{


. // instructions de définition des champs et des méthodes de la classe
. }

Nous reviendrons un peu plus loin sur le rôle exact de public.

p Convention: Pour nommer une classe, vous devez respecter les règles suivantes :
à Le nom doit commencer par une majuscule.
Exp: Point, Sphere, ...
2

à Quand une classe est composée de plusieurs mots, tous les mots commencent par
une lettre majuscule.
Exp: ProgrammePrincipal, TestPoint, ...

Voyons maintenant comment définir le contenu de notre classe, en distinguant les champs
des méthodes.

2. 1 Définition des champs


Nous supposerons ici qu’une variable de type Point sera représentée par deux champs (at-
tributs), une abscisse et une ordonnée. Le type Point se compose donc à partir de deux types
entièrs.

public class Point{public int x,y;}

2. 2 Définition des méthodes


Nous souhaiterions définir un ensemble d’opérations sur les attributs. Nous allons pour ce
faire nous servir de méthodes. Voici un exemple de la classe Point ci-dessus à laquelle est
ajoutée les trois méthodes suivantes :
— initialiser pour attribuer des valeurs aux coordonnées d’un point.
— deplacer pour modifier les coordonnées d’un point.
— afficher pour afficher les coordonnées du point.
Voici la définition complète de notre classe Point :

public class Point{


. public int x,y;
. void initialiser (int x0, int y0){
. x = x0 ;
. y = y0 ;
. }
. void deplacer (int dx, int dy){
. x += dx ;
. y += dy ;
. }
. void afficher (){
. System.out.println ("Je suis en " + x + " " + y) ;
3 Mise en œuvre d’un programme comportant plusieurs classes 3

. }
. }

Une fois définie cette classe, le type Point est un type comme les autres, il devient donc
possible d’éecrire
Point p1,p2;
Cette instruction déclare deux variables p1 et p2 de type Point, ces variables s’appellent des
objets. Une classe permet d’instancier plusieurs objets.

2. 3 Surcharge de méthodes
La surcharge ou surdéfinition est la possibilité de créer dans une classe plusieurs méthodes
qui portent le même nom mais avec différents paramètres et/ou valeurs de retour. Le compilateur
Java décide de la méthode à appeler en regardant la valeur de retour et les paramètres.

p Exemple:
class Point{
. public int x,y;
. ...
. void deplacer (int dx) { x += dx; }
. void deplacer (int dx, int dy) { x += dx; y += dy; }
. void deplacer (double dx, double dy) { x += dx; y += dy; }
. ...
}

3 Mise en œuvre d’un programme comportant plusieurs classes


Java n’est pas tout à fait aussi strict. Il vous impose seulement de respecter les contraintes
suivantes :
— un fichier source peut contenir plusieurs classes mais une seule doit être publique ;
— la classe contenant la méthode main doit obligatoirement être publique, afin que la ma-
chine virtuelle y ait accès ;
— le fichier source doit être enregistré avec l’extension .java et porter le même nom que la
classe publique qui contient main()(Exp. ProgrammePrincipal.java).

p Exemple:
public class ProgrammePrincipal {
4

. public static void main(String args[]) {...}


}
class Test1 {...}
class Test2 {...}

4 La notion de constructeur
Vous vous demandez peut-être comment on fait pour créer une instance à partir d’une
classe ? C’est très simple. Il suffit, pour cela, de faire appel à un constructeur.
Chaque classe a une méthode spéciale appelée constructeur, qui porte toujours le même nom
que la classe et ne peut pas préciser de valeur de retour (c’est l’objet créé qui est renvoyé). Il
peut disposer d’un nombre quelconque d’arguments (éventuellement aucun).

p Remarque:
Par essence, un constructeur ne fournit aucune valeur. Dans son en-tête, aucun type ne
doit figurer devant son nom. Même la présence (logique) de void est une erreur :
class Point{
. .....
. void Point (){ // erreur de compilation : void interdit ici
. .....
. }
}

Considérons la classe Point et transformons simplement la méthode initialiser en un construc-


teur en la nommant Point. La définition de notre nouvelle classe se présente alors ainsi :

public class Point{


. public int x,y;
. Point (int x0, int y0){
. x = x0 ;
. y = y0 ;
. }
. void deplace (int dx, int dy){
. x += dx ;
. y += dy ;
. }
4 La notion de constructeur 5

. void afficher (){


. System.out.println ("Je suis en " + x + " " + y) ;
. }
. }

4. 1 Surcharge de constructeurs
Le langage Java permet aussi la définition de plusieurs constructeurs, à l’intérieur d’une
même classe, du fait que la construction des objets peut se réaliser de différentes façons. Lors-
qu’il existe plusieurs constructeurs, on dit que le constructeur est surchargé.
Pour l’utilisateur de la classe, il peut être pratique de disposer de plusieurs constructeurs afin
qu’il puisse choisir les valeurs d’initialisation du nouvel objet. En effet, les constructeurs sont
utilisés pour initialiser correctement les données d’un objet au moment de la création de l’objet
en mémoire.
Par exemple pour pouvoir créer un point à partir de son abscisse, nous définissons le construc-
teur suivant:

Point(int x0){ x=x0;}

On pourrait définir un autre constructeur de la manière suivante:

Point(int x0, int y0){ x=x0; y=y0; }

4. 2 Création d’un objet


À l’intérieur d’une méthode quelconque, une déclaration telle que : Point a ;
est tout à fait correcte. Cependant, contrairement à la déclaration d’une variable d’un type pri-
mitif (comme int n ;), elle ne réserve pas d’emplacement pour un objet de type Point, mais
seulement un emplacement pour une référence à un objet de type Point.
La seule manière de déclarer et créer un objet est d’utiliser l’opérateur new avec l’un des
constructeurs de la classe:

NomMaClasse monObjet = new Constructeur(arguments);

p Exemple:
Point a = new Point (1);
Point b = new Point (2,3);
6

Pour déterminer quel constructeur doit être utilisé, l’interpréteur Java regarde, lors de son
appel, la liste des paramètres définis dans chaque constructeur.

p Conseil: Ne pas initialiser les variables à l’extérieur du constructeur.

4. 3 Constructeur par défaut


Si une classe ne déclare pas de constructeur, un constructeur par défaut sans arguments sera
automatiquement créé par le compilateur Java (toute classe posséde au moins un constructeur).
Dès qu’un objet est créé, et avant l’appel du constructeur, ses champs sont initialisés à une
valeur par défaut "nulle" ainsi définie :

Type du champ Valeur par défaut


boolean false
char caractère de code nul (’\0’)
entier (byte, short, int, long) 0
flottant (float, double) 0.0
objet null

TABLE 1 – Initialisation par défaut des champs d’un objet

p Exemple:
public class A {
int x; double y;
char c;
public class A { boolean t;
int x; double y; String ch;
char c; ⇔ public A() { x=0; y=0.0;
boolean t; c=’\0’;
String ch; t=false;
} ch=null;
}
}

Dès qu’il y a création d’un constructeur, celui-ci écrase d’office le constructeur par défaut.
Vous ne pouvez donc plus créer un code en faisant un appel explicite à ce constructeur là car il
n’existe plus, comme le montre cet exemple :
5 Accès aux membres d’une classe 7

p Exemple:
class Point {
. public int x, y ;
. public Point ( int x0 , int y0) {
. x = x0 ;
. y = y0 ;
. }
}
public class TestPoint ( ) {
. public static void main ( String args[]) {
. Point a = new Point() ; // erreur
. Point b = new Point(3,5) ; // ok
. }
}

5 Accès aux membres d’une classe


Pour accéder aux membres, il faut d’abord créer une instance de la classe puis accéder aux
membres avec l’opérateur "."
On accède aux méthodes et aux variables de la classe comme suit:

nomObjet.méthode(args)
. nomObjet.variable

p Exemple:
class Point{
. public int x,y;
. Point(int x0,int y0) {x=x0; y=y0;}
. void deplacer(int dx, int dy) {x += dx; y += dy ;}
. }
public class TestPoint {
. public static void main(String args[]) {
. Point a = new Point(3,4);//crée un objet a.
. a.x=2;//affecte 2 à la variable x de l’objet a.
. a.y=6;// affecte 6 à la variable y de l’objet a.
. a.deplacer(2,2); // affecte 2 aux variables dx et dy.
8

. }
}

6 Affectation d’objets
Nous avons étudié le rôle de l’opérateur d’affectation sur des variables d’un type primitif.
Par ailleurs, nous venons de voir qu’il existe des variables de type classe, destinées à contenir
des références sur des objets. Comme on peut s’y attendre, ces variables pourront être soumises
à des affectations. Mais celles-ci portent sur les références et non sur les objets eux-mêmes, ce
qui modifie quelque peu la sémantique (signification) de l’affectation. C’est ce que nous allons
examiner à partir de un exemple.
Supposons que nous disposions d’une classe Point possédant un constructeur à deux arguments
entiers et considérons ces instructions :
. Point a, b ;
. .....
. a = new Point (3, 5) ;
. b = new Point (2, 0) ;
Après leur exécution, on aboutit à cette situation :

Exécutons maintenant l’affectation : a = b ;


Celle-ci recopie simplement dans a la référence contenue dans b, ce qui nous conduit à :
7 Le mot clé "this" 9

Dorénavant, a et b désignent le même objet, et non pas deux objets de même valeur.

p Exemple:
Combien d’instances de la classe Point crée le code suivant?
Point p1,p2,p3;
p1=new Point(1,2);
Point p4=p1;
Point p5=new Point(3,4);
å Il y a deux instances de Point crées par les deux new, la première est référencée par p1
et p4, la deuxième par p5.

7 Le mot clé "this"


Le mot clé this référence l’instance courante de la classe sur laquelle s’applique la méthode.
Il est permis à une variable locale de porter le même nom qu’une variable d’instance ⇒ permet
d’éviter les conflits de nom.
Pour appeler explicitement un unique constructeur à partir d’un autre il faut utiliser le mot cle
this(args). Cet appel ne peut être que la première instruction de ce constructeur.

p Exemple:
class Point {
. int x, y;
. Point(int x, int y){
. this.x=x;
. this.y=y;
. }
. Point(int x) {
. this(1,2);
. ...
. }
. Point() {
. this(4);
. ...
. }
}
10

p Exemple:

å Q: Ce programme peut-il être compilé? Si oui, qu’affiche-t-il? Si non, expliquez pour-


quoi, corrigez-le et indiquez l’affichage exact produit par son exécution.
.
.
1 class A { 13 public class TestConstructeur {
2 int x; 14 public static void main(String[] args){
3 A(){x=3;} 15 A o=new A(2020,3) ;
4 A(int x){ 16 System.out.println("Année:"+o.x);
5 this.x=this.x+x; 17 }
6 this(); 18}
7 }
8 A(int x, int y){
9 this. x= this.x-y;
10 this(x);
11 }
12 }

å R: Non, dans les constructeurs l’appel au constructeur doit être effectué en premier.
Après la correction le programme affiche Année: 2020.

8 Membres statiques
La déclaration d’un membre statique est précédée du modifieur static. Un membre sta-
tique est lié à la classe et non à un objet de la classe. Autrement dit, le membre est partagé
par tout les objets de la classe (v membre globale).
Pour accéder à un membre statique, il faut le précéder du nom de sa classe.

NomDeLaClasse.nomDeLaVariable
. NomDeLaClasse.nomDeLaMethode(liste de paramètres)

p Exemple:
Math.PI, Math.cos(x), Math.sin(x) , ...
⇒ La classe Math contient un membre de classe dont le nom est PI, cos(), sin(x), ...

Une méthode statique ne peut utiliser que des membres statiques à la classe, afin de garantir
l’utilisation exclusive de données statiques.
8 Membres statiques 11

p Exemple:
class Addition { public class TstMembreStatique {
static int c ; public static void main(String args[]) {
int a,b ; Addition obj1=new Addition(10,10);
Addition(int x, int y) {a=x ; b=y; } Addition.fctConst(1);
static void fctConst(int cte){ System.out.println(obj1.somme());
c=cte; Addition.c= 2;
a=cte;//Erreur car a n’est pas statique System.out.println(obj1.somme());
} }
int somme(){ return a+b+c;} }
}

p Remarque:
Une classe peut ne contenir que des membres static. Dans ce cas elle ne sert pas à créer
des objets !!!

Vous aimerez peut-être aussi