cours java

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


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.


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.


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


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


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;


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 :


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)


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


10


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.


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 ()

{


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;



}

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


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


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


15

8. Srie d'exercices

Exercice 1

Ecrire un programme qui initialise deux entiers puis affiche leur somme et leur produit.

Solution


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


final int N = 4;

int n;

int fact;

n = 1;

fact = 1;

while ( n


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


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;


17

else

a = a - b;

System.out.print("PGCD("+a+","+b+") = ");

}


}

}

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


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

[] [=];


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.


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 " +


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.


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.


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() {

}


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;

}


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 {


Personne pers = new Personne("Mohamed", "benMohamed", 20) ;

pers.afficherPrenom();

pers.incrementerAge();

System.out.println("l'ge devient: "+ pers.age);

}

}


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 {


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 {


Ordinateur ord = new Ordinateur(12, "Dell", 1024);

ord.afficherOrdinateur();

}

}

Excution

****Ordinateur****

id: 12Marque: Dell


28

public class TestMatiere {


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.


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 {


String nom, prenom;

int age;

//Premier constructeur


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 ");


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.


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?


33

class Personne {


private int id;

static int compteur=0;

//_____les constructeurs

public Personne() {

compteur++;

id= compteur; } // ceci permet d'avoir des id successifs

}

class TestPersonne {


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;


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;


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.


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


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 {


// 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) {.}


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:


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


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 {


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.


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


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);

}


43

}

class TestComplexe {


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


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 :


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;


if (tab[i]%2 ==0)

sPaires += tab[i];


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.


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


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:


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


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


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);


51

int somme = 0;


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;

}

}


52

class TestChainePalindrome{


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

cours java

Documents