Rpublique Tunisienne
Ministre de lenseignement suprieur et de la recherche scientifique
Direction gnrale des tudes technologiques
Programmation Oriente Objet
Support de cours
et sries de travaux dirigs
Par
Manel ZOGHLAMI
Assistante technologue ISET Jendouba
Anne universitaire 2011/2012
Programmation Oriente Objet
Support de cours et sries de travaux dirigs Fiche matire
Domaine de formation : Sciences et technologies
Mention : Technologie de linformatique (TI)
Parcours : Tronc Commun
Semestre : S3
Unit denseignement : Programmation oriente objet
Volume horaire : 45 heures (22,5 cours 22,5 TD)
Coefficient : 2
Objectifs du cours
Comprendre les concepts de programmation oriente objet: comprendre une
conception oriente objet en vue de la traduire en programme orient objet.
Implmenter des classes dobjets : implmenter une classe en prcisant ses
attributs et ses oprations en prcisant leurs visibilits.
Utiliser les tableaux d'objets et crire des programmes avec des objets de
diffrentes classes.
Crer des classes avec le principe dhritage : partir dune classe dj dfinie,
crer une autre classe qui hrite la premire.
Comprendre l'utilit des classes abstraites et des interfaces et les utiliser dans des
programmes Java.
Grer les exceptions dans un programme java.
Pr-requis
Programmation, algorithmique et structures de donnes
Moyens et Outils Pdagogiques
Condens du cours
Travaux dirigs.
Tableau
Explication orale
Table des matires Chapitre 1. Introduction au langage Java .....................................................................1
1. Prsentation du langage Java ..................................................................................2
2. Excution d'un programme en Java .........................................................................3
2.1. La compilation d'un code source .........................................................................4
2.2. L'excution d'un programme ...............................................................................5
2.3. Les Environnements de Dveloppement intgrs ................................................5
3. Les rgles gnrales de la syntaxe ...........................................................................5
4. Les commentaires ...................................................................................................5
5. Les variables..........................................................................................................6
5.1. Les types primitifs ..............................................................................................6
5.2. Dclaration et affectation ...................................................................................7
5.3. La conversion des types ......................................................................................7
6. Les oprateurs ........................................................................................................8
6.1. Les oprateurs arithmtiques ..............................................................................8
6.2. Les oprateurs de comparaison ...........................................................................9
6.3. Oprateurs logiques ...........................................................................................9
6.4. Oprateurs d'affectation ......................................................................................9
6.5. L'incrmentation et la dcrmentation ............................................................... 10
7. Les structures de contrle ..................................................................................... 10
7.1. Les structures conditionnelles ........................................................................... 10
7.2. Structures de contrle itratives ........................................................................ 12
8. Srie d'exercices ................................................................................................... 15
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet ............................ 18
1. Les classes ............................................................................................................ 19
1.1. Notion de classe................................................................................................ 19
1.2. Dclaration des classes ..................................................................................... 19
2. Les Objets ............................................................................................................ 22
2.1. Notion d'objet ................................................................................................... 22
2.2. La cration d'un objet ....................................................................................... 23
2.3. Les constructeurs .............................................................................................. 24
2.4. Les destructeurs ................................................................................................ 26
2.5. Utiliser un objet ................................................................................................ 26
2.6. Les rfrences et la comparaison des Objets ..................................................... 28
2.7. La rfrence this ............................................................................................... 29
2.8. Le mot cl null.................................................................................................. 30
2.9. L'operateur instanceOf ..................................................................................... 30
3. Le principe de l'encapsulation ............................................................................... 31
3.1. Les membres publiques et les membres privs .................................................. 31
3.2. Les accesseurs .................................................................................................. 31
4. Attribut d'instance et attribut de classe .................................................................. 32
5. Les mthodes ........................................................................................................ 34
5.1. Passage des paramtres ..................................................................................... 34
5.2. La surcharge des mthodes ............................................................................... 35
5.3. Mthodes de classe ........................................................................................... 36
6. Srie d'exercices ................................................................................................... 38
Chapitre 3. Tableaux et chanes de caractres .............................................................. 44
1. Les tableaux ......................................................................................................... 45
1.1. Dclaration ....................................................................................................... 45
1.2. Cration ............................................................................................................ 45
1.3. Initialisation ..................................................................................................... 45
1.4. Parcours d'un tableau ........................................................................................ 46
1.5. Tableaux deux dimensions ............................................................................ 47
2. Les chanes de caractres ...................................................................................... 48
3. Srie d'exercices ................................................................................................... 50
Chapitre 4. Association et agrgation entre les classes ................................................ 53
1. Association entre classes ...................................................................................... 54
1.1. Relation un un ................................................................................................ 54
1.2. Relation un plusieurs...................................................................................... 55
1.3. Relation plusieurs plusieurs............................................................................ 55
2. Agrgation entre classes ....................................................................................... 56
3. Problme .............................................................................................................. 57
Chapitre 5. Hritage et encapsulation ........................................................................... 63
1. Utilit et mise en uvre ........................................................................................ 64
2. Constructeur de la sous classe ............................................................................... 65
3. La redfinition des champs ................................................................................... 66
4. La redfinition des mthodes: ............................................................................... 67
5. Interdire l'hritage................................................................................................. 68
6. La classe Object.................................................................................................... 69
7. Les paquetages ..................................................................................................... 69
7.1. Utilit des paquetages ...................................................................................... 69
7.2. Importer des paquetages ................................................................................... 71
8. L'encapsulation et la visibilit des membres .......................................................... 71
9. Srie d'exercices ................................................................................................... 73
Chapitre 6. Les classes abstraites et les interfaces ....................................................... 78
1. Classes et mthodes abstraites .............................................................................. 79
1.1. Les mthodes abstraites .................................................................................... 79
1.2. Les classes abstraites ........................................................................................ 79
2. Les interfaces ....................................................................................................... 80
2.1. Dclaration des interfaces ................................................................................. 81
2.2. Implmenter les Interfaces : .............................................................................. 82
2.3. Hritage entre interfaces ................................................................................... 83
3. Srie d'exercices ................................................................................................... 83
Chapitre 7. La gestion des exceptions .......................................................................... 86
1. Prsentation des exceptions .................................................................................. 87
2. Capturer des exceptions ........................................................................................ 87
3. Le bloc finally ...................................................................................................... 89
4. Hirarchie des exceptions ..................................................................................... 89
4.1. La classe Throwable ......................................................................................... 89
4.2. Les exceptions contrles/ non contrles ......................................................... 91
5. Propagation des Exceptions .................................................................................. 91
6. Lever une Exception ............................................................................................. 94
7. Dfinir sa propre exception ................................................................................... 95
8. Srie d'exercices ................................................................................................... 95
Bibliographie ................................................................................................................. 100
Chapitre 1. Introduction au langage Java
1
Chapitre 1. Introduction au
langage Java
Objectifs
Ce chapitre s'intresse faire une prsentation gnrale du langage Java
(caractristiques et principe d'excution). Il passe ensuite prsenter la syntaxe du
langage, particulirement l'utilisation des types et des variables, les oprateurs et les
structures conditionnelles et itratives.
Pr-requis
Algorithmique et structures de donnes 1
Elments de contenu
1. Prsentation du langage Java
2. Excution d'un programme en Java
2.1. La compilation d'un code source
2.2. L'excution d'un programme
2.3. Les Environnements de Dveloppement Intgr
3. Les rgles gnrales de la syntaxe
4. Les commentaires
5. Les variables
5.1. Les types primitifs
5.2. Dclaration et affectation
5.3. La conversion des types
6. Les oprateurs
6.1. Les oprateurs arithmtiques
6.2. Les oprateurs de comparaison
6.3. Oprateurs logiques
6.4. Oprateurs d'affectation
6.5. L'incrmentation et la dcrmentation
7. Les structures de contrle
7.1. Les structures conditionnelles
7.2. Les structures itratives
Chapitre 1. Introduction au langage Java
2
1. Prsentation du langage Java Java est un langage de programmation orient objet. Il a t dvelopp par la
socit Sun Microsystems (rachete dernirement par Oracle Corporation). Les principales
caractristiques de Java sont les suivantes :
Java est orient objet. Donc il tire profit des avantages de la programmation
oriente objet. Cette dernire sera aborde dans le chapitre 3.
Java est compil-interprt : Java n'est pas un langage totalement compil
ou totalement interprt. L'excution se fait sur deux tapes: le code source
est compil en pseudo code puis ce dernier est excut par un interprteur
Java appel Java Virtual Machine (JVM). Ce concept est la base du slogan
de Sun pour Java : WORA (Write Once, Run Anywhere : crire une fois,
excuter partout).
Java est indpendant de toute plateforme : Le pseudo code gnr ne
contient pas de code spcifique une plateforme particulire. Il peut tre
excut sur toutes les machines disposant d'une JVM et obtenir quasiment les
mmes rsultats. On dit que Java est un langage portable.
Java possde une API riche. Le terme API (pour Application Programming
Interfaces) regroupe l'ensemble des librairies, classes, interfaces,etc
prdfinies en Java. Java possde une API trs riche qui facilite la tche des
dveloppeurs et permet un gain de temps.
Java assure la gestion de la mmoire : l'allocation de la mmoire est
automatique pour les objets crs. Java rcupre automatiquement la
mmoire inutilise grce un systme appel ramasse miette (connu par
garbage collector en anglais) qui libre les espaces de mmoire libres.
Simplicit (relative): Le dveloppement en Java ne contient pas la
manipulation des lments gnralement jugs compliqus tels que la notion
de pointeurs (pour viter les incidents en manipulant directement la
mmoire) et l'hritage multiple. En plus, la syntaxe de Java proche de celle
du C/C++ contribue sa simplicit.
Java est fortement typ : Toutes les variables doivent avoir un type et il
n'existe pas de conversion automatique qui risquerait une perte de donnes.
Ceci est une source de la robustesse du langage Java.
Java est multitche : il permet l'utilisation de threads (processus lgers) qui
sont des units d'excution isoles.
Java a actuellement trois ditions principales:
J2SE : Java 2 Standard Edition. Cette dition est destine aux applications pour poste de travail.
Chapitre 1. Introduction au langage Java
3
J2EE : Java 2 Entreprise Edition. Cette dition est spcialise dans les applications serveurs. Elle inclut le dveloppement des applications Web.
J2ME : Java 2 Micro Edition. Cette dition est spcialise dans les applications mobiles.
Remarque: JDK et JRE et Java
Un ensemble d'outils et de programmes permettant le dveloppement de programmes
avec Java se trouve dans le Java dveloppement Kit connu par JDK. La JRE (pour Java
Runtime Environment) est une partie du JDK qui contient uniquement l'environnement
d'excution de programmes Java. Le JRE seul doit tre install sur les machines o des
applications Java doivent tre excutes.
2. Excution d'un programme en Java
Pour excuter un programme en C, on le compile. On gnre alors un code natif
spcifique l'environnement d'excution de la machine. Ce code est directement
excutable.
Dans le cas de Java, c'est diffrent. Il est ncessaire de compiler la source pour la
transformer en pseudo-code Java (code intermdiaire ou byte code) indpendant de la
plateforme d'excution. Ce pseudo-code sera ensuite excut par la machine virtuelle
(JVM) installe sur la machine. On rappelle ici la devise de java : crire une fois , excuter
partout.
Chapitre 1. Introduction au langage Java
4
La figure suivante re-illustre ce principe: le compilateur gnre un fichier d'extension
.class indpendant de la plateforme d'excution qui sera ensuite excut dpendamment de
la plateforme. Ceci fait la portabilit de Java.
2.1. La compilation d'un code source
N'importe quel diteur de texte peut tre utilis pour diter un fichier source Java.
Pour compiler ce fichier, il suffit d'invoquer la commande javac avec le nom du fichier
source avec son extension .java
javac NomFichier.java
Chapitre 1. Introduction au langage Java
5
Suite la compilation, le pseudo code Java est enregistr sous le nom
NomFichier.class
2.2. L'excution d'un programme
Un programme ne peut tre excute que si il contient une mthode main()
correctement dfinie. Pour excuter un fichier contenant du byte-code il suffit d'invoquer la
commande java avec le nom du fichier source sans son extension .class
java NomFichier
2.3. Les Environnements de Dveloppement intgrs
En pratique, les dveloppeurs Java utilisent des Environnements de Dveloppement
Intgrs (EDI ou IDE en anglais pour integrated development environment) pour crer des
application Java. Un EDI est un programme regroupant un ensemble d'outils pour le
dveloppement de logiciels. En rgle gnrale, un EDI regroupe un diteur de texte, un
compilateur, des outils automatiques de fabrication, et souvent un dbogueur. Parmi les
EDI les plus connus pour le langage Java, on trouve eclipse, Netbeans et JCreator.
3. Les rgles gnrales de la syntaxe Java est sensible la casse: il fait la diffrence entre majuscule et minuscule.
Exemple: La variable nomme id et celle nomme ID reprsentent deux variables
diffrentes.
Chaque instruction Java finit pas par un ;
Une instruction peut tenir sur plusieurs lignes
Exemple:
int age = 20; est quivalent
int age
=
20;
L'indentation est ignore de la part du compilateur mais elle permet une meilleure
comprhension du code.
Chaque variable ou sous-programme est associ un nom : l'identificateur. Il peut
se composer de tous les caractres alphanumriques et des caractres _ et $. Le premier
caractre doit tre une lettre, le caractre de soulignement ou le signe dollar. Un
identificateur ne peut pas appartenir la liste des mots rserv du langage Java
4. Les commentaires Les commentaires ne sont pas pris en compte par le compilateur. Un commentaire
sur une seule ligne commence par '//', celui portant sur une ou plusieurs lignes est crit
Chapitre 1. Introduction au langage Java
6
entre '/*' et '*/'. Les commentaires sont gnralement utiliss par les dveloppeurs pour
expliquer le code.
Exemples :
int age=20; // ge de l'tudiant
int nom; /* c'est le nom
de l'tudiant */
Il existe un type particulier de commentaires qui servent enrichir le code crit: les
commentaires de documentation automatique.
Exemple:
/**
* commentaire de la mthode
* @param (les paramtres)
* @return . (type de retour )
*/
5. Les variables
5.1. Les types primitifs
Le langage Java utilise plusieurs types lmentaires, appels aussi les types primitifs.
Ils commencent tous par une minuscule.
Type Dsignation Longueur Valeurs ( titre indicatif)
Byte octet sign 1 octet 128 127
Short entier court sign 2 octets 32768 32767
Int entier sign 4 octets
2147483648
2147483647
Long entier long
8 octets 9223372036854775808
9223372036854775807
float
virgule flottante simple
prcision (IEEE754)
4 octets
1.401e045
3.40282e+038
double
virgule flottante double
prcision (IEEE754)
8 octets 2.22507e308
1.79769e+308
Char caractre Unicode 2 octets \u0000 \uFFFF
boolean valeur logique : true ou false 1 bit true ou false
- Catgorie logique : Type boolean En java, un boolen nest pas considr
comme une valeur numrique, les seules valeurs possibles sont true ou false.
exemple: boolean trouve=true;
Chapitre 1. Introduction au langage Java
7
- Catgorie caractre : Type char Le type char permet de reprsenter les
caractres (caractre Unicode reprsent sur 16 bits). Il est dlimit par deux
apostrophes. Exemples:
char x=a; char omega=(char) 969;
char z=\u1200
- Catgorie entier : types byte, short, int et long Il existe 4 types dentiers en
java. Chaque type est dclar avec lun des mots cls byte, short, int et long.
Exemple: int x =1;
- Catgorie flottant : type float et double Une constante numrique est
flottante si elle contient un point dcimal, une partie exponentielle (lettre E) ou
si elle est suivie par la lettre F ou D.
Exemples:
2.3F
2.3
2.3E4
4F
Remarque 1: Les types par rfrences A part les types primitifs qui possdent des tailles
standards et fixes, il existe des types qui ne peuvent pas avoir une taille standard. Il s'agit
des types rfrences (tableaux, classes) qui seront abords dans les chapitres suivants.
Remarque 2: Les chanes de caractres Pour manipuler les chanes de caractres Java
offre le type String. Une constante chane de caractres est place entre doubles cotes.
5.2. Dclaration et affectation
La dclaration se fait avec la syntaxe suivante
Type nomVariable ;
Par convention, le nom de la variable en Java commence par une minuscule. Il est possible
de dfinir plusieurs variables de mme type dans une seule ligne en sparant chacune
d'elles par une virgule. On peut aussi initialiser une variable lors de sa dclaration. Le signe
= est l'oprateur d'affectation.
Exemples:
int a,b;
int c = 2;
5.3. La conversion des types
Si dans une expression les oprandes sont de diffrents types le rsultat est alors
converti vers le type le plus grand.
Exemple :
Chapitre 1. Introduction au langage Java
8
int x=2; long y=4, z;
z=x*y; //le rsultat est alors convertis en long
Pour laffectation, la donne droite est convertie dans le type de celle de gauche.
Si le type de la destination est plus faible linstruction est considre errone.
Exemple :
int i=2; long x=5;
x=i; //instruction lgale
i=x; // instruction errone
On peut convertir explicitement une valeur en forant la transformation. On
parle de "cast" ou "forage de type". Le type cibl est plac entre ( ) et est utilis comme
prfixe de lexpression dont on veut modifier le type. La syntaxe est:
= ()
Dans l'exemple prcdent on crit:
int i=2; long x=5;
i=(int)x; // instruction non errone
Autre exemple: float z; z=(float) 14.33;
int x; x=(int) z; //x contient la valeur 14
Le cast peut donc engendrer une perte d'information. (14.33 14)
6. Les oprateurs
6.1. Les oprateurs arithmtiques
Java reconnat les oprateurs arithmtiques usuels suivants :
+ (addition), (soustraction), * (multiplication), / (division) et % (reste de la division). Ils
peuvent se combiner l'oprateur d'affectation comme en C.
Exemple: nombre += 10;
Il existe diverses fonctions mathmatiques prdfinies. Voici quelques-unes:
Math .sqrt (x) racine carree
Math .pow( x, y) x la puissance y
Math .abs(x ) valeur absolue
Math .cos(x) Cosinus
Math .sin(x) Sinus
Exemple:
public static void main(String[] args) {
int a = -3;
int b= Math.abs(a); // valeur absolue
double c = Math.pow(a, 2); // a au carr (retourne un double)
double d = Math.sqrt(c);// racine carre (retourne un double)
Chapitre 1. Introduction au langage Java
9
// affichage
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
Excution:
-3
3
9.0
3.0
6.2. Les oprateurs de comparaison
Le rsultat d'une expression de comparaison est un boolen. Comme en C, Les oprateurs
sont les suivants:
Oprateur Exemple Signification
> a > 10 strictement suprieur
< a < 10 strictement infrieur
>= a >= 10 suprieur ou gal
Chapitre 1. Introduction au langage Java
10
System.out.println(a);
On affiche 5
De mme on a:
a- =b a=a-b
a*=b a=a*b
a/=b a=a/b
6.5. L'incrmentation et la dcrmentation
Comme en C, les oprateurs ++ et -- permet d'incrmenter / dcrmenter la valeur dune
variable.
Exemple:
int a =4, b=4;
a++; // a est gal 5
b- -; // b est gal 3
Si l'oprateur est plac avant la variable (il est alors dit prfix), la modification de la
valeur est immdiate, sinon la modification n'a lieu qu' l'issu de l'excution de la ligne
d'instruction ((il est alors dit oprateur postfix).
Exemple:
int x = 2;
System.out.println(x++); on affiche 2 puis on incrmente
Ceci est quivalent System.out.println(x); x = x + 1;
int x = 2;
System.out.println(++x); on incrmente puis affiche 3
x = x + 1; System.out.println(x);
Remarque: Il existe aussi les oprateurs de bits, qui ne sont pas couramment utiliss:
7. Les structures de contrle
7.1. Les structures conditionnelles
Le programmeur est trs souvent amen tester des valeurs et orienter le
programme selon ces valeurs.
a) Structure conditionnelle si.. alors .. sinon La syntaxe en Java est :
if () {
//instruction ou bloc dinstruction excuter si condition= vrai.
Chapitre 1. Introduction au langage Java
11
}else{
//instruction ou bloc dinstruction excuter si condition= faux.
}
Pour cette syntaxe, la clause else est optionnelle. On peut imbriquer des structures
conditionnelles.
Exemple
float moyenne = 16;
if (moyenne>=10 ){
System.out.println("Russite!");}
else {System.out.println("Echec!");
}
Excution: Russite!
b) L'oprateur ternaire
Il s'agit d'une forme simplifie de la structure conditionnelle prcdente. Il s'agit
d'valuer une expression et, selon la valeur logique prise par cette expression, on affecte
une valeur ou une autre une variable. La syntaxe est :
variable= ( condition ) ? valeurvrai : valeurfaux;
Exercice
Donner une version utilisant l'oprateur ternaire quivalente l'exemple prcdent
utilisant la structure si/alors.
Solution
float moyenne = 16;
String resultat=( moyenne>=10 ) ? "Russite!" : "Echec!";
System.out.println(resultat); // afficher le rsultat
Excution: Russite!
c) La structure conditionnelle selon.. faire
Dans la structure conditionnelle alternatives, une expression peut tre teste par rapport
plusieurs valeurs possibles. La syntaxe est la suivante:
switch ()
{
Chapitre 1. Introduction au langage Java
12
case : break;
case : break;
case : break;
default :
}
- La spcification du break est ncessaire pour grer les ruptures de squences.
- On ne peut utiliser switch qu'avec des types primitifs suivants: byte, short, int, char.
Exercice
Donner le rsultat d'excution des deux codes suivants:
Code 1 Code2
Int k=0, i=2;
switch(i)
{
case 1: k+=20; break;
case 2: k+=2; break;
case 3: k+=10; break;
}
System.out.println("k= "+k);
int k=0, i=2;
switch(i)
{
case 1: k+=20;
case 2: k+=2;
case 3: k+=10;
}
System.out.println("k= "+k);
Solution
Le rsultat du code 1 est "k=2". Le deuxime code ne contient pas l'instruction
break, on va donc excuter les deux dernires clauses case. Le rsultat est donc "k=12".
7.2. Structures de contrle itratives
Une boucle sert excuter un ensemble dinstructions rptes plusieurs fois.
a) La boucle pour
La boucle pour est utilise si le nombre de rptitions est connu l'avance. La
syntaxe est la suivante:
for ( ; ; )
{
}
Exemple:
for (int i=1 ; i
Chapitre 1. Introduction au langage Java
13
1
2
Il est noter que:
for ( ; ; ) est une boucle infinie.
Dans l'initialisation, on peut dclarer une variable qui sert d'index (la variable i
dans l'exemple) Elle est dans ce cas locale la boucle.
Il est possible d'inclure plusieurs traitements dans l'initialisation et la modification
de la boucle: chacun des traitements doit tre spar par une virgule.
Exemple:
int i,j;
for (i = 0 , j = 0 ; i + j < 10; i++ , j+= 3) {
. }
Exercice:
Donner un code Java permettant de calculer puis afficher le factoriel d'un entier n.
Solution:
int n =3;
int fact = 1;
for (int i=1; i
Chapitre 1. Introduction au langage Java
14
instructions excutes 0 ou plusieurs
fois.
Exercice:
Donner la somme 1+2+3+4 en utilisant les deux boucles.
Solution:
int s = 0, i = 1;
while (i
Chapitre 1. Introduction au langage Java
15
8. Srie d'exercices
Exercice 1
Ecrire un programme qui initialise deux entiers puis affiche leur somme et leur produit.
Solution
public static void main(String[] args) {
int a = 4;
int b = 3;
int somme= a+b;
int produit= a*b;
System.out.println("La somme est "+ somme+ " - Le produit est : " + produit);
}
Exercice 2
crire un programme qui affiche successivement les factorielles des N premiers entiers. La
constante N sera dclare et initialise dans main comme suit :
final int N = 4;
Solution
public static void main(String[] args) {
final int N = 4;
int n;
int fact;
n = 1;
fact = 1;
while ( n
Chapitre 1. Introduction au langage Java
16
Exercice 3
a) Ecrire un programme qui calcule la nime valeur de la suite de Fibonacci qui
dfinie par
U0 = 1
U1 = 1
Un = Un-1 + Un-2, pour n>2
b) Vrifier le rsultat pour n =4.
Solution
public static void main(String[] args) {
int n = 4;
for (int i = 1; i 0 && b > 0 ) {
System.out.print("PGCD("+a+","+b+") = ");
while ( a != b ) {
if ( a < b )
b = b - a;
Chapitre 1. Introduction au langage Java
17
else
a = a - b;
System.out.print("PGCD("+a+","+b+") = ");
}
System.out.println(a);
}
}
Excution
PGCD(6,9) = PGCD(6,3) = PGCD(3,3) = 3
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
18
Chapitre 2. Les bases de la Programmation
Objet : Classe - Objet
Objectifs
Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances
de base se rapportant aux objectifs spcifiques suivants:
- Comprendre les notions de classe et d'objet
- Etre capable de dvelopper une classe en prcisant ses attributs, ses constructeurs et ses
oprations, puis utiliser cette classe dans un programme Java.
- Comprendre le principe d'encapsulation et la surcharge des mthodes.
Pr-requis
Algorithmique et structures de donnes
Syntaxe de Java
Elments de contenu
1. Les classes
1.1. Notion de classe
1.2. Dclaration des classes
2. Les Objets
2.1. Notion d'objet
2.2. La cration d'un objet
2.3. Les constructeurs
2.4. Les destructeurs
2.5. Utiliser un objet
2.6. Les rfrences et la comparaison des Objets
2.7. La rfrence this
2.8. Le mot cl null
2.9. L'operateur instanceOf
3. Le principe de l'encapsulation
3.1. Les membres publiques et les membres privs
3.2. Les accesseurs
4. Attribut d'instance et attribut de classe
5. Les mthodes
5.1. Passage des paramtres
5.2. La surcharge des mthodes
5.3. Mthodes de classe
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
19
1. Les classes
1.1. Notion de classe
Les langages de programmations que vous avez vu jusqu' maintenant (Pascal et
C) ne sont pas orients objet. Vous avez vu la programmation procdurale: un ensemble
de procdures et fonctions qui appellent les unes les autres. La programmation oriente
objet (POO) est bas sur la notion d'objet. Cest une notion trs proche de celle de la vie
courante qu'on va dcouvrir dans ce chapitre.
La POO est base sur l'utilisation d'un ensemble d'units appeles classes. Ces
dernires offrent gnralement une description des objets concrets ou abstraits du monde
rel.
Exemple: Pour dvelopper un programme de gestion de votre ISET, on vous
propose de crer les classes suivantes: classe Etudiant, classe Enseignant, classe matire,
classe module, classe laboratoire.
Une classe offre le modle (ou description abstraite) de ses objets, in s'agit d'un
ensemble de donnes et d'oprations qui permettent de manipuler ces dernires regroupes
dans une mme entit. Les donnes sont gnralement appeles attributs et les oprations
sont appeles mthodes. Java est un langage orient objet : gnralement tout appartient
une classe, sauf les variables de type primitives.
Exemple : la classe personne
Personne
Prnom: chaine de caractres
Nom: chaine de caractres
Age : entier
Des attributs
afficherNom()
incrementerAge()
Des mthodes
1.2. Dclaration des classes
Une classe se compose en deux parties : l'en-tte et le corps. Le corps peut tre
divis en 2 sections : la dclaration des attributs (des variables contenant les donnes) et la
dfinition des mthodes (elles implmentent les traitements).
[Modificateurs] class nomDeClasse [extends classe_mere] [implements interface] {
// Dclaration des attributs
[] [=];
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
20
//Dclaration les mthodes
[] ([])
{ // les instructions}
} // fin classe
L'ordre des mthodes dans une classe n'a pas d'importance. Si dans une classe on
rencontre d'abord la mthode A puis la mthode B, B peut tre appele sans problme dans
la mthode A.
Il est noter que les modificateurs de classe sont des mots rservs tels que
"public", "private"... Ils vont tre abords plus tard. Pour le moment, on ne va pas les
utiliser. De mme, les modificateurs des mthodes et des attributs ainsi que les mots cl
implements et extends seront traits plus tard. On va donc se contenter de la forme la plus
rduite.
Exemple: Une classe Personne qui modlise une personne en Java.
class Personne {
//______les attributs
String prenom;
String nom;
int age;
//______les mthodes
//une mthode qui affiche le prnom de la personne
void afficherPrenom() {
System.out.println("le prnom de la personne est:" + prenom);
}
//une mthode qui incrmente l'age de la personne
void incrementerAge() {
age++;
}
}
Remarque : Conventions de nommage en Java
Ce sont des conventions: on peut ne pas suivre ces rgles et avoir un programme
Java excutable sans erreurs. Cependant, il est recommand de les suivre pour augmenter
la qualit du code.
1) Les noms de classes (et des interfaces voir dans le chapitre 4) commencent
par des majuscules.
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
21
Exemple: class Etudiant class Livre
2) Les noms des attributs, des variables et des mthodes commencent par des
minuscules.
Exemple: int compteur; - void afficher() {}
3) Si le nom est une concatnation de plusieurs mots alors les premires lettres
de tous les mots, sauf le premier, seront crites en majuscule. Ceci permet
de dlimiter les mots visuellement.
Exemple:
class EtudiantEnInformatique
int compteurLivre;
void afficherEtudiant() {}
4) Le nom d'une constante est entirement en majuscule.
Exemple: MAXIMUM
Exercice
1) Donner la classe ISET permettant de reprsenter une ISET par un
identifiant (entier), une adresse, nombre d'tudiants. Doter cette classe par
une mthode d'affichage et une mthode qui ajoute augmente le nombre des
tudiants avec un entier pass comme paramtre.
2) Donner la classe Ordinateur qui permet de reprsenter un ordinateur par un
identifiant, une marque et la taille de la RAM. Doter cette classe par une
mthode d'affichage.
3) Classe matire qui reprsente une matire par un identifiant, un nom, une
note oral, une note de DS et une note d'exam. Elle a une mthode
calculerMoyenne qui calcule la moyenne dans une matire avec la faon
suivante : Moyenne= 02*oral+0.4*DS + 0.4*Examen
Solution
class Iset {
// attributs
int identifiant;
String adresse;
int nombreEtudiants;
// mthodes
void afficherIset() {
System.out.println("l'Iset n" + identifiant + " situe " + adresse + "contient " +
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
22
nombreEtudiants + " tudiants. ");
}
void ajouterEtudiants(int nbrAjoutes) {
nombreEtudiants = nombreEtudiants + nbrAjoutes;
}
}
class Ordinateur {
int id;
String marque ;
double tailleRam;
void afficherOrdinateur (){
System.out.println("****Ordinateur****\n id: "+ id + "Marque: "+marque);
}
}
class Matiere {
// les attributs
int id;
String nom;
double noteOral, noteDS, noteExam;
// le mthodes
double calculerMoyenne() {
double res;
res = 0.2 * noteOral + 0.4 * noteDS + 0.4 * noteExam;
return res;
}
}
2. Les Objets
2.1. Notion d'objet
Un objet est lunit de base de la conception OO. On a dit qu'une classe est la
description d'un objet. Un objet est une instance d'une classe: instancier une classe
consiste crer un objet sur son modle. Entre classe et objet il y a, en quelque sorte, le
mme rapport qu'entre type et variable. Pour chaque instance d'une classe, le code est le
mme, seules les donnes sont diffrentes chaque objet.
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
23
Personne
Prnom
Nom
Age
afficherNom()
incrementerAge()
Objet 1 de Personne . Objet 2 de Personne . . Objet n
Prnom = Mohamed
Nom = BenMohamed
Age = 20
Prnom = Salah
Nom = BenSalah
Age = 25
afficherNom()
incrementerAge()
afficherNom()
incrementerAge()
2.2. La cration d'un objet
Elle consiste l'instanciation de la classe relative cet objet. Il faut diffrencier
entre la cration d'un objet et sa dclaration.
a) Dclaration d'un objet: Elle est similaire la dclaration d'une variable de
type primitif: Dclarer une variable ayant comme type la classe que lon
dsire instancier. Cette variable nest pas lobjet lui-mme mais une
rfrence cet objet. La dclaration est de la forme:
nomClasse nomObjet;
Exemple :
Personne p1; // dclarer un objet p1 de la classe Personne
Personne p2; // dclarer un autre objet p2 de la classe Personne
b) Cration de l'instance d'un objet: L'oprateur new se charge de crer une
instance de la classe et de l'associer la variable, il s'agit ici d'allouer
lespace mmoire ncessaire lobjet et renvoyer ladresse de lobjet la
variable rfrence.
Exemple : p1 = new Personne ( );
Il est possible de tout runir en une seule ligne comme suit:
Personne p1 = new Personne();
L'oprateur new est suivi du constructeur.
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
24
2.3. Les constructeurs
Un constructeur est une mthode particulire appele au moment de la cration
dun objet. Deux rgles importantes pour le constructeur:
Le nom du constructeur doit tre le mme que le nom de la classe
Il n'a pas de type de retour.
Pour une mme classe, on peut associer plusieurs constructeurs. Ils doivent
ncessairement avoir des paramtres diffrents (nombre, type et ordre des paramtres.) On
dit alors qu'on a surcharg le constructeur. On utilise principalement ces trois manires de
dfinir un constructeur :
1) le constructeur vide sans paramtres, c'est le plus simple. Si on ne dfinit aucun
constructeur pour la classe, un constructeur pareil est dfinit par dfaut.
Exemple: public Personne () {}
2) le constructeur avec initialisation fixe.
Exemple :
public Personne() {
age = 5;
}
3) Le constructeur avec initialisation des attributs partir des paramtres.
Exemple:
public Personne(String prenom1, String nom1, int age1) {
prenom = prenom1;
nom = nom1;
age = age1;
}
Si on veut lui ajouter des constructeurs, la classe "Personne" devient comme suit:
class Personne {
// les attributs
String prenom;
String nom;
int age;
//les constructeurs
public Personne() {
}
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
25
public Personne(String prenom1, String nom1, int age1) {
prenom = prenom1;
nom = nom1;
age = age1;
}
// les mthodes
void afficherPrenom() {
System.out.println("le prnom de la personne est: " + prenom);
}
void incrementerAge() {
age++;
}
}// fin personne
Remarque: Le constructeur par dfaut
La dfinition d'un constructeur n'est pas obligatoire. En fait, si le dveloppeur ne
spcifie aucun constructeur pour la classe, Java appelle un constructeur par dfaut cr
automatiquement qui correspond un constructeur vide sans paramtres. Par exemple
pour la classe Personne, le constructeur par dfaut est de la forme:
public Personne (){ }
Cependant, ds que le dveloppeur dfini explicitement un constructeur, Java ne va plus
utiliser le constructeur par dfaut ( Java considre que le dveloppeur prend en charge la
cration des constructeurs). Si on en a besoin, on doit dfinir explicitement le constructeur
sans paramtres.
Exercice
Ajouter un constructeur qui initialise les attributs pour les trois classes Iset,
Ordinateur et Matire de l'application prcdente.
Solution
public Iset(int id1, String adr1, int nbrE1) {
identifiant = id1;
adresse = adr1;
nombreEtudiants = nbrE1;
}
public Ordinateur(int id1, String marque1, double tailleRam1) {
id = id1;
marque = marque1;
tailleRam = tailleRam1;
}
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
26
public Matiere(int id1, String nom1, double noteOral1, double noteDS1, double
noteExam1) {
id = id1;
nom = nom1;
noteOral = noteOral1;
noteDS = noteDS1;
noteExam = noteExam1;
}
2.4. Les destructeurs
Un destructeur permet d'excuter du code lors de la libration, par le garbage
collector, de l'espace mmoire occup par l'objet. En Java, les destructeurs appels
finaliseurs (finalizers), sont automatiquement appels par le garbage collector. Pour crer
un finaliseur, il faut redfinir la mthode finalize() hrite de la classe Object.
2.5. Utiliser un objet
Laccs un attribut d'un objet donn se fait toujours lintrieur dune mthode.
On cre un objet de la classe puis on applique cette syntaxe: nomObjet.nomAttribut
Exemple:
Personne p1 = new Personne("Ahmed","Mohamed",12);
System.out.println ("L'ge de la personne est :" +p1.age);
De mme, pour invoquer une mthode d'un objet donn, on cre l'objet puis on
applique cette syntaxe: nomObjet.nomMthode (arguments);
Exemple:
p1.incrementerAge();
Pour tester une classe, on cre souvent une classe de test permettant de crer un
objet puis invoquer les mthodes de la classe.
Exemple
public class TestPersonne {
public static void main(String[] args) {
Personne pers = new Personne("Mohamed", "benMohamed", 20) ;
pers.afficherPrenom();
pers.incrementerAge();
System.out.println("l'ge devient: "+ pers.age);
}
}
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
27
L'excution donne:
le prnom de la personne est: Mohamed
l'ge devient: 21
Exercice
On veut tester les trois classes de l'exercice prcdent.
1) Crer la classe TestIset possdant une mthode main permettant de tester la
classe Iset. Dans la mthode main on doit:
a) Crer un objet et initialiser ses attributs
b) Appeler les mthodes de chaque objet.
c) Donner le rsultat de l'excution attendu.
2) Crer la classe TestOrdinateur permettant de tester la classe Ordinateur avec la
mme dmarche dcrite dans 1.
3) Crer la classe TestMatire permettant de tester la classe Matire avec la
mme dmarche dcrite dans 1.
Solution:
class TestIset {
public static void main(String[] args) {
Iset iset = new Iset(123, "Jendouba", 1200);
iset.afficherIset();
iset.ajouterEtudiants(5);
iset.afficherIset();
}
}
Excution:
l'Iset n123 situe Jendouba contient 1200 tudiants.
l'Iset n123 situe Jendouba contient 1205 tudiants.
class TestOrdinateur {
public static void main(String[] args) {
Ordinateur ord = new Ordinateur(12, "Dell", 1024);
ord.afficherOrdinateur();
}
}
Excution
****Ordinateur****
id: 12Marque: Dell
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
28
public class TestMatiere {
public static void main(String[] args) {
Matiere mat = new Matiere(1, "POO", 11, 12, 11.5);
double moy=mat.calculerMoyenne();
System.out.println(moy);
}
}
Excution
11.600000000000001
2.6. Les rfrences et la comparaison des Objets
Les rfrences sont les variables qui permettent de dsigner et manipuler les objets:
ces variables ne contiennent pas un objet mais une rfrence vers cet objet. Lorsqu'on
affecte une rfrence dans une autre ( c..d on crit p1 = p2 avec sont des objets), on copie
la rfrence de l'objet p2 dans p1.
p1 et p2 rfrent au mme objet (ils pointent sur le mme objet).
Gnralement, 3 cas de comparaisons se prsentent:
1) Pour comparer deux rfrences, on utilise les oprateurs logiques suivants: = =: teste si 2 rfrences dsignent le mme objet.
!= : teste si 2 rfrence ne dsignent pas le mme objet
Exemple:
Personne p1 = new Personne("Mohamed", "BenMohamed",20);
Personne p2 = new Personne ("Salah", "BenSalah",25);
if (p1 = = p1) { ... } // vrai
if (p1 = = p2) { ... } // faux
2) Pour comparer l'galit de deux objets selon les valeurs de leurs attributs (et
non pas les rfrences), on doit doter la classe d'une mthode qui permet de
le faire (ne pas utiliser l'operateur = =).
3) Pour s'assurer que deux objets sont de la mme classe, il faut utiliser la
mthode getClass().
Exemple :
If (obj1.getClass().equals(obj2.getClass()) {.}
Le 2me
cas est le cas le plus utilis.
Exercice
Ajouter la classe Personne la mthode egaleA qui permet de comparer deux
personnes. On supposera que les deux personnes doivent avoir le mme nom et prnom
pour que la mthode retourne True.
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
29
Indication: Pour comparer deux chaines de caractres, on utilise la mthode equals
avec la syntaxe suivante: chaine.equals(chaine2) . Cette mthode retourne true si les deux
chaines sont identiques et false sinon.
Solution:
boolean egaleA (Personne p2){
if (this.nom.equals(p2.nom) && this.prenom.equals(p2.prenom))
return true;
return false;
}
2.7. La rfrence this
Le mot rsrv this reprsente une rfrence sur lobjet courant d'utilisation (celui
qui est entrain dexcuter la mthode contenant le this). Cette rfrence est habituellement
implicite :
void incrementerAge() { age++; } est equivalent :
void incrementerAge() { this.age++; }
Le mot cl this peut tre utilis aussi dans ces deux cas :
a) Lorsquune variable locale ou paramtre cache, en portant le mme nom, un
attribut de la classe.
Exemple:
class Personne{
int age;
public Personne (int age) {
age = age; // attribut de classe = variable en paramtre du constructeur
} }
Dans ce cas on distingue les deux variables "age" en crivant:
this.age = age;
b) Pour dclencher un constructeur depuis un autre constructeur.
Exemple
public class Personne {
//______les attributs
String nom, prenom;
int age;
//Premier constructeur
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
30
public Personne(String nom ) {
this.nom=nom;
}
// Deuxime constructeur
public Personne(String nom, String prenom, int age) {
this (nom); // l'appel this(..) doit tre la premire ligne dans ce constructeur
this.age = age;
this.prenom = prenom;
}
2.8. Le mot cl null
Le mot cl null permet de reprsenter la rfrence qui ne reprsente rien. On peut
assigner cette valeur nimporte quelle variable contenant une rfrence. Cest aussi la
valeur par dfaut dinitialisation des attributs reprsentant des rfrences.
Class TestPersonne{
Personne p1; // objet initialis null par dfault.
void methode() {
if (p1= =null)
p1=new Personne();
}
}
2.9. L'operateur instanceOf
Il permet de dterminer la classe de l'objet qui lui est pass en paramtre: il retourne
true si lobjet gauche est une instance de la classe plac sa droite ou si la comparaison
est faite entre un objet dune classe implmentant une interface. Sinon il retourne false. La
syntaxe est la suivante:
objet instanceof nomClasse
Exemple:
class Personne { ..}
class Test
{
public static void main (String[] args){
Peronne p=new Personne();
if (pers instanceof Personne)
System.out.println("c'est une personne ");
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
31
if (pers instanceof Test)
System.out.println("c'est une instance de la classe Test ");
}}
3. Le principe de l'encapsulation
En orient objet, le regroupement d'attribut et de mthodes dans une "boite" appele
classe ainsi que le marquage des donnes est appel: encapsulation. C'est principe
important dans la philosophie de l'orient objet.
3.1. Les membres publiques et les membres privs
L'encapsulation permet d'offrir l'utilisateur de la classe (celui qui veut appeler une
classe) une liste de services exploitables appels interface. Cette dernire comporte les
attributs et mthodes dits publiques. On peut donc accder ces membres partir de
l'extrieur de la classe. On utilise le mot cl public lors de leurs dclarations.
Exemple:
public int monAttribut;
public void maMthode ( ){}
On peut avoir une liste d'attributs et de mthodes rservs l'utilisation interne d'un
objet. Ces membres sont dits privs. Les attributs privs sont donc utilisables seulement
dans les mthodes du mme objet. On utilise le mot rserv private pour la dclaration
Exemple:
private int monAttribut;
private void maMthode (){.}
3.2. Les accesseurs
Pour respecter le principe de l'encapsulation, les attributs sont gnralement
dclars privs (sauf en cas ncessit). Ils ne peuvent tre vus et modifis que par des
mthodes dfinies dans la mme classe. Si une autre classe veut accder ces attributs, elle
doit utiliser une mthode prvue pour cet effet : il s'agit de l'accesseur qui est une mthode
publique qui donne l'accs un attribut d'instance. Il s'agit de deux types:
un accesseur en lecture qui commence par convention par get (d'o le nom
getter). Il retourne la valeur de l'attribut en question.
un accesseur en criture qui commence par convention par set(d'o le nom
setter). Il change la valeur de l'attribut.
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
32
Notre classe Personne devient donc:
public class Personne {
//______les attributs privs
private String nom;
private String prenom;
private int age;
//______ les accesseurs publiques
public int getAge() {
return age; }
public void setAge(int age) {
this.age = age; }
public String getNom() {
return nom; }
public void setNom(String nom) {
this.nom = nom; }
public String getPrenom() {
return prenom; }
public void setPrenom(String prenom) {
this.prenom = prenom; }
}
4. Attribut d'instance et attribut de classe Les attributs peuvent tre des variables d'instances (ceux dj vus jusqu'
maintenant), des variables de classes ou des constantes. Un attribut marqu par le mot cl
static est un attribut de classe (appel aussi attribut statique), sinon il s'agit d'un attribut
d'instance. Les variables d'instance sont des variables propres un objet. Un attribut
statique est commun tous les objets de la classe concerne
Si on modifie cet attribut pour un objet donn, il sera modifi pour tous les
objets de la classe. Une variable de classe permet de stocker une constante ou une valeur
modifie par plusieurs instances d'une classe.
Exercice:
1) Dterminer le rsultat de l'excution de ce programme.
2) Pourquoi l'attribut compteur n'est pas dclar priv?
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
33
class Personne {
//______les attributs
private int id;
static int compteur=0;
//_____les constructeurs
public Personne() {
compteur++;
id= compteur; } // ceci permet d'avoir des id successifs
}
class TestPersonne {
public static void main(String[] args) {
Personne pers1 = new Personne() ; // id=1
Personne pers2 = new Personne() ;// id=2
// Le compteur est commun entre les deux personnes:
pers1.compteur=44;
System.out.println(pers2.compteur); }}
Solution:
1) Le programme affiche 44. Bien que modifi par l'instance pers1, et appel par
l'objet pers2, compteur contient 44.
2) L'attribut compteur n'est pas dclar priv pour qu'on puisse l'appeler dans la
classe TestPersonne.
On accde un attribut statique selon deux manires:
a) Via une instance quelconque de la classe
Exemple: pers1.compteur
b) Via le nom de la classe
Exemple: Personne.compteur
Le mot cl final est utilis pour dclarer une variable dont la valeur, une fois
initialise, ne peut plus tre modifie. On peut associer static final pour avoir une
constante commune tous les objets de la classe.
Exemple: final static double PI=3.14;
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
34
5. Les mthodes On a vu que les mthodes permettent d'implmenter les traitements de la classe.
Elles sont dfinies selon la faon suivante:
[modificateurs] typeDeRetour nomMthode ( [parametres] ) {...
// dfinition des variables locales + les instructions
}
Le type de retour peut tre un type lmentaire ou le nom d'une classe. Si la
mthode ne retourne rien, alors on utilise void.
5.1. Passage des paramtres
Si on passe en paramtre d'une mthode une variable de type simple (int, float,
boolean, ), le passage se fait par valeur. Les modifications de la valeur d'un argument
de type simple ne sont pas transmissibles l'extrieur de la mthode, car ces dernires
travaillent sur une copie de l'argument.
Pour transmettre la valeur modifie d'un argument de type simple l'extrieur d'une
mthode, on peut:
Soit retourner la valeur de la variable par la mthode elle-mme
Soit la dfinir comme attribut dans l'objet (Les oprations oprent
directement sur les attributs sans avoir besoin de les passer en paramtres)
Si on passe en paramtre d'une mthode un objet, le passage se fait par rfrence:
Le contenu de l'objet peut etre modifi dans la mthode appele, par contre la rfrence
elle-mme ne va pas tre change.
Exercice:
Dterminer le rsultat de l'excution de ce programme.
class Test {
private int val = 11;
public void modifEntier(int n) {
n = 22;
}
public void modifObjet(Test obj) {
obj.val = 22;
}
public static void main(String a[]) {
Test t = new Test();
int n = 0;
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
35
// modifier n
t.modifEntier(n);
System.out.println("Valeur de n: "+n);
// modifier la valeur de l'attribut de l'objet
t.modifObjet(t);
System.out.println("Valeur de l'attribut val: "+t.val);
}
}
Solution:
Le rsultat de l'excution est:
Valeur de n: 0
Valeur de l'attribut val: 22
5.2. La surcharge des mthodes
Java permet de rutiliser un mme nom de mthode pour plusieurs fonctionnalits:
on parle alors de la surcharge des mthodes. La surcharge permet de dfinir des mthodes
portant le mme nom mais acceptant des paramtres diffrents en types et/ou en nombre.
Exemple:
class MiniCalculatrice {
//mthode1
public int additionner (int a, int b){
System.out.println("J'additionne deux entiers");return a+b;}
//mthode2
public double additionner (double a, double b){
System.out.println("J'additionne deux doubles");return a+b;}
//mthode3
public int additionner (int a, int b, int c ){
System.out.println("J'additionne trois entiers");return a+b+c;} }
Le compilateur choisi la mthode qui doit tre appele en fonction du nombre et du
type des paramtres.
Exercice
Dterminer les mthodes de la classe MiniCalculatrice appeles successivement dans les
lignes 5, 6 et 8.
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
36
1. class TestMiniCalculatrice {
2. public static void main(String[] args) {
3. MiniCalculatrice calc = new MiniCalculatrice();
4. int x = 2, y = 3;
5. System.out.println("resultat: " + calc.additionner(x, y));
System.out.println("resultat: " + calc.additionner(x, 3, y));
6. double i = 2.2, j = 3.2;
7. System.out.println("resultat: " + calc.additionner(i, j));
8. }
9. }
Solution
L'ordre d'appel des mthodes est:
1) Mthode 1
2) Mthode 3
3) Mthode 2
Il est noter que le type de retour des mthodes surcharges peut tre diffrent mais
cette diffrence elle seule nest pas suffisante, c'est--dire qu'il n'est pas possible d'avoir
deux mthodes avec le mme nom et les mmes paramtres et dont seul le type retourn
diffre.
Exemple:
int additionner (int a, int b){ return a+b;}
double additionner (int a, int b){ return a+a+b;}
// erreur, pour corriger on change le nom de la mthode, ou les paramtres
5.3. Mthodes de classe
Tout comme les attributs, on peut trouver des mthodes de classes. Une mthode de
classe:
est prcde par le mot cl static
ses actions concernent la classe entire
Ne peut accder qu'aux attributs statiques. Cependant, une mthode non
statiques peut accder aux attributs statiques.
On n'y utilise pas la rfrence this (car elle peut tre appele sans
lintermdiaire dun objet).
Comme dans le cas d'un attribut statique, on peut invoquer une mthode statique
selon deux manires :
a) Via une instance quelconque de la classe
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
37
b) Via le nom de la classe (sans instancier un objet)
Exercice:
1) Crer la classe MathTool contenant un attribut statique PI, une mthode
statique foiPI qui retourne la multiplication d'un nombre par PI et une
mthode carre qui calcule le carr d'un nombre donn en paramtre.
2) Tester la mthode carre de deux manires.
Solution
class MathTool {
// Pi est une constante
private final static double PI = 3.14;
public static double foixPI(double x) {
return x * PI; // accs une constante
}
public static double carr(double x) {
return (x * x);
}
}
class Test {
public static void main(String[] args) {
// Premire mthode de test: appel partir de la classe
double x = 6;
double result1 = MathTool.foixPI(x);
double result2 = MathTool.carr(x);
System.out.println("x*PI= " + result1 + " x*x= " + result2);
// Deuxime mthode de test: appel partir d'un objet
MathTool tool = new MathTool();
result1 = tool.foixPI(x);
result2 = tool.carr(x);
System.out.println("x*PI= " + result1 + " x*x= " + result2);
}
}
Excution
x*PI= 18.84 x*x= 36.0
x*PI= 18.84 x*x= 36.0
La mthode main a la forme suivante:
public static void main(String[] args) {.}
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
38
C'est donc une mthode de classe, elle est la premire tre appele quand on excute sa
classe. Cette dclaration de la mthode main() est impose par la machine virtuelle pour
reconnaitre le point d'entre d'une application.
6. Srie d'exercices
Remarque: Dans vos rponses, respectez le principe d'encapsulation. Le code java doit tre
comment.
Exercice 1
1) Dfinir une classe Date permettant de reprsenter le jour, le moi et l'anne d'une
date. Doter la d'un constructeur. La classe contient aussi les mthodes suivantes:
nbredeJours qui retourne le nombre de jours du moi de la date.
dateValide qui vrifie si une date est valide
lendemain qui retourne la date du jour d'aprs.
afficherDate qui affiche une date sous la forme jour/moi/anne.
2) Crer la classe TesterDate contenat une mthode main qui
Cre une date et l'affiche.
Si la date est invalide, on affiche un message d'erreur, sinon on affiche le
nombre de jours du moi puis la date du lendemain.
Solution
1)
class Date {
// attributs
private int jour, moi, annee;
// Constructeur
public Date(int jour, int moi, int annee) {
this.jour = jour;
this.moi = moi;
this.annee = annee;
}
// mthode qui retourne le nombre de jours du moi
public int nbreJours() {
int nb;
switch (moi) {
case 1:
case 3:
case 5:
case 7:
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
39
case 8:
case 10:
case 12:
nb = 31;
break;
case 4:
case 6:
case 9:
case 11:
nb = 30;
break;
case 2:
if (annee % 4 == 0) // si anne bissextile
{ nb = 29;
} else {
nb = 28;
}
default:
nb = 0;
break;
}
return nb;
}
//mthode qui vrifie si la date est valide
public boolean dateValide() {
if (jour > 0 && jour 0 && moi 0) {
return true;
}
return false;
}
// mthode qui retourne la date du lendemain
public Date lendemain() {
Date d = new Date(jour, moi, annee);
if (d.jour < nbreJours()) {
d.jour++; // si le moi en cours n'est pas fini, incrmenter le jour
} else {
d.jour = 1; // sinon , un nouveau moi commence
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
40
if (d.moi > 12) {
d.moi++;
} else {
d.moi = 1;
d.annee++;
}
}
return d;
}
public void afficherDate() {
System.out.println("Date: " + "/" + jour + "/" + moi + "/" + annee);
}
} // Fin TestDate
2)
public class TestDate {
public static void main(String[] args) {
Date d = new Date(9, 8, 1985);
d.afficherDate();
if (!d.dateValide()) {
System.out.println("Date invalide!");
} else {
System.out.println("Nombre de jours du moi: " + d.nbreJours());
Date lendemain = d.lendemain();
lendemain.afficherDate();
}
}
}
Exercice 2
On dsire reprsenter les nombres complexes sous la forme a+ib o a est la partie
relle, b la partie imaginaire (a et b tant deux entiers positifs) et i le nombre dont le carr
vaut -1. On voudra pouvoir additionner et de multiplier des complexes, calculer le
conjugu et le module ... On se propose de crer alors la classe Complexe.
1) Dterminer les deux attributs de la classe Complexe.
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
41
2) Donner les constructeurs suivants:
un constructeur par dfaut
un constructeur qui initialise les deux attributs par les valeurs passes en
paramtre
un constructeur permettant de construire un complexe ne possdant pas de
partie imaginaire.
Qu'appelle-t-on l'opration de programmer ces trois constructeurs?
3) Donner la mthode permettant de tester l'galit de deux complexes. (on va tester
l'galit des deux parties relles et des deux parties imaginaires)
4) Donner la mthode "addition" permettant d'additionner deux complexes.
5) Donner la mthode "addition" permettant d'additionner un entier au complexe en
cours.
Peut-on appeler cette mthode "addition" ? De quoi sont caractrises les deux
mthodes des questions 4 et 5?
6) Donner la mthode qui retourne le conjugu.
7) Donner la mthode qui calcule le module du complexe.
8) Donner la mthode qui multiplie deux complexes.
9) Crer la classe TestComplexe qui teste la mthode de calcul du module.
Solution
public class Complexe {
// Les attributs privs
private int a; //Partie reelle
private int b; //Partie imaginaire
// Les constructeurs
public Complexe() {
}
public Complexe(int r, int i) {
a = r;
b = i;
}
public Complexe(int r) {
a = r;
b = 0;
}
// Les mthodes
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
42
// tester l'galit
boolean testEgaliter(Complexe c2) {
if ((this.a == c2.a) && (this.b == c2.b)) {
return true;
}
return false;
}
/*additionner deux complexes: cette mthode retourne un nouveau complexe
representant l'addition du complexe courant
* au complexe passe en parametre. */
Complexe addition(Complexe c2) {
Complexe res = new Complexe();
res.a = a + c2.a;
res.b = b + c2.b;
return res;
}
/** Ajoute au complexe courant un entier. Cette methode ne retourne
* pas de resultat car elle modifie le complexe courant */
void additionEntier(int r) {
a = a + r;
}
//Calcul du conjugu du complexe
Complexe calculerConjug() {
return new Complexe(a, -b);
}
// Calcul le module du complexe
double calculerModule() {
double module = Math.sqrt(a * a - b * b);
return module;
}
// multiplier deux complexes
public Complexe multiplication(Complexe z) {
return new Complexe(a * z.a - b * z.b, a * z.b + z.a * b);
}
Chapitre 2. Les bases de la Programmation Objet : Classe - Objet
43
}
class TestComplexe {
public static void main(String[] args) {
Complexe c = new Complexe(3,2);
double module = c.calculerModule();
System.out.println("Module: "+ module);
}
}
Chapitre 3. Tableaux et chanes de caractres
44
Chapitre 3. Tableaux et chanes de
caractres
Objectifs
Ce chapitre s'intresse la manipulation des tableaux et des chaines de caractres.
Pr-requis
Notion de classe et d'objet.
Algorithmique et structures de donnes
Elments de contenu
1. Les tableaux
1.1. Dclaration
1.2. Cration
1.3. Initialisation
1.4. Parcours d'un tableau
1.5. Tableaux deux dimensions
2. Les chanes de caractres
Chapitre 3. Tableaux et chanes de caractres
45
1. Les tableaux
En java le type tableau est assimilable une classe, un tableau est un objet
rfrenc.
- Un objet tableau ne rfrence pas lobjet lui-mme mais uniquement
ladresse mmoire a qui il fait rfrence. Dclarer un tableau en java revient
rserver de la place mmoire pour ladresse de ce tableau.
- Pour crer un tableau il faut lui allouer lespace mmoire ncessaire aprs
lavoir dclar.
Si les lments d'un tableau sont de type simple, Java stocke directement les valeurs dans
les lments du tableau. S'il s'agit d'un tableau d'objets, les lments du tableau contiennent
toujours des rfrences (pointeurs) aux objets et non pas les objets eux mmes.
1.1. Dclaration
La dclaration d'un tableau une dimension suit cette syntaxe:
[ ];
ou bien
[ ];
On peut placer les crochets aprs ou avant le nom du tableau dans la dclaration.
Exemples:
int ages[]; // tableau entiers
char[] lettres; //tableau de caractres
float tab[100]; //instruction illgale car il nest pas possible de dfinir un
//tableau de taille fixe la dclaration.
1.2. Cration
La dclaration ne fait que rserver lespace mmoire allant contenir ladresse du tableau.
Cette place mmoire est identifie par le nom du tableau. Lallocation de la place mmoire
se fait par le mot cl new :
= new []; Exemples:
int ages[] = new int[8];
char[] lettres = new char[28];
1.3. Initialisation
Lorsquun tableau est cr, chacun de ses lments est initialis par dfaut. Cette
initialisation se fait :
Chapitre 3. Tableaux et chanes de caractres
46
0 si les lments sont des entiers ou des rels
false sils sont des boolens
null sinon.
On peut aussi initialiser le tableau lors de sa cration par des valeurs particulires.
Exemple:
int tab[ ]={2, 4, 6};
est quivalent faire
int tab[ ] =new int[3]; tab[0]=2; tab[1]=4; tab[2]=6;
1.4. Parcours d'un tableau
La longueur dun tableau peut tre obtenue partir de la variable length (Elle
retourne le nombre d'lments du tableau). La syntaxe est la suivante:
.length
Le premier lment d'un tableau est d'indice 0, le dernier lment est dindice n-1 avec n le
nombre dlments du tableau(tab.lenght -1).
Laccs un lments du tableau se fait en mettant lindice de cet lment entre
crochets. Si on essaie daccd un lment qui ce trouve en dehors des bornes du tableau
une erreur (de type java.lang.arrayIndexOutOfBoundsException) est gnre.
Exercice:
1) Crez et initialisez un tableau contenant 3 notes d'un tudiant.
- Afficher la somme des notes en utilisant la boucle for.
- Afficher la moyenne de ces 3 notes.
2) Affichez la somme des notes paires.
Solution:
1) float tab[] = {12, 10, 13};
float s = 0;
for (int i = 0; i < tab.length; i++) {
s += tab[i];
}
System.out.println("La somme est: " + s);
System.out.println("La moyenne est: " + s/tab.length);
2)
float tab[] = {12, 10, 13};
float sPaires = 0;
for (int i = 0; i < tab.length; i++) {
if (tab[i]%2 ==0)
sPaires += tab[i];
Chapitre 3. Tableaux et chanes de caractres
47
}
System.out.println("La somme est: " + sPaires);
Excution:
1)La somme est: 35.0
La moyenne est: 11.666667
2) La somme est: 22.0
1.5. Tableaux deux dimensions
En java, pour dclarer un tableau plusieurs dimensions, on dclare un tableau de
tableaux. Un tableau 2 dimensions est donc un tableau dont chaque composante est
forme par un tableau.
Il est noter que la taille des tableaux de la seconde dimension peut ne pas tre
identique pour chaque occurrence.
Exemple:
int[][] notes=new int[3][]; // 3 sous tableaux
notes[0]=new int[4];
notes [0][0]=10; notes [0][1]=11; notes [0][2]=12; notes [0][3]=13;
10 11 12 13
notes[1]=new int[3];
notes [1][0]=5; notes [1][1]=6 ; notes [1][2]=7;
5 6 7
notes[2]=new int[1]; notes [2][0]=20 20
Si le tableau deux dimensions est rectangulaire, on peut le crer comme suit :
[ ][ ]=new[N1][N2];
- N1: nombre des sous-tableaux.
-N2: nombre des lments dans chaque sous-tableau.
Exemple:
float tab [ ] [] = new float[3][3];
Cre le tableau ayant la forme suivante:
x x x
x x x
x x x
Le nombre des sous-tableaux peut tre obtenu en utilisant la variable length.
Chapitre 3. Tableaux et chanes de caractres
48
Exemple:
int[][] tab={{1,2,9},{12,8},{11,15,9,10}};
tab.length3
tab[1].length2
Exercice:
Crer un tableau qui a la forme ci-dessous puis afficher ses valeurs:
Sous tableau1: 10 20
Sous tableau2: 30
Solution:
// Dclaration et cration
int[][] tab = new int[2][];
tab[0] = new int[2];
tab[1] = new int[1];
// Remplir par des valeurs
tab[0][0] = 10;
tab[0][1] = 20;
tab[1][0] = 30;
// Afficher les valeurs
for (int i = 0; i < tab.length; i++) {
System.out.println("Sous tabelau n "+ i);
for (int j = 0; j < tab[i].length; j++) {
System.out.println( tab[i][j]);
}
}
L'excution donne:
Sous tableau n 0
10
20
Sous tableau n 1
30
2. Les chanes de caractres Le type String sert reprsenter des chaines de caractres en Java. Il ne s'agit pas
d'un tableau de caractres comme en C. String est une classe qui est fourni avec lAPI
Java, elle dcrit des objets qui contiennent une chane de caractre constante. Voici un
exemple de dclaration est initialisation d'une chaine:
Chapitre 3. Tableaux et chanes de caractres
49
String s=Bonjour ISET";
Les oprateurs + et += servent pour la concatnation des chanes de caractres.
Java permet un traitement trs riche des chanes de caractres grce un ensemble
mthodes prdfinies. Les plus utiliss sont dcrits dans le tableau qui suit.
mthode de la classe
String
Utilit Exemple pour
String s=Bonjour RSI";
int length() retourne le nombre de
caractres de la chane.
System.out.println(s.length());
11
boolean isEmpty() true si la chanine est
vide, false sinon
System.out.println(s.isEmpty());
false
char charAt(int i) retourne la caractre qui
se trouve la position i.
System.out.println(s.charAt(2));
n
boolean equals(String
s)
effectue la comparaison
de 2 chanes (elles sont
gales si elles
contiennent la mme
suite de caractres)
if(s.equals("Bonjour RSI")) {} true
if (s.equals("BONJOuR RSI")) {}
false
boolean
equalsIgnoreCase(Stri
ng s)
Comme la mthode
"equals" mais elle ignore
la case. (majuscule ou
minuscule)
if (s.equals("BONJOuR RSI")) {}
devient true
String toLowerCase () Retourne une chaine avec
les caractres en
minuscule.
System.out.println(s.toLowerCase());
bonjour rsi
String toUpperCase () Retourne une chaine avec
les caractres en
majuscule.
System.out.println(s.toUpperCase());
BONJOUR RSI
int indexOf(String ch,
int i)
retourne la position de la
chaine ch partir de la
position i.
System.out.println(s.indexOf("jour",
2)); 3
String replace(char
oldChar, char
newChar)
Remplace un caractre
par un autre.
System.out.println(s.replace('o', 'i'));
Binjiur RSI
String substring(int i,
int j)
retourne une chane
extraite de la chane sur
laquelle est applique la
mthode en partant de la
position i la position j.
System.out.println(s.substring(1, 4));
onj
Chapitre 3. Tableaux et chanes de caractres
50
boolean endsWith
(String suffix)
Teste si la chaine fini par
la chaine suffixe. (il
existe aussi la mthode
startsWith )
System.out.println(s.endsWith("RSI")
);
true
Ces mthodes facilitent les oprations traditionnelles que le dveloppeur Java pourrait
avoir besoin, ce qui permet un gain de temps et d'effort. Ceci met l'accent sur un des
avantages qui ont fait le succs du langage Java: une API riche.
Remarque: La classe StringBuffer permet de reprsenter une chaine de taille variable.
3. Srie d'exercices
Exercice 1
Soit la classe suivante:
class Personne {
//les attributs
private String nom;
private String prenom;
private int age;
// constructeur
public Personne(String nom, String prenom, int age) {
this nom=nom;
this.age = age;
this.prenom = prenom; }
//Mthode qui retourne l'age
public int getAge() { return age; }
} // Fin classe
Donner la mthode main permettant de:
- crer puis remplir un tableau de 3 personnes
- Le remplir
- afficher la somme de leurs ges.
Solution
public static void main(String[] args) {
Personne tab[] = new Personne[3];
tab[0] = new Personne("Mohamed", "Amine", 20);
tab[1] = new Personne("Manel", "Mohamed", 15);
tab[2] = new Personne("Ali", "Saleh", 36);
Chapitre 3. Tableaux et chanes de caractres
51
int somme = 0;
for (int i = 0; i < tab.length; i++) {
somme = somme + tab[i].getAge();
}
System.out.println("La somme des ages est : " + somme);
}
Exercice 2
1. Crer la classe ChainePlindrome contenant un attribut str de type String.
2. Doter la classe d'un constructeur permettant d'initialiser la chaine par la chaine
passe en paramtre
3. Donner la mthode inverser qui retourne l'inverse de str
4. Donner la mthode estPalindrome qui teste si une chaine est palindrome (se lit de
la mme manire de droite gauche et de gauche droite)
5. Donner la classe TestChainePalindrome permettant de tester la classe prcdente.
Solution
public class ChainePlindrome {
// attributs privs
private String str;
// constructeur
public ChainePlindrome(String str) {
this.str = str;
}
// La mthode inverser qui inverse la chaine
public String inverser (){
String res="";
for (int i =str.length()-1;i>=0; i--) {
res+=str.charAt(i);
}
return res;
}
// la mthode estPalindrome qui teste si une chaine est palindrome
public boolean estPalindrome () {
if (str.equals(this.inverser()))
return true;
return false;
}
}
Chapitre 3. Tableaux et chanes de caractres
52
class TestChainePalindrome{
public static void main(String[] args) {
ChainePlindrome ch= new ChainePlindrome("aziza");
if (ch.estPalindrome())
System.out.println("La chaine est palindrome");
else
System.out.println("La chaine n'est pas palindrome");
}
}
Chapitre 4. Association et agrgation entre les classes
53
Chapitre 4. Association et agrgation entre
les classes
Objectifs
Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances
de base se rapportant aux objectifs spcifiques suivants:
Etre capable de comprendre les relations d'association ou d'agrgation entre les
classes.
- Crer des classes java avec des relations d'association ou agrgation entre les elles.
Pr-requis
Classes et objets en Java
Manipulation des tableaux.
Elm
Top Related