Vous êtes sur la page 1sur 115

REPUBLIQUE TUNISIENNE

MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE


LA RECHERCHE SCIENTIFIQUES ET TECHNOLOGIQUES

Institut Supérieur des Etudes ‫المعهد العالي للدراسات التكنولوجية‬


Technologiques de Kasserine
‫بالقصرين‬

Département Technologies de
l’Informatique

SUPPORT DE COURS
Avec exercices corrigés

Programmation Orientée Objet

Elaboré par :

Mme. Laila NAKKAII Enseignante Technologue à l‟ISET de Kasserine

Année Universitaire : 2015/2016

0
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Table des matières

Avant-propos ........................................................................................................................................... 5

Chapitre 1: Introduction à la Programmation Objet en Java ................................................................. 6

Introduction............................................................................................................................................. 6

1. Présentation de Java ........................................................................................................................ 6

2. Interprétation d‟un programme Java ............................................................................................... 7

3. Caractéristiques et avantages de Java ............................................................................................. 7

4. Les techniques de base de la programmation en Java ..................................................................... 9

5. Le concept de classe ........................................................................................................................ 9

Conclusion ............................................................................................................................................. 10

Chapitre 2: Types et instructions de base du langage JAVA ................................................................ 11

Introduction ........................................................................................................................................... 11

1. Types simples ................................................................................................................................ 11

2. Enoncés élémentaires .................................................................................................................... 12

3. Flot de contrôle .............................................................................................................................. 12

1.1 Bloc d'instructions ................................................................................................................. 12

1.2 Instruction conditionnelle ...................................................................................................... 13

1.3 Instructions itératives ............................................................................................................ 13

2. Affichage de résultats sur la console ............................................................................................. 14

3. Les tableaux................................................................................................................................... 15

3.1 La déclaration des tableaux ................................................................................................... 15

3.2 L'initialisation explicite d'un tableau ..................................................................................... 16

3.3 Le parcours d'un tableau ........................................................................................................ 16

4. Les conversions de types ............................................................................................................... 17

4.1 La conversion d'un entier int en chaîne de caractère String .................................................. 18

5. La manipulation des chaînes de caractères .................................................................................... 18

5.1 Les caractères spéciaux dans les chaines............................................................................... 19

Page 1
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

5.2 L'addition de chaines ............................................................................................................. 20

5.3 La comparaison de deux chaines ........................................................................................... 20

5.4 La détermination de la longueur d'une chaine ....................................................................... 21

5.5 La modification de la casse d'une chaine .............................................................................. 21

Conclusion ............................................................................................................................................. 22

Chapitre 3: Eléments de base de la programmation objet avec le langage JAVA ............................... 23

Introduction ........................................................................................................................................... 23

1. Notion d‟objet................................................................................................................................ 23

1.1 Définition............................................................................................................................... 23

1.2 Objets, tableaux et types de base ........................................................................................... 24

2. Notion de classe............................................................................................................................. 25

2.1 Définition d‟une classe .......................................................................................................... 25

2.2 Déclaration des attributs ........................................................................................................ 25

2.3 Définition des méthodes ........................................................................................................ 25

3. Création d‟objet ............................................................................................................................. 27

Conclusion ............................................................................................................................................. 29

Chapitre 4: Constructeur et Destructeur de classe ............................................................................... 30

Introduction ........................................................................................................................................... 30

1. Constructeur de classe ................................................................................................................... 30

1.1 Définition............................................................................................................................... 30

1.2 Utilisation des constructeurs.................................................................................................. 30

2. Utilisation d‟un objet ..................................................................................................................... 33

2.1 Accès à un attribut ................................................................................................................. 33

2.2 Invocation d‟une méthode ..................................................................................................... 34

2.3 Surcharge des méthodes ........................................................................................................ 35

3. Attributs et méthodes de classe ..................................................................................................... 37

3.1 Attribut de classe ................................................................................................................... 37

3.2 Méthode de classe ................................................................................................................. 37

Page 2
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

4. Les références ................................................................................................................................ 38

4.1 L‟autoréférence „‟this‟‟ ......................................................................................................... 38

4.2 La référence „‟null „‟ ............................................................................................................. 40

5. Destruction d‟un objet ................................................................................................................... 40

Conclusion ............................................................................................................................................. 41

Chapitre 5: Mode de passage des paramètres, Packages et Modificateurs de visibilités ..................... 43

Introduction ........................................................................................................................................... 43

1. Mode de passage des paramètres ................................................................................................... 43

2. Classes internes ............................................................................................................................. 45

3. Les paquetages .............................................................................................................................. 46

4. Bibliothèque .................................................................................................................................. 47

5. Les modificateurs de visibilité....................................................................................................... 48

Conclusion ............................................................................................................................................. 49

Chapitre 6: Héritage et Polymorphisme avec Java .............................................................................. 50

Introduction ........................................................................................................................................... 50

1. Constructeurs et héritage ............................................................................................................... 51

1.1 Constructeurs ......................................................................................................................... 51

1.2 Le mot réservé final ............................................................................................................... 54

1.3 Opérateur instanceof.............................................................................................................. 54

2. Redéfinition de méthodes .............................................................................................................. 55

3. Polymorphisme: Recherche dynamique des méthodes ................................................................. 55

4. Classe abstraite .............................................................................................................................. 57

5. Interface ......................................................................................................................................... 57

Conclusion ............................................................................................................................................. 61

Chapitre 7: Gestion des exceptions....................................................................................................... 62

Introduction ........................................................................................................................................... 62

1. Utilisation ...................................................................................................................................... 62

2. Transmission d‟information au gestionnaire d‟exception ............................................................. 64

Page 3
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

3. Poursuite de l‟exécution ................................................................................................................ 65

4. Choix du gestionnaire d‟exception ................................................................................................ 66

5. Quelques exceptions standards ..................................................................................................... 69

Conclusion ............................................................................................................................................. 71

Liste des Travaux Dirigées ..................................................................................................................... 72

TD1 : Syntaxe et Eléments de base du langage Java ............................................................................. 73

Correction TD1 : Syntaxe et Eléments de base du langage Java........................................................... 76

TD2 : Notion d'Objet, Classe et Constructeur ....................................................................................... 80

Correction TD2 : Notion d'Objet, Classe et Constructeur ..................................................................... 82

TD3 : Objet, Classe, Attribut de classe .................................................................................................. 85

Correction TD3 : Objet, Classe, Attribut de classe ................................................................................. 89

TD4 : Modificateurs de visibilité ............................................................................................................ 93

Correction TD4 : Modificateurs de visibilité .......................................................................................... 95

TD5 : Héritage et polymorphisme ......................................................................................................... 96

Correction TD5 : Héritage et polymorphisme ..................................................................................... 100

TD6 : Exception .................................................................................................................................... 106

Correction TD6 : Exception .................................................................................................................. 108

Bibliographie ....................................................................................................................................... 113

Page 4
Avant-propos

Cet ouvrage « PROGRAMMATION OBJET » est fondé sur les notes d‟un cours dispensé pendant
plusieurs années à l‟ISET de Kasserine.
Ce support de cours permet d‟expliquer en termes simples et à travers de multiples exemples et
exercices corrigés comment apprendre à programmer en orientée objet et connaitre la spécificité du
langage java.
Les chapitres du livre sont tous structurées de la même manière. Chaque chapitre débute par un petit
encart indiquant les objectifs à attendre suite à la lecture du dit chapitre ainsi qu‟un descriptif succinct
du contenu du chapitre.

Cet ouvrage a pour objectifs :

 Traiter les notions fondamentales de l‟orienté objet et traite les caractéristiques fondamentales
du langage java.
 Maitriser éléments de la programmation orientée java en langage java : objet, classe, attributs
et méthodes.
 Comprendre la notion du constructeur et de ses utilisations.
 Connaitre les types et les instructions de base du langage java.
 Traiter le mode de passage des paramètres, les packages et les modificateurs de visibilités.
 Comprendre le mécanisme d‟héritage et la notion du polymorphisme.
 Traiter la notion d‟exception.

L‟information contenue dans ce cours a été choisie et organisée de la meilleure façon possible afin
d‟être exhaustive tout en étant également assimilable par l‟étudiant.

Laila NAKKAII
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Chapitre 1: Introduction à la Programmation Objet en Java

Objectifs

 Présenter les caractéristiques du langage Java.


 Définir les techniques de base de la programmation Java.

Introduction
La programmation orientée objet existe depuis 1967, cependant, elle n‟est vraiment devenue un des
paradigmes de la programmation qu‟au milieu des années 1980.

Au contraire de la programmation structurée traditionnelle, la programmation orientée objet met dans


une même et unique structure les données et les opérations qui leurs sont associées.

En programmation traditionnelle, les données et les opérations sur les données sont séparées, les
structures de données sont donc envoyées aux procédures et fonctions qui les utilisent.

La programmation orientée objet résout de nombreux problèmes inhérents à cette conception en


mettant dans une même entité les attributs et les opérations (encapsulation des données et des
traitements). Cela est plus proche du monde réel, dans lequel tous les objets disposent d‟attributs
auxquels sont associés des activités.

Java est un pur langage orienté objet, ce qui signifie que le niveau le plus externe de la structure des
données est l‟objet. Il n‟y a pas de constante, de variable ni de fonction indépendante en Java. On
accède à toute chose via les classes et les objets. C‟est un des aspects les plus agréables de Java.

D‟autres langages orientés objets plus hybrides ont conservé des aspects des langages structurés en
plus de leurs extensions objet. Par exemple, C++ et Pascal Objet sont des langages orientés objet, mais
permettent toujours d‟écrire des programmes structurés, ce qui diminue l‟efficacité des extensions
orientées objet.

1. Présentation de Java
Java est un environnement de programmation orientée objets adapté à la distribution d‟applications sur
Internet et s‟intégrant au Web.

Vers la fin de 1995, le langage de programmation Java (Développé par Sun Microsystems) surgit sur
la grande scène d'Internet et obtient immédiatement un énorme succès. Il s'agit d'un langage de
conception très performant qui a été adopté par la majorité des fournisseurs.

Il se compose de 4 éléments :

6
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

 un langage de programmation
 une machine virtuelle (JVM)
 Un ensemble de classes standards réparties dans différentes API (Application
Programming Interface) : Cette API fournit aussi bien des éléments de base de langage
java que des fonctionnalités plus complexes comme la programmation d‟interface
graphique

 Un ensemble d‟outils (jdb, javadoc, ...)

2. Interprétation d’un programme Java


Tout d‟abord, Java simplifie le processus de développement; quelle que soit la machine sur
laquelle le codage est réalisé, le compilateur fournit le même code. Ensuite, quel que soit le
système utilisé par les utilisateurs, cet unique code est directement opérationnel.

En effet, la compilation d‟une source Java produit du pseudo-code Java qui sera exécuté par
tout interpréteur Java sans aucune modification ou recompilation.

Cet "interpréteur" est la "machine virtuelle Java". De plus en plus, cette machine virtuelle
utilise un compilateur JIT (“Just In Time”) qui transforme, au moment de l‟exécution, le
pseudo-code en code natif (code machine pour un type d'ordinateur précis) afin d‟obtenir la
vitesse d‟exécution maximale.

Pour des applications l‟API Java apporte un ensemble très riche de classes répondant à de
nombreux besoins et pouvant être étendue, cette unique API simplifie la création et le
déploiement des applications, en effet cette application s‟exécutera sur tout système en
utilisant l‟aspect visuel de ce dernier.

3. Caractéristiques et avantages de Java


Les caractéristiques fondamentales de Java se résument selon les 13 termes suivants :

Simple : Java a été conçu de façon relativement proche du langage C++. De nombreuses fonctions
compliquées, mal comprises, rarement utilisées de C++ (pointeur, surcharge dynamique, héritage
multiple,...), qui semblent apporter plus d'inconvénients que d'avantages, ont été supprimées de Java.

Fiable : Java a été conçu pour que les programmes qui l'utilisent soient fiables sous différents
aspects. Sa conception encourage le programmeur à traquer préventivement les éventuels problèmes, à
lancer des vérifications dynamiques en cours d'exécution et à éliminer les situations génératrices
d'erreurs

7
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Orienté objet : Java se concentre sur les objets et sur les interfaces avec ces objets. Java offre de
nombreuses classes permettant de définir et de manipuler les objets.

Distribué : Java possède une importante bibliothèque de routines permettant de gérer les protocoles
TCP/IP tels que HTTP et FTP. Les applications Java peuvent charger et accéder à des pages sur
Internet via des URL avec la même facilité qu'elles accèdent à un fichier local sur le système.

Sécurité : Java a été conçu pour être exploité dans des environnements serveur et distribués. Dans
ce but, la sécurité n‟a pas été négligée. Java permet la construction de systèmes inaltérables et sans
virus.

Sûr : La sécurité fait partie intégrante du système d'exécution et du compilateur. Un programme


Java planté ne menace pas le système d'exploitation. Il ne peut y avoir d'accès direct à la mémoire.
L'accès au disque dur est réglementé dans une applet. Les programmes fonctionnant sur le Web sont
soumis aux restrictions suivantes dans la version 1.0 de Java :

 Aucun programme ne peut ouvrir, lire, écrire ou effacer un fichier sur le


système de l'utilisateur
 Aucun programme ne peut lancer un autre programme sur le système de
l'utilisateur
 Toute fenêtre créée par le programme est clairement identifiée comme
fenêtre Java, ce qui interdit par exemple la création d'une fausse fenêtre
demandant un mot de passe
 Les programmes ne peuvent pas se connecter à d'autres sites Web que celui
dont ils proviennent.
Architecture neutre : Le compilateur génère un format de fichier objet dont l‟architecture est
neutre. Le code compilé est exécutable sur de nombreux processeurs, à partir du moment où le
système d‟exécution de Java est présent.

Portable : A la différence du C/C++, on ne trouve pas les aspects de dépendance de la mise en


œuvre dans la spécification. Les tailles des types de données primaires sont spécifiées, ainsi que le
comportement arithmétique qui leur est applicable.

Interprété : La source est compilé en pseudo code puis exécuté par un interpréteur Java (la Machine
Virtuelle Java (JVM)).

Indépendant de toute plateforme : L‟interpréteur Java peut exécuter le bytecode directement sur
n‟importe quelle machine sur laquelle il a été porté. Il n'y a pas de compilation spécifique pour chaque
plate forme.

8
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Performances élevées : En général, les performances des bytecodes interprétés sont tout à fait
suffisantes, il existe toutefois des situations dans lesquelles des performances plus élevées sont
nécessaires.

Multithread : Il permet l'utilisation de threads qui sont des unités d'exécution isolées. La JVM elle-
même utilise plusieurs threads. Ce qui permet des traitements multitâches dans une même application.
Les avantages du multithread sont une meilleure inter-réactivité et un meilleur comportement en temps
réel.

Dynamique : Java a été conçu pour s‟adapter à un environnement qui évolue, et pousse le concept
orienté objet à son optimum en permettant l‟édition des liens entre modules objets dynamiquement au
moment de l‟exécution, en particulier dans le cas ou une application s‟appuie sur une librairie de
classes (une librairie de composants logiciels).

4. Les techniques de base de la programmation en Java


On peut résumer les techniques de base de la programmation en java par les points
suivantes :

 N'importe quel éditeur de texte peut être utilisé pour éditer un fichier source Java
 Il est nécessaire de compiler la source pour le transformer en J-code ou byte-code Java
qui sera lui exécuté par la machine virtuelle
 Il est préférable de définir une classe par fichier. Le nom de la classe publique et le
fichier qui la contient doivent être identiques (il faut respecter la casse)
 Pour être compilé, le programme doit être enregistré au format de caractères Unicode :
une conversion automatique est faite par le JDK si nécessaire.

5. Le concept de classe
Une classe est le support de l'encapsulation : c'est un ensemble de données et de fonctions regroupées
dans une même entité.

Une classe est une description abstraite d'un objet. Les fonctions qui opèrent sur les données sont
appelées des méthodes. Instancier une classe consiste à créer un objet sur son modèle. Entre classe et
objet il y a, en quelque sorte, le même rapport qu'entre type et variable.

Dans Java, tout appartient à une classe sauf les variables de types primitifs (int, float...). Pour
accéder à une classe il faut en déclarer une instance de cette classe (ou un objet).

Une classe comporte sa déclaration, des variables et la définition de ses méthodes. Une classe se
compose de deux parties : un en-tête et un corps.

9
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Le corps peut être divisé en deux sections : la déclaration des données et des constantes et la
définition des méthodes. Les méthodes et les données sont pourvues d'attributs de visibilité qui gère
leur accessibilité par les composants hors de la classe.

Exercice
Prenez comme exemple une de vos activités sportives, culturelles, artistiques ou sociales, et faites une
liste des objets impliqués dans cette activité. Dans un premier temps, créez ces objets sous formes de
couples attribut/ valeur. Dans un deuxième temps, réfléchissez au lien d‟interaction existant entre ces
objets ainsi qu‟à la manière dont ils sont capables de s‟influencer mutuellement. Dans un troisième
temps, identifiez pour chaque objet une possible classe le caractérisant.

Solution
Les arts de l‟expression : musique, chant, voix, écriture, lecture, mime
-Les activités : Jouer, chanter, danser, écrire…
-Séance –Entraînement-Répétition, durée….
-Appareil musicale-Type, catégorie, prix, son….,

Conclusion
Dans ce premier chapitre on a défini le principe de la programmation orientée objet et on a introduit
les caractéristique de base du langage java, un langage orienté objet utilisé dans ce cours.

10
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Chapitre 2: Types et instructions de base du langage JAVA

Objectifs

 Savoir déclarer et manipuler les différents types en Java.


 Maitriser les flots de contrôle.

Introduction
Un programme en langage JAVA consiste en une série d'énoncés (statements) organisés en blocs. Ces
énoncés définissent des données et des opérations sur ces données. La fin de chaque énoncé est
marquée par un « ;. » Ce caractère indique à l'interpréteur JAVA que l'énoncé est complet, qu'il doit
être exécuté avant de passer à l'énoncé suivant. L'ordre dans lequel l'interpréteur JAVA exécute les
énoncés s'appelle le flôt d'exécution ou flôt de contrôle.

1. Types simples
Type désignation opérations

byte entiers sur 8 bits


short entiers sur 16 bits unaire : +, -
Entiers
int entiers sur 32 bits binaire : +, -, *, / %
long entiers sur 64 bits

float réels simple précision (32 bits) unaire : +, -


Réels
double réels double précision (64bits) binaire : +, -, *, /

Caractère Char

&& et logique
Booléen Boolean || ou logique
! négation

Relation d'ordre : elle est définie sur tous les types simples.

strictement supérieur strictement inférieur


Egal différent
supérieur ou égal inférieur ou égal

== != > >= < <=

11
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

2. Enoncés élémentaires

 Déclaration d'une variable

Avant d'être utilisée dans un programme une variable doit être déclarée.

déclaration: exemples:
type identificateur ; byte age;
boolean jeune;
float poids;

Une variable est accessible (visible) depuis l'endroit où elle est déclarée jusqu'à la fin du bloc où sa
déclaration a été effectuée.

 Opérateur d'affectation

Permet de donner une valeur à une variable

affectation: exemples:
lvalue = expression ; age = 10;
jeune = true;
lvalue est une expression qui doit délivrer une variable poids = 71.5f;
(par exemple un identificateur de variable, élément de
tableau...., mais pas une constante)
Attention en JAVA comme en C, l'affectation est un i = j = 10;
opérateur. L'affectation peut donc être utilisée comme
une expression dont la valeur est la valeur affectée à la
variable.

3. Flot de contrôle
1.1 Bloc d'instructions

Permet de grouper un ensemble d'instructions en lui donnant la forme syntaxique d'une seule
instruction

instruction composée: exemples:


{ int k;
sequence d'enoncés } {
int i = 1;

12
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

int j = 12;
j = i+1;
k = 2 * j - i;
}

1.2 Instruction conditionnelle


syntaxe: exemples:
if ( expression booléenne ) instruction1 ; if (i==j)
{
ou bien j = j -1;
i = 2 * j;
if ( expression booléenne )
}
instruction1 ;
else
else
i = 1;
instruction2 ;

sémantique : expression booléeene est évaluée. Si sa


valeur vaut true, instruction1 est exécutée,
sinon instruction2 si elle existe est exécutée.

1.3 Instructions itératives

Ces structures de contrôle permettent d'exécuter des instructions de manière répétitive.

 Instruction while (boucle tantque ... faire)

syntaxe: exemple:
while ( expression booléenne ) int i = 0;
instruction ; int somme = 0;
while (i <= 10)
{
somme += i;
sémantique : i++;
1) expression booléeene est évaluée. Si sa valeur vaut true, }
l'étape 2 est réalisée sinon l'exécution de System.out.println("Somme des 10
l'instruction while est terminée premiers entiers" + somme);
2) instruction est exécutée, puis l'étape 1) est renouvelée.

13
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

 Instruction do-while (boucle faire .... tantque)

syntaxe: exemple:
do int i = 0;
instruction ; int somme = 0;
while ( expression booléenne ) ; do
{
sémantique : somme += i;
i++;
1) instruction est exécutée } while (i <= 10);
2) expression booléeene est évaluée. Si sa valeur vaut true, System.out.println("Somme des 10
l'étape 1 est renouvelée sinon l'exécution de l'instruction do premiers entiers" + somme);
while est terminée

 Instruction for (boucle pour)

syntaxe: exemple:
for (expression1 ; expression2; expression3) int i = 0;
instruction ; int somme = 0;
sémantique : for (i = 0; i <= 10; i++)
somme += i;
1) expression1 est évaluée (en général elle initialise un
itérateur (variable de comptage du nombre d'itérations), System.out.println("Somme des 10
cf. l'affectation qui est une expression). Cette premiers entiers" + somme);
expression n'est évaluée qu'une seule fois.
2) expression 2 est évaluée, si sa valeur vaut true le
contrôle passe à l'étape 3 sinon l'exécution de
l'instruction for est terminée
3) instruction est exécutée, puis expression3 est évaluée
(en général elle modifie l'itérateur) puis l'étape 1 est
renouvellée. expression3 est ainsi évaluée après chaque
itération.

2. Affichage de résultats sur la console

La phrase System.out.print(chaine de caractères à afficher) affiche la chaîne sur la console


System.out.println(chaine de caractères à afficher) affiche la chaîne sur la console avec un retour à la
ligne,la chaîne de caractères qui définit le texte à afficher peut être :

14
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

 une constante chaîne de caractères (String) .


o System.out.println("coucou"); // affiche le texte coucou
 une expression de type String
o System.out.println(age); // affiche la valeur de la variable age
 une combinaison (concaténation) de constantes et d'expressions de type String. La
concaténation est exprimée à l'aide de l'opérateur +
o System.out.println("L'âge de la personne est " + age + " , son poids " + poids + "kg");
produit sur la console la chaîne : L'âge de la personne est 12 , son poids :
33.333333333333336 kg

Remarque : dans les expressions de type String, les variables de type simple sont automatiquement
converties en chaîne de caractères.

3. Les tableaux
Ils sont dérivés de la classe Object : il faut utiliser des méthodes pour y accéder dont font partie des
messages de la classe Object tel que equals() ou getClass(). Le premier élément d'un tableau possède
l'indice 0.

3.1 La déclaration des tableaux


Java permet de placer les crochets après ou avant le nom du tableau dans la déclaration.

Exp1:

int tableau[] = new int[50]; Déclaration et allocation


// OU int[] tableau = new int[50];
Déclaration
OU int tab[];
tab = new int[50]; Allocation

Java ne supporte pas directement les tableaux à plusieurs dimensions : il faut déclarer un tableau de
tableau.

Exp2 :

float tableau[][] = new float[10][10];

Exp3:

int dim1[][] = new int[3][];


La taille des tableaux de la seconde
dim1[0] = new int[4];
dimension peut ne pas être identique pour
dim1[1] = new int[9]; chaque occurrence. 15
dim1[2] = new int[2];
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Chaque élément du tableau est initialisé selon son type par l'instruction new : 0 pour les numériques,
'\0' pour les caractères, false pour les booléens et nil pour les chaines de caractères et les autres objets.

3.2 L'initialisation explicite d'un tableau


Exemples :

Exp1 :

int tableau[5] = {10,20,30,40,50};

int tableau[3][2] = {{5,1},{6,2},{7,3}};

Exp2:
La taille du tableau n'est pas obligatoire
int tableau[] = {10,20,30,40,50};
si le tableau est initialisé à sa création.

Exp3 :

int[][] tabEntiers = {{1,2,3,4,5,6},


Le nombre d'élément de chaque ligne
{1,2,3,4},{1,2,3,4,5,6,7,8,9}};
peut ne pas être identique :

3.3 Le parcours d'un tableau


Exemples :

Exp1:

for (int i = 0; i < tableau.length ; i ++) { ... }

La variable length retourne le nombre d'éléments du tableau. Pour passer un tableau à une méthode, il
suffit de déclarer les paramètres dans l'en tête de la méthode

Exp2:

public void printArray(String texte[]){ ...}

Les tableaux sont toujours transmis par référence puisque ce sont des objets. Un accès à un élément

d‟un table qui dépasse sa capacité, lève une exception du type :

16
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

java.lang.arrayIndexOutOfBoundsException.

4. Les conversions de types


Lors de la déclaration, il est possible d'utiliser un cast :

Exemple :

int entier = 5;

float flottant = (float) entier;

La conversion peut entrainer une perte d'informations. Il n'existe pas en Java de fonction pour
convertir : les conversions de type se font par des méthodes. La bibliothèque de classes API fournit
une série de classes qui contiennent des méthodes de manipulation et de conversion de types
élémentaires.

Classe Rôle

String pour les chaines de caractères Unicode

Integer pour les valeurs entières (integer)

Long pour les entiers longs signés (long)

Float pour les nombres à virgules flottante (float)

Double pour les nombres à virgule flottante en double précision (double)

Les classes portent le même nom que le type élémentaire sur lequel elles reposent avec la première
lettre en majuscule.

Ces classes contiennent généralement plusieurs constructeurs. Pour y accéder, il faut les instancier
puisque ce sont des objets.

Exemple :

String montexte; L'objet montexte permet d'accéder aux


méthodes de la classe java.lang.String
montexte = new String("test");

17
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

4.1 La conversion d'un entier int en chaîne de caractère String


Exemple :

int i = 10;
valueOf est également définie pour
des arguments de type boolean, long,
String montexte = new String();
float, double et char
montexte =montexte.valueOf(i);

4.2 La conversion d'une chaîne de caractères String en entier int

Exemple :

String montexte = new String("10 ");

Integer monnombre=new Integer(montexte);

int i = monnombre.intValue(); //conversion d'Integer en int

4.3 La conversion d'un entier int en entier long

Exemple :

int i=10;

Integer monnombre=new Integer(i);

long j=monnombre.longValue();

5. La manipulation des chaînes de caractères


La définition d'un caractère se fait grâce au type char :

Exemple :

char touche = '%';

La définition d'une chaîne se fait grâce à l'objet String :

18
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exemple :

String texte = "bonjour ";

Les variables de type String sont des objets. Partout ou des constantes chaînes de caractères figurent
entre guillemets, le compilateur Java génère un objet de type String avec le contenu spécifié. Il est
donc possible d'écrire :

String texte = "Java Java Java ".replace('a','o');

Les chaînes de caractères ne sont pas des tableaux : il faut utiliser les méthodes de la classe String d'un
objet instancié pour effectuer des manipulations.

Il est impossible de modifier le contenu d'un objet String construit à partir d'une constante. Cependant,
il est possible d'utiliser les méthodes qui renvoient une chaîne pour modifier le contenu de la chaîne.

Exemple :

String texte = "Java Java Java ";

texte = texte.replace('a','o');

Java ne fonctionne pas avec le jeu de caractères ASCII ou ANSI, mais avec Unicode (Universal
Code). Ceci concerne les types char et les chaînes de caractères. Le jeu de caractères Unicode code un
caractère sur 2 octets. Les caractères 0 à 255 correspondent exactement au jeu de caractères ASCII
étendu.

5.1 Les caractères spéciaux dans les chaines


Caractères spéciaux Affichage

\' Apostrophe

\" Guillemet

\\ Anti slash

\t Tabulation

\b retour arrière (backspace)

\r retour chariot

\f saut de page (form feed)

\n saut de ligne (newline)

19
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

\0ddd caractère ASCII ddd (octal)

\xdd caractère ASCII dd (hexadécimal)

\udddd caractère Unicode dddd (hexadécimal)

5.2 L'addition de chaines


Java admet l'opérateur + comme opérateur de concaténation de chaines de caractères.

L'opérateur + permet de concaténer plusieurs chaines. Il est possible d'utiliser l'opérateur +=

Exemple s:

String texte = " ";

texte += " Hello ";

texte += " World3 ";

Cet opérateur sert aussi à concaténer des chaînes avec tous les types de bases. La variable ou constante
est alors convertie en chaîne et ajoutée à la précédente. La condition préalable est d'avoir au moins une
chaîne dans l'expression sinon le signe '+' est évalué comme opérateur mathématique.

Exemple :

System.out.println(" La valeur de Pi est : "+Math.PI);

int duree = 121;

System.out.println("durée = "+duree);

5.3 La comparaison de deux chaines


Il faut utiliser la méthode equals()

Exemple :

String texte1 = "texte 1 ";

String texte2 = "texte 2 ";

if ( texte1.equals(texte2) )...

20
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

5.4 La détermination de la longueur d'une chaine


La méthode length() permet de déterminer la longueur d'une chaine.

Exemple :

String texte = "texte ";

int longueur = texte.length();

5.5 La modification de la casse d'une chaine


Les méthodes Java toUpperCase() et toLowerCase() permettent respectivement d'obtenir une chaîne
tout en majuscule ou tout en minuscule.

Exemple :

String texte = "texte" ;

String textemaj = texte.toUpperCase();

Exercice
Soit la chaîne de caractères suivante : "Jouer avec Java"

Réalisez séquentiellement les opérations et afficher les résultats de chaque opération à la console:

 longueur de la chaîne (méthode length()),


 conversion en majuscule (méthode toUpperCase()),
 conversion en minuscule (méthode toLowerCase()),
 concaténation avec la chaîne ":o",
 remplacer le caractère 'r' par le caractère 'z' (méthode replace(...)),
 comparer avec la chaîne "Jouer avec Pierre" (méthode compareTo(...)).
Solution
public class Chaine{ public static void main(String[] arg)

{ String ch; ch="Jouer avec Java";

String ch1="Jouer avec Pierre " ;

System.out.printl("la longueur de la chaine est"+ ch.length());

System.out.printl(ch.toUpperCase());

System.out.printl(ch.toLowerCase());

System.out.printl(ch+":o");

System.out.printl(ch.replace('r',' z'));

System.out.printl(ch.compareTo(ch1)) ; }}

21
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Conclusion
Ce premier chapitre a présenté la syntaxe de base du langage Java. Pour les déclarations des types
primitifs et des tableaux ou l‟utilisation des instructions de contrôle, la syntaxe est très proche de celle
du langage C.

Il y a cependant des différences importantes : il n‟y a pas de typedef, ni de déclarations de structures


(struct en C), ni de variables globales, ni de directives de compilation (#include, #define, etc.), ni de
pointeurs ; les entrées-sorties sont différentes (printf en C, System.out.println en Java), ainsi que la
gestion des chaînes de caractères ; enfin on a un passage des paramètres par valeur ce qui pose des
problèmes pour les types primitifs. La désallocation de mémoire est automatique.

Ce chapitre introductif présente donc en quelque sorte, un moyen de programmer en Java à la manière
C. Les notions de programmation objet ont été évitées. Les fonctions sont déclarées static, ce qui
signifie qu‟elles s‟appliquent sans la définition explicite d‟un objet.

22
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Chapitre 3: Eléments de base de la programmation objet avec le


langage JAVA

Objectif

 Maîtriser la notion d’objet


 Maîtriser la notion de classe.

Introduction
Le langage java est un langage de programmation orienté objet. Sa syntaxe est très proche de C et
C++ .Le but d‟une application java est de s‟exécuter sur n‟importe plate forme qui possède une
JVM .Le concept fondamental est l‟objet.

1. Notion d’objet
1.1 Définition
L‟objet est l‟unité de base de la conception orienté objet d‟un système informatique. Un objet
représente une entité réelle (personne, voiture….) ou une entité conceptuelle (cercle, rectangle….).Les
objets regroupe à la fois des données (attributs) et des fonctionnalités (méthodes) permettant de
manipuler les attributs. Les attributs décrivent l‟état de l‟objet et les méthodes permettent à l‟objet
d‟effectuer des opérations éventuellement changer d‟état.

Des concepteurs de langage ont décrété que la programmation orientée objet en elle-même n'était pas
adéquate pour résoudre facilement tous les problèmes de programmation, et recommandent la
combinaison d'approches variées dans des langages de programmation multi-paradigmes.

Alan Kay résume les cinq caractéristiques principales de Smalltalk, le premier véritable langage de
programmation orienté objet et l'un des langages sur lequel est basé Java. Ces caractéristiques
représentent une approche purement orientée objet :

1. Toute chose est un objet. Il faut penser à un objet comme à une variable améliorée : il stocke des
données, mais on peut « effectuer des requêtes » sur cet objet, lui demander de faire des opérations sur
lui-même. En théorie, on peut prendre n'importe quel composant conceptuel du problème qu'on essaye
de résoudre (un chien, un immeuble, un service administratif, etc...) et le représenter en tant qu'objet
dans le programme.

2. Un programme est un ensemble d'objets se disant les uns aux autres quoi faire en s'envoyant des
messages. Pour qu'un objet effectue une requête, on « envoie un message » à cet objet. Plus

23
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

concrètement, on peut penser à un message comme à un appel de fonction appartenant à un objet


particulier.

3. Chaque objet a son propre espace de mémoire composé d'autres objets. Dit d'une autre manière,
on crée un nouveau type d'objet en créant un paquetage contenant des objets déjà existants. Ainsi, la
complexité d'un programme est cachée par la simplicité des objets mis en œuvre.

4. Chaque objet est d'un type précis. Dans le jargon de la POO, chaque objet est une instance d'une
classe, où « classe » est synonyme de « type ». La plus importante caractéristique distinctive d'une
classe est : « Quels messages peut-on lui envoyer ? ».

5. Tous les objets d'un type particulier peuvent recevoir le même message. C'est une caractéristique
lourde de signification, comme vous le verrez plus tard. Parce qu'un objet de type « cercle » est aussi
un objet de type « forme géométrique », un cercle se doit d'accepter les messages destinés aux formes
géométriques. Cela veut dire qu'on peut écrire du code parlant aux formes géométriques qui sera
accepté par tout ce qui correspond à la description d'une forme géométrique. Cette substituabilité est
l'un des concepts les plus puissants de la programmation orientée objet.

1.2 Objets, tableaux et types de base


Lorsqu'une variable est de type objet ou tableau, ce n'est pas l'objet ou le tableau lui-même qui est
stocké dans la variable mais une référence vers cet objet ou ce tableau (on retrouve la notion
d‟adresse mémoire ou du pointeur en C).

Lorsqu'une variable est de type de base, la variable contient la valeur.

 La référence est, en quelque sorte, un pointeur pour lequel le langage assure une
manipulation transparente, comme si c'était une valeur (pas de déréférencement).

 Par contre, du fait qu'une référence n'est pas une valeur, c'est au programmeur de prévoir
l'allocation mémoire nécessaire pour stocker effectivement l'objet (utilisation du new).

 Différences entre objets et types de base :

24
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

2. Notion de classe
Une classe est une description d‟un ensemble d‟objets ayant des propriétés et des comportements
communs. La classe sert de modèle de définition pour les objets en termes d‟attributs et méthodes :

2.1 Définition d’une classe


class <NomClasse>

//Déclarations des attributs

//Définition des méthodes

2.2 Déclaration des attributs


Les attributs sont des données de la classe ils sont considérés comme les variables globales à
l‟intérieur d‟une classe. Ils sont visibles pour toutes les méthodes de la classe.

Syntaxe :
[Modificateur de visibilité] <Type> <Nom de l’attribut> [=expression] <;>
[ ] Optionnel
<>Obligatoire

2.3 Définition des méthodes


Une méthode est équivalente d‟une procédure ou une fonction dans les autres langages ; Elle est
composée d‟un entête et un corps.

Syntaxe :

Entête

[Modificateur de visibilité] <Type de retour> <Nom de la méthode>< ([type argument


ARGUMENT,…….])>

Corps {

//Déclaration des variables locales

//Instructions
}

25
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

EXEMPLES :

Exemple1 :

public class Rectangle Comprendre l’exemple :


{
//Déclarations des attributs …………………………………………………………………………
…………………………………………………………………………
int longueur ;
…………………………………………………………………………
int largeur ; …………………………………………………………………………
//Définitions des méthodes …………………………………………………………………………
void allongerRectangle (int lg) …………………………………………………………………………
…………………………………………………………………………
{
…………………………………………………………………………
longueur+=lg ; …………………………………………………………………………
} …………………………………………………………………………
} …………………………………………………………………………
…………………………………………………………………………

Exemple2 :
Travailler l’exemple :

Il s'agit de modéliser un segment de droite ………………………………………………………………………


dont les valeurs des deux extrémités sont ………………………………………………………………………
………………………………………………………………………
entières.
………………………………………………………………………
Les opérations que l'on souhaite faire sur ………………………………………………………………………
ce segment sont : ………………………………………………………………………
• calculer sa longueur ………………………………………………………………………
………………………………………………………………………
• savoir si un entier donné se trouve sur le
………………………………………………………………………
segment (c'est-à-dire s'il est compris entre
………………………………………………………………………
la plus petite et la plus valeurs des ………………………………………………………………………
extrémités du segment). ………………………………………………………………………
Ecrire un programme qui contient : ………………………………………………………………………
………………………………………………………………………
• une classe Segment comportant
………………………………………………………………………
o deux attributs de type int, extr1 et extr2, ………………………………………………………………………
représentant les coordonnées (entières) des ………………………………………………………………………
extrémités d'un segment sur un axe ………………………………………………………………………
………………………………………………………………………
o une méthode retournant la longueur du
………………………………………………………………………
segment ………………………………………………………………………
o une méthode dont le prototype est : ………………………………………………………………………
………………………………………………………………………
………………………………………………………………………26
………………………………………………………………………
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

boolean appartient (int x); indiquant si le


point de coordonnée x appartient ou non au
segment

3. Création d’objet
La création d‟un objet se fait dans une classe externe à l‟aide de l‟operateur new qui se charge :

 D‟allouer l‟espace mémoire pour stocker l‟objet au cours de construction


 D‟appeler le constructeur de l‟objet adéquat pour initialiser les objets, le choix du
constructeur est fait en fonction des paramètres passés à l‟opérateur new
 Retourne une référence sur l‟objet crée

Syntaxe :

<Nom de classe><nom de l’objet> ;


<Nom d’objet>=new <Nom de classe> ([liste d’arguments]) ;

Ou bien

<Nom de la classe><nom de l’objet>=new <Nom de la classe> ([liste d’arguments]) ;

EXEMPLES:

Exemple1 :

Personne p ; Comprendre l’exemple

p=new Personne () ; ……………………………………………………………………


……………………………………………………………………
Personne p=new Personne () ;
……………………………………………………………………..

Exemple2 :

Remarque : La méthode main () est la première à être appelée qu‟on lance la JVM avec sa classe. Elle
se lance sans qu‟aucune instance de la classe qui le contient n‟existe.

27
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

public class Rectangle


Comprendre l’exemple
{
//Déclaration des attributs ………………………………………………………………………
………………………………………………………………………
int longueur, largeur ;
………………………………………………………………………
//Définition des méthodes ………………………………………………………………………
Rectangle(int lg,int larg) ………………………………………………………………………
{ ………………………………………………………………………
………………………………………………………………………
longueur=lg ;
………………………………………………………………………
largeur =larg ;
………………………………………………………………………
} ………………………………………………………………………
void allongerRectangle(int lg){ longueur +=lg ;} ………………………………………………………………………
}//fin de la classe Rectangle ………………………………………………………………………
………………………………………………………………………
………………………………………………………………………
class TestRectangle ………………………………………………………………………
{//class externe de la classe rectangle ………………………………………………………………………
public static void main(String[]args) ………………………………………………………………………
………………………………………………………………………
{//création de l’objet
………………………………………………………………………
Rectangle r1 ;
………………………………………………………………………
r1=new Rectangle(5,3) ;
}//fin de la classe TestRectangle

Exercice
Répondez aux questions suivantes :

a. Un même référent peut-il désigner plusieurs objets ?


b. Plusieurs référents peuvent-ils désigner un même et seul objet ?
c. Un objet peut-il faire référence à un autre ? si oui, comment ?
d. Pourquoi l‟objet a-t-il besoin d‟une classe pour exister ?
e. Un objet peut-il changer d‟état ? si oui, comment ?
f. Que signifie cette écriture a.f(x) ?
g. Où doit être déclarée f(x) pour que l‟instruction précédente s‟exécute sans problème ?
h. Qu‟appelle-t-on un envoi de message ?
i. Comment un premier objet peut-il agir de telle sorte qu‟un deuxième objet change d‟état suite à
cette action ?

Solution
a. Un référent ne peut désigner qu‟un seul objet puisqu‟il s‟agit en effet de l‟adresse de l‟objet et
qu‟un objet ne peut être placé que dans une adresse unique.
b. Plusieurs référents peuvent ceci dit partager cette adresse et ainsi pointer vers le même objet. Il
s‟agit d‟un système d‟adressage indirect. Cette multiplication des référents est un aspect
fondamental de la gestion mémoire par le « ramasse-miettes » dans les langages de
programmation qui le permettent.

28
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

c. Un objet peut en référer un autre en, par exemple, pour une association forte entre deux objets,
possédant parmi ses attributs l‟adresse d‟un autre objet.
d. En programmation orientée objet, tout ce que fait un objet est spécifié par sa classe. Cela permet
notamment au compilateur de vérifier que le code est correctement écrit. C‟est la classe qui
définit également les parties communes à tous les objets : types d‟attribut et méthodes.
e. Tout dépend de ce l‟on appelle l‟état d‟un objet mais, en substance, toute modification des
attributs d‟un objet ne peut se faire que par l‟exécution de méthodes qui sont prévues dans la
définition de la classe de l‟objet.
f. Cela signifie que la méthode « f(x) » s‟exécute sur l‟objet désigné par « a ».
g. La classe de l‟objet « a » contiendra en son sein la méthode « f(x) ». La méthode « f(x) » soit être
déclarée dans une des classes qui définit l‟objet « a ». Il faut connaître que cette méthode doit se
trouver dans une des classes qui décrit l‟objet « a ».
h. On appelle « envoi de message » la présence dans le code d‟une classe d‟un appel de méthode
s‟exécutant sur un autre objet. Lors de l‟exécution du code, un premier objet passera le relais à un
deuxième pour l‟exécution de cette méthode le concernant.
i. Il suffit que le message qui provoque l‟exécution de la méthode sur le deuxième ait
spécifiquement dans ses attributions la modification des attributs de ce deuxième.

Conclusion
En programmation objet, une classe (un objet) existe indépendamment d‟une application. On essaie de
répertorier toutes ses caractéristiques intrinsèques sans tenir compte d‟une application particulière.
Une application donnée n‟utilise souvent qu‟un sous ensemble des méthodes disponibles de la classe
d‟un objet.

Le principe d‟encapsulation des données fait que les données (les attributs, les caractéristiques) d‟un
objet ne sont accessibles que par l‟intermédiaire des méthodes qui constituent une interface non basée
sur les structures de données. Le concepteur de la classe peut modifier et optimiser ses structures de
données. Dès lors qu‟il ne modifie pas l‟interface, cela n‟a aucune incidence sur les programmes
utilisateurs.

29
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Chapitre 4: Constructeur et Destructeur de classe

Objectifs

 Savoir utiliser le constructeur et le destructeur de classe.

Introduction
L'appel de new pour créer un nouvel objet déclenche, dans l'ordre :

 L'allocation mémoire nécessaire au stockage de ce nouvel objet et l'initialisation par


défaut de ces attributs,

 L'initialisation explicite des attributs, s'il y a lieu,

 L'exécution d'un constructeur.

1. Constructeur de classe
1.1 Définition
Un constructeur est une méthode particulière appelé au moment de la création d‟un objet. Son rôle est
d‟initialiser l‟objet en fonction des paramètres fournis par l‟utilisateur. Le nom de constructeur
correspondant exactement au nom de la classe et aucun type de retourne doit être déclaré pour le
constructeur.

1.2 Utilisation des constructeurs


On donne les exemples pour l‟utilisation des constructeurs suivants :

Exemples :

Exp1 :

public class Personne public class Application Le constructeur est ici


{ celui par défaut (pas de
{public static void main(String args[]) constructeur défini dans
String nom ;
{Personne P=new Personne(); la classe Personne).
String prenom ;
int age ; P.setNom("Mohamed")
void setNom(String N)
}
{nom=N;}}

Remarque1 : Toute classe possède au moins un constructeur. Si le programmeur ne l'écrit pas, il en


existe un par défaut, sans paramètres, de code vide.
{p
30
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exp2 :

Définition d’un constructeur. Le


public class Personne
constructeur par défaut Personne()
{ n’existe plus. Le code précédent
String nom ; occasionnera une erreur.
String prenom ;
int age ;
public Personne(String n,String p,int a)
{nom=n;
prenom=p;
age=a;
}
void setNom(String N)
public class Application
{
{public static void main(String args[])
nom=N;
}} {Personne P=new Personne();

P.setNom("Mohamed")

}
Va donner une erreur à la compilation

Remarque2 :

 {p constructeurs, de signatures (prototypes)


Pour une même classe, il peut y avoir plusieurs
différentes (surcharge (avec des listes d‟arguments différents))
 L'appel de ces constructeurs est réalisé avec le new auquel on fait passer les paramètres :

Personne p1 = new Personne("NAKKAII", "Laila", 30);


 Déclenchement du "bon" constructeur :
Il se fait en fonction des paramètres passés lors de l'appel (nombre et types).
C'est le mécanisme de "lookup".

Attention !

Si le programmeur crée un constructeur (même si c'est un constructeur avec


paramètres), le constructeur par défaut n'est plus disponible. Attention aux erreurs
de compilation !

31
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exp3 :

public class Personne


{
String nom ;
String prenom ; Redéfinition d’un constructeur
int age ; sans paramètres
public Personne()
{nom=null;
prenom=null;
age=a;
}

public Personne(String n,String p,int a)


{nom=n;
prenom=p; On définit plusieurs constructeurs qui se
age=a; différencient uniquement par leurs
} paramètres (on parle de leur signature)

void setNom(String N)
{
nom=N;
}}

32
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exp4 :

public class Rectangle Comprendre l’exemple


{
………………………………………………………………
int longueur,largeur ; ………………………………………………………………
Rectangle(int lg,int larg) ………………………………………………………………
{ //premier constructeur ………………………………………………………………
………………………………………………………………
longueur =lg ;
………………………………………………………………
largeur=larg ;
……………………………………………………………….
}
………………………………………………………………
Rectangle()
………………………………………………………………
{ //second constructeur ………………………………………………………………
longueur =20 ;
………………………………………………………………
Travailler l’exemple :
largeur=10 ;
………………………………………………………………
} ………………………………………………………………
void allongerRectangle(int lg){longueur+=lg ;} ………………………………………………………………
}//fin de classe Rectangle ………………………………………………………………
class TestRectangle ………………………………………………………………
………………………………………………………………
{public static void main (String[]args)
………………………………………………………………
{//création de l‟objet ………………………………………………………………
Rectangle r1, r2 ; ………………………………………………………………
r1=new Rectangle(3,1) ; //appel du constructeur 1 ………………………………………………………………
………………………………………………………………
r2= new Rectangle () ; //appel du constructeur 1
………………………………………………………………
} ………………………………………………………………
}//fin class TestRectangle ………………………………………………………………
………………………………………………………………
………………………………………………………………
………………………………………………………………
………………………………………………………………
………………………………………………………………
2. Utilisation d’un objet
………………………………………………………………
2.1 Accès à un attribut ………………………………………………………………
Intérieur à la classe <nom de l’attribut>….

Attribut

Extérieur à la classe <nom de l’instance>.<nom de l’attribut>

 Pour accéder à un attribut à partir de l‟intérieur de la classe, l‟accès se fait toujours à


l‟intérieur d‟une méthode en appliquant le nom de l‟attribut que l‟on veut accéder

33
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

 Pour accéder à un attribut à partir de l‟extérieur de la classe, Il faut d‟abord créer une
instance à partir de cette classe et utilisé son nom suivant d‟un point et le nom de
l‟attribut que l‟on veut utiliser

2.2 Invocation d’une méthode


Intérieur à la classe <nom de la méthode>

méthode

Extérieur à la classe <nom de l’instance>.<nom de la méthode >

 Pour accéder à une méthode à partir de l‟intérieur de la classe, l‟accès se fait toujours
à l‟intérieur d‟une méthode en appliquant le nom de la méthode que l‟on veut accéder.
 Pour accéder à une méthode à partir de l‟extérieur de la classe, Il faut d‟abord créer
une instance à partir de cette classe et utilisé son nom suivant d‟un point et le nom de
la méthode avec la liste d‟arguments.

Exemple :

public class Rectangle Comprendre l’exemple


{
………………………………………………………………
int longueur, largeur ;
………………………………………………………………
Rectangle(int lg,int larg) ………………………………………………………………
{ ………………………………………………………………
longueur = lg ; ………………………………………………………………
………………………………………………………………
largeur = larg ;
……………………………………………………………….
}
void allongerRectangle (int lg) ………………………………………………………………
………………………………………………………………
{
………………………………………………………………
longueur+=lg ; ………………………………………………………………
} ………………………………………………………………
void AugmenterRectangle() ………………………………………………………………

{allongerRectangle(2) ; ………………………………………………………………
} ………………………………………………………………
void affiche(){ ………………………………………………………………
………………………………………………………………
………………………………………………………………
System.out.println("longueur="+longueur+", ………………………………………………………………
largeur="+ largeur) ;
}

34
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

int getLongueur() Travailler l’exemple :


{ return(longueur) ;
………………………………………………………………
}
………………………………………………………………
int getLargeur() ………………………………………………………………
{ return(largeur) ; ………………………………………………………………
} ………………………………………………………………
………………………………………………………………
}//Fin class Rectangle
………………………………………………………………
class TestRectangle
………………………………………………………………
{ ………………………………………………………………
public static void main(String []args) ………………………………………………………………
{ Rectangle r1 ; ………………………………………………………………
………………………………………………………………
r1=new Rectangle(0,0) ;
………………………………………………………………
r1.affiche() ; ………………………………………………………………
r1.longueur=20 ; ………………………………………………………………
r1.largeur=10 ; ………………………………………………………………
………………………………………………………………
int larg=r1.getLargeur() ;
………………………………………………………………
System.out.println("largeur="+larg) ; ………………………………………………………………
System.out.println("longueur="+r1.getLongueur() ) ; ………………………………………………………………
r1.AugmenterRectangle() ; ………………………………………………………………
r1.affiche ; ………………………………………………………………
………………………………………………………………
}}
………………………………………………………………
………………………………………………………………
………………………………………………………………
………………………………………………………………
2.3 Surcharge des méthodes ………………………………………………………………
Exemples: ………………………………………………………………
………………………………………………………………
Exp1
………………………………………………………………
………………………………………………………………
Une classe peut contenir des méthodes de même nom avec des arguments différents pour plusieurs
………………………………………………………………
fonctionnalités. On dit que la méthode est surchargée.

void M(int a){………………}

void M(float b){……………}

void M(float b,String d){………………..}

35
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exp2 Il s‟agit ici de décrire deux classes Affiche et TestAffiche.

public class Affiche Comprendre l’exemple


{ ………………………………………………………………
void print(int i) ………………………………………………………………
{System.out.println("entier="+i) ; } ………………………………………………………………
………………………………………………………………
void print(float f)
………………………………………………………………
{System.out.println("réel="+f) ; } ………………………………………………………………
void print(String s) ……………………………………………………………….
{System.out.println("chaine de caractère =
………………………………………………………………
"+s) ; } Travailler l’exemple :
………………………………………………………………
} ………………………………………………………………
………………………………………………………………
public class TestAffiche ………………………………………………………………
………………………………………………………………
………………………………………………………………
………………………………………………………………
{
………………………………………………………………
………………………………………………………………
public static void main(String[]args)
………………………………………………………………
{ ………………………………………………………………
………………………………………………………………
………………………………………………………………
Affiche a=new Affiche(); ………………………………………………………………
………………………………………………………………
a.print(4.2f ) ; ………………………………………………………………
………………………………………………………………
a.print("Hello") ; ………………………………………………………………
………………………………………………………………
………………………………………………………………
a.print(4) ; ………………………………………………………………
………………………………………………………………
} ………………………………………………………………
}

Les méthodes surchargées sont soumises à certaines règles:

 Leurs arguments doivent être suffisamment différent par le nombre ou /et par le type pour
que la méthode puissent être déterminée sans ambiguïté.
 Le type de retour des méthodes surchargées peut être différent mais cette différence à elle-
même ne suffit pas.

36
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

3. Attributs et méthodes de classe


3.1 Attribut de classe
Le mot clé ‘’static’’

Attribut normal : <nom de l’instance>.<nom de l’attribut>

Attribut static : <nom de la classe>.<nom de l’attribut>

Un attribut de classe est un attribut marqué par le mot clé „‟static‟‟, ce dernier sert à indiquer que cette
attribut est commun à toute les instances de la classe consternée on modifie cet attribut pour une
instance donnée il sera modifié pour touts les autres instances. On accède à un attribut static via une
instance de la classe ou à l‟aide du nom de la classe.

Le mot clé ‘’final’’

class Mathtool

{ final float PI=3.14f ;}

Le mot clé final utilise pour un attribut spécifie que cet attribut est une constante, un attribut final doit
être obligatoirement initialisé lors de sa création :

final float PI ;

PI=3.14f ;

Remarque:

static final: pour un attribut constant et commun pour toutes les instances d‟une même classe.

3.2 Méthode de classe


L‟utilisation d‟une méthode static ne nécessite pas la création d‟une instance. Pour cette raison une
méthode static ne peut accéder qu‟aux attributs static de la classe

Remarque1 :

la méthode « main » est une méthode static , elle se lance sans qu‟aucune instance de la classe qu‟il
contient existe .

Remarque2 :

Dans une méthode static on ne peut pas manipuler que des attributs static

37
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exemple :

public class Mathtool Comprendre l’exemple


{
………………………………………………………………
final static double PI= 3 .14 ; ………………………………………………………………
static double getPI(){ ………………………………………………………………
return PI; ………………………………………………………………
………………………………………………………………
}
………………………………………………………………
static double diametre(double rayon){ ………………………………………………………………
return(2*PI*rayon); .……………………………………………………………
} ………………………………………………………………
………………………………………………………………
static double power (double X){
………………………………………………………………
return (X*X);}
………………………………………………………………
} ………………………………………………………………

public class Test Travailler l’exemple :


………………………………………………………………
{ ………………………………………………………………
………………………………………………………………
………………………………………………………………
public static void main(String []argv) ………………………………………………………………
………………………………………………………………
{ ………………………………………………………………
………………………………………………………………
………………………………………………………………
double i= Mathtool.power(6); ………………………………………………………………
………………………………………………………………
System.out.println("i="+i); ………………………………………………………………
………………………………………………………………
Mathtool tool=new Mathtool(); ………………………………………………………………
double i= tool.power(6); ………………………………………………………………
………………………………………………………………
System.out.println("i="+i);
………………………………………………………………
} ………………………………………………………………
} ………………………………………………………………

4. Les références
4.1 L’autoréférence ‘’this’’
Le mot réservé this, utilisé dans une méthode, désigne la référence de l'instance à laquelle le message
a été envoyé (donc celle sur laquelle la méthode est « exécutée »).

Il est utilisé principalement :


 pour lever une ambiguïté
 dans un constructeur, pour appeler un autre constructeur de la même classe.

38
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exemples:

Exp1 :

public class Rectangle Comprendre l’exemple


{
………………………………………………………………
int longueur, largeur ;
………………………………………………………………
String nom ; ………………………………………………………………
Rectangle() ………………………………………………………………
{ longueur=20 ; ………………………………………………………………
………………………………………………………………
largeur=10 ;} Travailler l’exemple :
……………………………………………………………….
Rectangle(String nom) {
………………………………………………………………
this.nom=nom;
………………………………………………………………
} ………………………………………………………………
Rectangle (int longueur,int largeur,String nom) ………………………………………………………………
{ this(nom) ; ………………………………………………………………
………………………………………………………………
this.longueur=longueur ;
………………………………………………………………
this.largeur=largeur ; ………………………………………………………………
………………………………………………………………
} ………………………………………………………………
………………………………………………………………
void affiche() ………………………………………………………………
………………………………………………………………
………………………………………………………………
………………………………………………………………
{System.out.println ("longueur= "+longueur+,"l
………………………………………………………………
………………………………………………………………
argeur="+largeur+, "nom"=+nom) ;}} ………………………………………………………………
………………………………………………………………
class TestRectangle ………………………………………………………………
{public static void main(String[]args){ ………………………………………………………………
Rectangle r1=new Rectangle (2,3," r1"); ………………………………………………………………
………………………………………………………………
r1.affiche () ;
………………………………………………………………
}} ………………………………………………………………
Exp2 : ………………………………………………………………
………………………………………………………………
………………………………………………………………
public class Personne ……………………………………………………………….
{
Pour lever l’ambigüité sur le mot « cin »et
int cin; déterminer si c’est le nom du paramètre ou
de l’attribut
public Personne (int cin)

this.cin=cin ;}}

39
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exp 3 :

public MonEntier(int a,int b){ …..} Appelle le constructeur MonEntier(int a,int b)

public MonEntier(int c)

this(c,0);
Appelle le constructeur MonEntier(int c)
}

public MonEntier()

this(1) ;

4.2 La référence ‘’null ‘’


Le mot clé „‟null‟‟ permet de représenter la référence qui ne référence rien .On peut aussi assigner
cette valeur à n‟importe quel variable ou attribut de type Objet. C‟est aussi la valeur par défaut
d‟initialisation des attributs de type objet.

Exemple :

Rectangle R ;R==null ;
String S ;S==null ;

5. Destruction d’un objet


Java n'a pas repris à son compte la notion de destructeur telle qu‟elle existe en C++ par exemple. C'est
le ramasse-miettes (ou Garbage Collector - GC en anglais) qui s'occupe de collecter les objets qui ne
sont plus référencés.

Le programmeur n‟a plus à gérer directement la destruction des objets, ce qui était une importante
source d'erreurs (on parlait de fuite de mémoire ou « memory leak » en anglais).Il est possible au
programmeur d'indiquer ce qu'il faut faire juste avant de détruire un objet. C'est le but de la méthode
finalize() de l'objet.

Cette méthode est utile, par exemple, pour :

 fermer une base de données

 fermer un fichier

 couper une connexion réseau

40
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

 etc.

Exemple :
L'instance c1 ne possède plus de référence.
public class Circle { Elle n'est plu accessible. A tout moment le gc
... peut détruite sur
c2 référence l'objet.
une nouvelle instance
void finalize() {
System.out.println("Je suis garbage collecte");
}
} c1 est une référence sur c2
...
Circle c1;
if (condition) {
Circle c2 = new Circle();
c1 = c2;
}
c1=null;
….

Exercice
Réalisez en Java un programme contenant une classe Point, avec ses trois coordonnées dans l‟espace
x,y,z, et que l‟on peut initialiser de trois manières différentes (selon les valeurs initiales connues des
trois coordonnées, on connaît soit x, soit x et y , soit x et y et z). Ensuite, intégrez dans la classe une
méthode translate () qui est surchargée trois fois, dépendant également desquelles des trois valeurs
des translations sont connues.

Solution
public class Point
{int x,y,z ;
public Point (int x){this.x=x ;}
public Point (int x,int y){this.x=x ;this.y=y ;}
public Point (int x,int y,int z){this.x=x ;this.y=y ;this.z=z ;}
void translate(int dx){this.x=this.x+dx ;}
void translate(int dx,int dy){this.x=this.x+dx ;this.y=this.y+dy ;}
void translate(int dx,int dy){this.x=this.x+dx ; this.y=this.y+dy ; this.z=this.z+dz ;}
}

Conclusion
Un constructeur est une méthode spécifique de la classe qui est appelée implicitement à
l‟instanciation de l‟objet. Il porte le même nom que la classe et ne retourne pas de valeur (même pas
void)

41
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

On trouve 3 types de constructeurs :

 par défaut (sans paramètre)


 paramétré (avec paramètres)
 copie (reçoit en paramètre un objet)

Si on ne définit pas le constructeur par défaut, il définira les variables à 0 et les chaînes à vide.

Un destructeur est une méthode spécifique de la classe appelée implicitement à la destruction de


l‟objet.
Caractéristiques :

 porte le même nom que la classe précédé de ~ (tilde)


 ne retourne pas de valeur, même pas void
 n‟accepte aucun paramètre, donc ne peut pas être surchargée

42
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Chapitre 5: Mode de passage des paramètres, Packages et


Modificateurs de visibilités

Objectifs

 Définir les notions : Packages, modificateurs de visibilités


 Savoir l’utilité des modificateurs de visibilité
 Savoir utiliser les modificateurs de visibilités pour les attributs, méthodes, classe

Introduction
Des nombreux langages ou objet introduisent les modificateurs de visibilité pour régler l‟accès aux
classes, méthodes et /ou attributs.

Selon leur niveau de visibilité, les classes, les interfaces, les attributs et les méthodes peuvent être
accessibles ou non depuis des classes du même paquetage ou depuis des classes d'autres paquetages. Si
on tente de compiler une classe invoquant une classe, une interface ou un champ non accessible, il y a
un message d'erreur pour indiquer que l'entité en question n'est pas accessible.

Les classes, attributs et méthodes peuvent être visibles ou non à l'intérieur d'autres paquetages ou
d'autres classes.

1. Mode de passage des paramètres


Java n'implémente qu'un seul mode de passage des paramètres à une méthode : le passage par valeur.

Conséquences :

 L'argument passé à une méthode ne peut être modifié

 Si l'argument est une instance, c'est sa référence qui est passée par valeur. Ainsi, le
contenu de l'objet peut être modifié, mais pas la référence elle-même.

 Contrôle d’accès

Chaque attribut et chaque méthode d'une classe peut être :

 Visible depuis les instances de toutes les classes d'une application. En d'autres
termes, son nom peut être utilisé dans l'écriture d'une méthode de ces classes. Il
est alors public.

43
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

 Visible uniquement depuis les instances de sa classe. En d'autres termes, son nom
peut être utilisé uniquement dans l'écriture d'une méthode de sa classe. Il est alors
privé.

Exemples :

Exp1
Comprendre l’exemple
public class Parallelogramme
………………………………………………………………
{
………………………………………………………………
private int longueur =0; ………………………………………………………………
private int largeur=0 ; ………………………………………………………………
public int profondeur=0 ; ………………………………………………………………
………………………………………………………………
public void affiche()
……………………………………………………………….
{
System.out.println("Longueur= "+longueur+" ………………………………………………………………
………………………………………………………………
Largeur="+largeur+ "Profondeur="+profondeur) ;
………………………………………………………………
} ………………………………………………………………
} ………………………………………………………………
………………………………………………………………

………………………………………………………………
………………………………………………………………
public class ProgPpal Travailler l’exemple :
………………………………………………………………
{public static void main(String args[]) ………………………………………………………………
………………………………………………………………
{ ………………………………………………………………
………………………………………………………………
Parrallelogramme p1=new Parallelogramme(); ………………………………………………………………
………………………………………………………………
p1.longueur=5; ………………………………………………………………
p1.profondeur=4 ; ………………………………………………………………
………………………………………………………………
p1.affiche() ;
………………………………………………………………
} ………………………………………………………………
} ….

44
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exp2 :

public class Rectangle Comprendre l’exemple


{
………………………………………………………………
int longueur,largeur ;
………………………………………………………………
void ChangerInt(int n){n=22 ;} ………………………………………………………………
void ChangerObj(Rectangle b){b.longueur=40;} ………………………………………………………………
} ………………………………………………………………
………………………………………………………………
public class TestRectangle
……………………………………………………………….
{
public static void main(String []args) ………………………………………………………………
………………………………………………………………
{
………………………………………………………………
Rectangle r=new Rectangle(); ………………………………………………………………
int ent=11 ; ………………………………………………………………
r. ChangerInt(ent); Travailler l’exemple :
………………………………………………………………
System.out.println("valeur entiere :" +ent) ; ………………………………………………………………
r.longueur=25 ; ………………………………………………………………
r. ChangerObj(r) ; ………………………………………………………………
………………………………………………………………
System.out.println("longueur d‟objet :
………………………………………………………………
"+r.longueur) ;} ………………………………………………………………
} ………………………………………………………………
………………………………………………………………
….
2. Classes internes
Une classe interne est une classe qui est définit à l‟intérieur d‟une autre classe au même niveau qu‟aux
méthodes ou attributs. Les classes internes sont visible uniquement par les méthodes de la classe dans
laquelle elles sont définit. Elles ont accès à tous les éléments de la classe qui l‟englobe.

Syntaxe :

class A
{ int a;
void M(){……… ; }
class B
{
int b;
void N(){……… ; }
}
}

45
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exemple :

class Voiture Comprendre l’exemple


{int puissance=10 ;
class Roue{ ……………………………………………………………
……………………………………………………………
String modele
……………………………………………………………
Roue(String m){ ……………………………………………………………
modèle =m ;}}//fin classe Roue ……………………………………………………………
Roue r=new Roue("mechelin") ; ……………………………………………………………
……………………………………………………………
void natureVoiture(){
………………….
System.out.println("puissanve"+puissance) ;
System.out.println("modele"+r.modele) ; ……………………………………………………………
……………………………………………………………
}
……………………………………………………………
Travailler l’exemple :
}//fin class voiture ……………………………………………………………
……………………………………………………………
class TestVoiture ……………………………………………………………
………………
……………………………………………………………
{ public static void main(String[]argv)
……………………………………………………………
{ ……………………………………………………………
……………………………………………………………
Voiture v=new Voiture(); ……………………………………………………………
……………………………………………………………
……………………………………………………………
v.natureVoiture(); ……………………………………………………………
……………………………………………………………
Roue r;//C‟est faux car…… ……………………………………………………………
……………………………………………………………
……………………….
}} ……………………………………………………………
………………

3. Les paquetages
Les classes peuvent être regroupées en paquetages. Les classes d‟un même paquetage sont dispersées
dans plusieurs fichiers sources dont la première ligne est :

package nom-de-paquetage

Au sein d‟un paquetage, on a accès aux classes de ce paquetage et aux classes déclarées public des
autres paquetages, mais dans ce dernier cas il faut utiliser un nom absolu :

nom-de-paquetage.nom-de-classe

De plus les classes compilées d‟un paquetage doivent être placées dans un répertoire de même nom
que le paquetage.

46
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Il est possible de désigner les classes par leur nom court, sans préciser le paquetage, à condition
d‟utiliser la directive import :

import nom-de-paquetage.nom-de-classe

ou bien
import nom-de-paquetage.* pour désigner toutes les classes du paquetage.

4. Bibliothèque

Java offre une bibliothèque standardisée, sous forme de paquetages thématiques qui couvrent la
plupart des sujets d‟intérêts actuels :
 java.lang : classes de base du langage (chaînes, math, processus, exceptions,…)
 java.util : structures de données (vecteurs, piles, tables, parcours,…)
 java.io : entrées-sorties classiques (texte sur clavier-écran, fichiers,…)
 java.awt : interfaces homme-machine (fenêtrage, événements, graphique, …)
 java.net : communications Internet (manipulation d‟URL, de sockets,…)
 java. Applet : insertion de programmes dans des documents HTML.

 Un paquetage regroupe des classes et des interfaces apportant une même catégorie de
fonctionnalités.

 Elle est proche de la notion de bibliothèque que l’on rencontre dans d’autres langages

 Par exemple java.io qui regroupe tout ce qui concerne les entrées/sorties.

 Les classes d’un paquetage sont dans un même répertoire.

Par exemple les classes de java.lang sont dans …/java/lang/.

Exemples :

import java.util.Date
class Test1 class Test2
{ public static void main(String []argv) { public static void main(String []argv)
{ Date d=new Date(); { java.util.Date d=new java.util.Date ();
System.out.println(d); System.out.println(d);
}} }}

47
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

5. Les modificateurs de visibilité

Une classe ne peut que :

 Avoir la visibilité par défaut : elle n'est visible alors que de son propre paquetage.
 Se voir attribué le modificateur public : elle est alors visible de partout.

Si un champ d'une classe A :

 Est private, il est accessible uniquement depuis sa propre classe


 A la visibilité paquetage (par défaut), il est accessible de partout dans le paquetage de A mais
de nulle part ailleurs
 Est protected, il est accessible de partout dans le paquetage de A et, si A est publique, grosso
modo dans les classes héritant de A dans d'autres paquetages
 Est public, il est accessible de partout dans le paquetage de A et, si A est publique, de partout
ailleurs.

Ci-dessus, les niveaux de visibilité sont rangés par visibilité croissante.

Rappelons une règle : une méthode d'instance ne peut pas être redéfinie en diminuant son
niveau de visibilité.

Exercice
Créez une classe Livre avec pour :

 variables/attributs : le titre, l'auteur et le nombre de pages.


 constructeurs : un premier qui prend en paramètre l'auteur et le titre du
livre, et un second qui prend en plus le nombre de pages.
Prévoyez également :

 Des accesseurs (ex: getTitre()) et des modificateurs (setTitre())


 Une méthode affiche() destinée à afficher toutes les variables/attributs
d'un livre.
Dans cette classe ajoutez une fonction main() qui crée deux livres et affiche les informations relative
à ces deux livres.
Dans le modificateur du nombre de pages du livre on prendra soin de contrôler si le nombre de page
n'est pas négatif
Solution
public class Livre{
private String Titre, Auteur ;
private int nbp ;
public Livre (String Titre, String Auteur) { this.Titre=Titre ; this.Auteur=Auteur }
public Livre (String Titre, String Auteur,int nbp) { this(Titre,Auteur); this.nbp=nbp ; }

48
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

public void affiche ()


{ System.out.println ("Titre = " + Titre + " Auteur= "+ Auteur+ "nombre de page "+ nbp ) ;
}
public static void setTitre (String Titre) { this.Titre=Titre ; }
public static int getTitre() { return Titre ; }
public static void setAuteur (String Auteur) { this.Auteur=Auteur ; }
public static int getAuteur() { return Auteur ; }
public static void setNbpage (int nbp) { if (nbp> 0)this.nbp=nbp ; }
public static int getNbpage() { return Nbp ; }
public static void main (String args[])
{ Livre L1 = new Livre("programmer en java" ," Claude Delanoy" ) ;
Livre L2 = new Livre("exercices en java" ," Claude Delanoy" ,330) ;
L1.affiche() ;
L2.affiche() ;}}

Conclusion
On définit les niveaux de protection différents par le tableau suivant :

Visibilité Accès dans la même Accès dans un autre


package package
public Accessible Accessible
Class Par défaut Accessible Non accessible
protected Not allowed Not allowed
Private Not allowed Not allowed

public Accessible Accessible


Méthode Par défaut Accessible Non accessible
protected Accessible Non accessible
Private Non Accessible Non accessible

public Accessible Accessible


Attribut Par défaut Accessible Non Accessible
protected Accessible Non Accessible
private Non Accessible Non Accessible

49
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Chapitre 6: Héritage et Polymorphisme avec Java

Objectifs

 Comprendre le principe d’héritage, polymorphisme, classe abstraite et interface.

Introduction
Java implémente le mécanisme d'héritage simple qui permet de "factoriser" l'information dans le cas
où deux classes sont reliées par une relation de généralisation / spécialisation.

 L'héritage multiple n'existe pas en Java.

 L‟implémentation d‟interface permet de compenser cette limitation

 Une classe ne peut hériter (extends) que d'une seule classe

 Pour le programmeur, il s'agit d'indiquer, dans la sous-classe, le nom de la superclasse dont


elle hérite.Par défaut toutes classes Java hérite de la classe java.lang.Object

Mot réservé : extends

Exemple de démarrage :

class Personne Comprendre l’exemple


{
…………………………………………………………………
String nom;
…………………………………………………………………
Date date_naissance; …………………………………………………………………
// ... …………………………………………………………………
} …………………………………………………………………
…………………………………………………………………
class Employe extends Personne
…………………………………………………………………
{
…………………………………………………………………
private float salaire; …………………………………………………………………
// ... …. …………………………………………………………….
} …………………………………………………………………
class Etudiant extends Personne …………………………………………………………………
{ private int numero_carte_etudiant; } …………………………………………………………………

50
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

1. Constructeurs et héritage
1.1 Constructeurs
Par défaut le constructeur d‟une sous-classe appelle le constructeur "par défaut" (celui qui ne reçoit
pas de paramètres) de la superclasse.

Attention donc dans ce cas que le constructeur sans paramètre existe toujours dans la superclasse.

Pour forcer l'appel d'un constructeur précis, on utilisera le mot réservé super. Cet appel devra être
obligatoirement la première instruction du constructeur.

 Situation usuelle : la classe de base et la classe dérivée disposent toutes les deux d‟au moins
un constructeur public.

public class Personne


{
public String nom, prenom;
public int anNaissance;
public Personne()
{
public class Employe extends Personne
nom=" "; prenom=" ";
{
}
public int nbheures;
public Personne(String nom,
public Employe (String nom,
String prenom,
String prenom,
int anNaissance)
int anNaissance,
{
int nbheures)
this.nom=nom;
{
this.prenom=prenom;
super(nom, prenom, anNaissance);
this.anNaissance=anNaissance;
this.nbheures = nbheures;
}
}
}
}

 La classe de base ne possède aucun constructeur

class A
{… // aucun constructeur
}
class B extends A
{ public B ( …)
{ super(); // appelle le constructeur par défaut de A
…..
}
}
 Il reste permis de ne doter la classe B d’aucun constructeur

51
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

La classe dérivée ne possède aucun constructeur (création d‟objet sans argument), il n‟est bien sûr plus
question de prévoir un appel explicite (par super) d‟un constructeur quelconque de la classe de base. Il
est prévu qu‟il appelle un constructeur sans argument de la classe de base. Ce qui signifie que la classe
de base devra :

 Soit posséder un constructeur public sans argument, lequel sera alors appelé

 Soit ne posséder aucun constructeur, il y aura appel du constructeur par défaut

Exemples :

Exp1 :

class A
{ public A() {…..} // constructeur 1 de A
public A (int n) {……} // constructeur 2 de A
}
class B extends A
{ …… // pas de constructeur
}
B b = new B(); // construction de b  appel de constructeur 1 de A

Exp 2 :

class A
{ public A (int n) {……} // constructeur 2 seulement
}
class B extends A
{ …… // pas de constructeur
}
Erreur de compilation car le constructeur par défaut de B cherche à appeler un
constructeur sans argument de A.

52
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exp 3 :
class A
{ …….. // pas de constructeur
}
class B extends A
{ …… // pas de constructeur
}
Aucun problème ne se pose plus. La création d’un objet de type B entraîne l’appel de
constructeur par défaut de B, qui appelle le constructeur par défaut de A

Remarques :

 Une classe peut définir des variables portant le même nom que celles de ses classes
ancêtres.

 Une classe peut accéder aux attributs redéfinis de sa classe mère en utilisant super ou
par cast.

 Une classe peut accéder aux méthodes redéfinies de sa classe mère en utilisant super.

Exemple

class A {
int x;
void m() {...}
}
class B extends A{
int x;
void m() {...}
}
class C extends B {
int x, a;
void m() {...}
void test() {
a = super.x; // a reçoit la valeur de la variable x de la classe B
a = super.super.x; // erreur syntaxique
a = ((B)this).x; // a reçoit la valeur de la variable x de la classe B
a = ((A)this).x; // a reçoit la valeur de la variable x de la classe A
super.m(); // Appel à la méthode m de la classe B

53
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

super.super.m(); // erreur syntaxique


((B)this).m(); // Appel à la méthode m de la classe C (et non B)
}
}

1.2 Le mot réservé final


 Une classe est déclarée finale lorsqu'on ne souhaite pas qu'elle puisse être sous-classée.

 Une méthode est déclarée finale lorsqu'on ne souhaite pas qu'elle puisse être redéfinie.

 Une variable déclarée finale est une constante.

public class Ellipse { Comprendre l’exemple :


public double r1, r2;
……………………………………………
public Ellipse(double r1, double r2) {
……………………………………………
this.r1 = r1; ……………………………………………
this.r2 = r2; ……………………………………………
} ……………………………………………
……………………………………………
public double area{...} ……………………………………………
} ……………………………………………
final class Circle extends Ellipse { ……………………………………………
……………………………………………
public Circle(double r) {super(r, r);}
……………………………………………
public double getRadius() {return r1;} ……………………………………………

1.3 Opérateur instanceof


L'opérateur instanceof confère aux instances une capacité d'introspection : il permet de savoir si une
instance est instance d'une classe donnée elle renvoie une valeur booléenne.

!!!Une référence d'une classe C peut contenir des instances de C ou des classes dérivées de C
Ellipse e = new Ellipse(2.0, 4.0);
Circle c = new Circle(2.0);
System.out.println("Aire de c:" + c.area());
System.out.println((e instanceOf Circle)); // false
System.out.println((e instanceOf Ellipse)); // true
System.out.println((c instanceOf Circle)); // true
System.out.println((c instanceOf Ellipse)); // true
e = c;

54
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

System.out.println((e instanceOf Circle)); // true


System.out.println((e instanceOf Ellipse)); // true
int r = e.getRadius(); // Erreur
c = e; // Erreur type incompatible, nécessité de casting.

2. Redéfinition de méthodes
Une sous-classe peut re-définir des méthodes existant dans une de ses superclasses (directe ou
indirecte), à des fins de spécialisation.Le terme anglophone est "overriding". On parle aussi de
masquage. La méthode redéfinie doit avoir la même signature :

Exemple :

class Employe extends Personne


class Cadre extends Employe
{
{
private float salaire;
public calculePrime()
public calculePrime( )
{
{
// ...
// ... Redéfinition }
}
// ...
}
}

class Cadre extends Employe


{
public float calculePrime()
{
return (super.calculePrime() / 2); class Employe extends Personne
} {
// ... private float salaire;
}
public float calculePrime()
{

return (salaire * 0,05);


Appel de la méthode calculPrime() de la super }
classe du Cadre // ..}

3. Polymorphisme: Recherche dynamique des méthodes


Capacité pour une entité de prendre plusieurs formes.

Le mécanisme de "lookup" dynamique :

 Déclenchement de la méthode la plus spécifique d‟un objet, c'est-à-dire celle


correspondant au type réel de l'objet,

 Cette dynamicité permet d'écrire du code plus générique.

55
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Remarque : Dans une même classe, plusieurs méthodes peuvent posséder le même nom, pourvu
qu'elles diffèrent en nombre et/ou type de paramètres :

 On parle de surdéfinition ou surcharge, on encore en anglais d‟overloading.

 Le choix de la méthode à utiliser est fonction des paramètres passés à l'appel.

 Très souvent les constructeurs sont surchargés (plusieurs constructeurs prenant des
paramètres différents et initialisant de manières différentes les objets)

Quelques précisions cependant :

 Le type de retour seul, ne suffit pas à distinguer deux méthodes de signatures


identiques par ailleurs,

 Les types des paramètres doivent être "suffisamment" différents pour qu'il n'y ait pas
d'ambiguïtés,

Ne pas confondre surcharge et redéfinition (même si très proche)

 On redéfinit dans une sous-classe des méthodes héritées de sa superclasse.

 On surcharge quand plusieurs méthodes dans une même classe ont le même nom
mais des paramètres différents.

Exemple :

int public int max (int m, int n)


{ if (m > n ) return m;
return n;
}
int public int max (int n1, int n2, int n3){ return(max(max(n1,n2),n3));}
int public int max (byte m, int n) Calcul a = new Calcul();
{ if (m > n ) return m; int x; byte y;
return n; a.max(x,y);
} a.max(y,x);
n public int max (int m, byte n) a.max(y,y); ??
{ if (m > n ) return m;
return n; }

56
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

4. Classe abstraite
Il peut être nécessaire au programmeur de créer une classe déclarant une méthode sans la définir (c'est-
à-dire sans en donner le code). La définition du code est dans ce cas laissée aux sous-classes : classe
abstraite

 Une classe abstraite est une classe ayant au moins une méthode abstraite.

 Une méthode abstraite ne possède pas de définition.

 Une classe abstraite ne peut pas être instanciée (new).

 Une classe dérivée d'une classe abstraite ne redéfinissant pas toutes les méthodes abstraites est
elle-même abstraite.

 Elle doit être marquée avec le mot réservé abstract.

Exemple :

class abstract Shape {


public abstract double perimeter();
}
class Circle extends Shape {
...
public double perimeter() { return 2 * Math.PI * r ; }
}
class Rectangle extends Shape {
...
public double perimeter() { return 2 * (height + width); }
}
Shape[] shapes = {new Circle(2), new Rectangle(2,3), new Circle(5)};
double sum_of_perimeters = 0;
for(int i=0; i<shapes.length; i++)
sum_of_perimeters += shapes[i].perimeter();

5. Interface
Si le programmeur veut s'assurer qu'une certaine catégorie de classes (pas forcément reliées par des
relations de généralisation / spécialisation) implémente un ensemble de méthodes, il peut regrouper les
déclarations de ces méthodes dans une interface.

 De telles classes pourront ainsi être manipulées de manière identique.

57
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

 Les classes désirant appartenir à la catégorie ainsi définie :

 déclareront qu'elles implémentent cette interface,

 fourniront le code des méthodes déclarées dans cette interface.

Cela peut être vu comme un contrat entre la classe et l’interface

 la classe s‟engage à implémenter les méthodes définies dans l‟interface

Mots réservés : interface et implements

 Une interface correspond à une classe où toutes les méthodes sont abstraites.

 Le modificateur abstract est facultatif

 Une classe peut implémenter (implements) une ou plusieurs interfaces tout en héritant
(extends) d'une classe.

 Comme pour les classes, l‟héritage est possible entre les interfaces

Exemple :

class abstract Shape { public abstract double perimeter(); }


interface Drawable { public void draw(); }
class Circle extends Shape implements Drawable {
public double perimeter() { return 2 * Math.PI * r ; }
public void draw() {...}
}
class Rectangle extends Shape implements Drawable {
...
public double perimeter() { return 2 * (height + width); }
public void draw() {...} }
Drawable[] drawables = {new Circle(2), new Rectangle(2,3), new Circle(5)};
for(int i=0; i<drawables.length; i++) { drawables[i].draw();}
Remarque :

Une classe peut implémenter plusieurs interfaces différentes.

58
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exercices

Exercice 1
Ecrire une classe Personne ayant pour attributs une chaine nom, un entier CIN et un entier age :

 Ecrire un constructeur prenant en arguments une chaine et deux entiers qui


initialisent les attributs de cette classe
 Ecrire les accesseurs correspondant aux attributs
 Ecrire une méthode toString permettant d‟afficher le nom d‟une personne suivi de
son âge entre parenthèses (exemple : Laila NAKKAII 34 ans)

Exercice 2
Ecrire une classe Skieur, sous classe de la classe Personne, ayant pour attribut supplémentaire un
booléen forfait (qui est vrai si le skieur a un forfait, faux, sinon)

 Ecrire un constructeur prenant en arguments une chaîne nom, un entier age,un


entier CIN et un booléen forfait. Ce constructeur commencera par :
super(CIN,nom, age) pour construire d‟abord la partie Personne de l‟objet
Skieur,
 Ecrire les accesseurs correspondant à l‟attribut forfait,
 Ecrire une méthode toString qui retourne les caractéristiques du Skieur

Ecrire une classe TestPersonne qui a pour attributs un tableau de Personne de capacité 10 nommé
peuple et un entier indiquant le nombre de personne

 Ecrire une méthode AjoutPersonne qui prend en argument une personne qui permet
d‟ajouter cette personne au tableau peuple
 Ecrire une méthode SupprimerPersonne qui permet de supprimer la personne passée
en paramètre du tableau
 Ecrire une méthode Explorer qui permet d‟afficher les caractéristiques des personnes
Tester les différentes classes (placer dans le tableau peuple de la classe TestPersonne des personnes,
et des Skieurs).

Solution
public class Personne {
private String Nom;
private int CIN, int age;
public Personne(String Nom,int CIN, int age) {
this.Nom=Nom;
this.CIN=CIN;
this.age=age;
}
public void setNom(String Nom) {This.Nom=Nom;}
public String getNom(){ return Nom;}
public void setCIN(int CIN) { This.CIN=CIN;}
public String getCIN(){ return CIN;}
public void setAge(int age) {This.age=age;}
public String getNom(){ return Nom;}
public String toString() { return Nom + " " +age + " ans" ; }

59
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

public class Skieur extends Personne {


boolean forfait ;

public Skieur (String Nom,int CIN, int age, boolean forfait)


{
super(Nom,CIN,age);
this. forfait = forfait;
}
public void setforfait (boolean forfait) {This.forfait =forfait;}
public boolean getforfait (){ return forfait;}
public String toString() {
if (forfait )
{ return ( super. toString() + " a un forfait "); }
else
{ return ( super. toString() + " n‟a pas un forfait ") ; }
}
⁄⁄ classe TestPersonne

Class TestPersonne{
private Personne[ ] peuple;
private int nbrePersonne;
private final static int capacite = 10;
public TestPersonne () {
peuple= new Personne[capacite];
nbrePersonne = 0;
}
public void AjoutPersonne(Personne P) {

++nbrePersonne;
if (nbrePersonne <= capacite)
{ peuple[nbrePersonne - 1] = P; }
else
{ System.out.println("Pas plus de " + capacite + " personnes"); }
}
public void SupprimerPersonne(Personne P) {
⁄⁄ rechercher la personne à retirer
int i=0 ;
boolean trouve= false ;
while(i< nbrePersonne) && (trouve == false)
{
if (peuple[i] ==P)
{ Trouve = true ; }
else
{ i ++ ; }
}
if (trouve)
{
⁄⁄ décalage à gauche
for( int j=i ; i< nbrePersonne ; i ++ )
{ peuple[j-1] =peuple[j] ; }
⁄⁄ décrémentation du nombre de personnes
nbrePersonne --,
}

60
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

else
{ System.out.println("Personne non trouvée"); }
}
public void Explorer() {
for( int j=0 ; i< nbrePersonne ; i ++ )
{ System.out.println(peuple[i].toString() ;}
}
public static void main (String args[])
{ Personne P1= new Personne(" IDRISS ",12345689,2) ;
Personne P2= new Personne(" SKANDER" ,77845329,39) ;
Skieur S= new Skieur(" MOHAMED ", 09095868,1,false) ;
TestPersonne T= new TestPersonne() ;
T.AjoutPersonne(P1) ;
T.AjoutPersonne(P2) ;
T.AjoutPersonne(S) ;
T.Explorer() ;
T.Supprimer(P2) ;
T.Explorer() ;}}

Conclusion
La notion d‟héritage est une notion importante en programmation objet. Cette notion permet de
spécialiser une classe sans avoir à tout réécrire, en utilisant sans modification, les méthodes de la
super-classe si elles conviennent ou en réécrivant les méthodes qui ne conviennent plus sachant qu‟une
partie du traitement peut souvent être faite par les méthodes de la super-classe.

Le polymorphisme permet de définir dans la super-classe des méthodes tenant compte des spécificités
des classes dérivées. En cas de redéfinition de méthodes, c‟est la méthode de la classe dérivée de
l‟objet qui est prise en compte, et non celle de la super-classe.

61
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Chapitre 7: Gestion des exceptions


Objectif

 Définir l’exception en reconnaissant sa déclaration en java


 Savoir utiliser des exceptions prédéfinies et déclarer ses propres exceptions

Introduction
Une exception est un signal qui indique que quelque chose d'exceptionnel est survenu en cours
d'exécution. Deux solutions alors :

 Laisser le programme se terminer avec une erreur,

 Essayer, malgré l'exception, de continuer l'exécution normale.

1. Utilisation
Java exige qu'une méthode susceptible de lever une exception indique quelle doit être l'action à
réaliser.

 Sinon, il y a erreur de compilation

Le programmeur a le choix entre :

 écrire un bloc try / catch pour traiter l'exception,

 laisser remonter l'exception au bloc appelant grâce à un throws.

C'est ce qu'on appelle : "Déclarer ou traiter".

Le bloc try est exécuté…

 … jusqu'à ce qu'il se termine avec succès

 … ou bien qu'une exception soit levée, les clauses catch sont examinées l'une après
l'autre dans le but d'en trouver une qui traite cette exception

try {

... }

catch (<une-exception>) { Autant de blocs catch que


l’on veut
... }

catch (<une autre exception>) { ... }

62
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

try
{
... Erreur : catch doit être
} contigu au bloc try
………..
………..
catch (<une-exception>) // {
...
}

Règle : Toute méthode susceptible de déclencher une exception qu’elle ne traite pas localement
doit mentionner son type dans une clause throws figurant dans son en-tête.

Exemple :

class Point { private int x, y;

public Point(int x, int y) throws ErrConst

{ if ((x <0) || (y<0)) throw new ErrConst();

this.x = x; this.y = y}

public void deplace (int dx, int dy) throws ErrDepl

{ if (((x + dx)<0) || ((y + dy)<0)) throw new ErrDepl();

x = x + dx; y = y + dy;}}

63
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

2. Transmission d’information au gestionnaire d’exception

class Point
Conmprendre l’exemple :
{ private int x, y;
………………………………………………………
public Point(int x, int y) throws ErrConst ………………………………………………………
………………………………………………………
{ if ((x <0) || (y<0)) throw new ErrConst(x,y); ………………………………………………………
………………………………………………………
this.x = x; this.y = y;} ………………………………………………………
………………………………………………………
public void affiche() ………………………………………………………

{ System.out.println("coord : " + x + " " + y);} } ………………………………………………………


………………………………………………………
class ErrConst extends Exception { ………………………………………………………
………………………………………………………
public int abs, ord; ………………………………………………………
………………………………………………………
ErrConst (int abs, int ord)
………………………………………………………
………………………………………………………
{this.abs = abs; this.ord = ord;} } public void affiche()
………………………………………………………
{ System.out.println("coord : " + x + " " + y); } } ………………………………………………………
………………………………………………………
class ErrConst extends Exception { } ………………………………………………………
………………………………………………………
class ErrDepl extends Exception { } ………………………………………………………
………………………………………………………
public class Except ……………………………………………………

{ public static void main (String args[]) ………………………………………………………


………………………………………………………
{ try ………………………………………………………
………………………………………………………
{ Point a = new Point(1,4); ………………………………………………………
………………………………………………………
a.affiche(); ………………………………………………………
……………………………………………………
a.deplace(-3,5);

a = new Point (-3,5);

a.affiche(); }

catch (ErrConst e)

64
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

{ System.out.println(" Erreur construction " ); Travailler l’exemple :

System.exit(-1); } ……………………………………………………
……………………………………………………
catch (ErrDepl e) ……………………………………………………
……………………………………………………
{ System.out.println(" Erreur deplacement " );
……………………………………………………
……………………………………………………
System.exit(-1); }}}
……………………………………………………
……………………………………………………
……………………

……………………………………………………
3. Poursuite de l’exécution ……………………………………………………
// définition des classes Point, ErrConst et ErrDepl ……………………………………………………
public class Suitex ……………………………………………………
{ public static void main (String args[]) ……………………………………………………
……………………………………………………
System.out.println(" Avant bloc try " );
……………………………………………………
{ try ……………………………………………………
{ Point a = new Point(1,4); ……………………………………………………
a.affiche(); ……………………………………………………
……………………………………………………
a = new Point (-3,5);
……………………………………………………
a.affiche();
…………
}
catch (ErrConst e)
{ System.out.println(" Erreur construction " );
}
catch (ErrDepl e)
{ System.out.println(" Erreur deplacement " );
}
System.out.println(" apres bloc try " );
}
}
Avant bloc try
Coord : 1 4
Erreur construction
Apres bloc try
sortir avec return
int f()
{ try {}

65
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

catch ( E1 e )
{
return 0; // en cas d‟exception, on sort de f
}
…. // sans exécuter ces instructions
}
accès aux variables
int f()
{ int n = 12;
try { float x;}
catch ( E1 e )
{
// ici, on n‟a pas accès à x (bloc disjoint de celui-ci)
// mais on a accès à n (bloc englobant)
}
}

4. Choix du gestionnaire d’exception


class ErrPoint extends Exception { }
class ErrConst extends ErrPoint { }
class ErrDepl extends ErrPoint { }
void f( )
{ ………. throw new ErrConst();
…………throw new ErrDepl();
}
Dans un programme utilisant la méthode f, on peut gérer les exceptions qu‟elle est susceptible de
déclencher de cette façon :
try { …..// on suppose qu‟on utilise f
}
catch (ErrPoint e)
{ // on traite ici à la fois les exceptions de type ErrConst et celles de // type ErrDepl
}

66
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

try { …..// on suppose qu‟on utilise f


}
catch (ErrConst e)
{ // on traite ici uniquement les exceptions de type ErrConst
}
catch (ErrDepl e)
{ // et ici, uniquement celles de type ErrDepl }
try { …..// on suppose qu‟on utilise f
}
catch (ErrConst e)
{ // on traite ici uniquement les exceptions de type ErrConst
}
catch (ErrPoint e)
{ // et ici, toutes celles de type ErrPoint ou dérivé (autre que ErrConst)
}

Les clauses catch doivent traiter les exceptions de la plus spécifique à la plus générale. La présence
d'une clause catch qui intercepte une classe d'exceptions avant une clause qui intercepte une sous-
classe d'exceptions déclenche une erreur de compilation.

Si une clause catch convenant à cette exception a été trouvée et le bloc exécuté, l'exécution du
programme reprend son cours.

 Si elles ne sont pas immédiatement capturées par un bloc catch

– les exceptions se propagent en remontant la pile d'appels des méthodes, jusqu'à être
traitées.

 Si une exception n'est jamais capturée

– elle se propage jusqu'à la méthode main(), ce qui pousse l'interpréteur Java à afficher
un message d'erreur et à s'arrêter.

 L'interpréteur Java affiche un message identifiant :

– l'exception,

– la méthode qui l'a causée,

– la ligne correspondante dans le fichier.

67
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Le bloc finally

 Le bloc finally

– il permet au programmeur de définir un ensemble d'instructions qui est toujours


exécuté, que l'exception soit

 levée ou non,

 capturée ou non

 Le bloc finally s'exécute même si

– le bloc en cours d'exécution (try ou catch selon les cas) contient un return et un
break.

 Dans ce cas, le bloc finally est exécuté juste avant le branchement effectué
par l'une de ces instructions.

– La seule instruction qui peut faire qu'un bloc finally ne soit pas exécuté est
System.exit().

Un bloc finally doit obligatoirement être placé après le dernie Gestionnaire

 Un bloc finally n’a aucun intérêt lorsque les exceptions sont traitées localement

try { }

catch (Ex e) { }

finally

{ // instructions A }

Le même résultat pourrait être obtenu en supprimant tout simplement le mot clé finally et en
conservant les instructions A à la suite du gestionnaire

 Un bloc finally a un intérêt lorsque :

o Un gestionnaire comporte une instruction return ou break, le bloc finally est quand
même exécuté auparavant
o Il est associé à un bloc try ne comportant aucun gestionnaire d‟exception. Ce bloc est
exécuté après la sortie du bloc try, quelle que soit la façon dont elle a eu lieu

68
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

class Except extends Exception { }


Public class Finally
{ public static void f(int n) // pas de throws
{ try { if (n!=1) throw new Except(); }
catch (Except e)
{ System.out.println(" catch dans f - n = " + n ); return ; }
finally
{ System.out.println(" dans finally - n = " + n ); }
}
public static void main (String args[])
{ f(1); f(2); } }
dans finally – n = 1 catch dans f – n = 2 dans finally –n = 2

try
{ ……
if (…..) break; // si ce break est exécuté, on exécutera d‟abord
….
}
finally // ce bloc finally
{ }
……… // avant de passer à cette instruction
try
{ ……
return 0; // provoque d‟abord l‟exécution
}
finally // de ce bloc finally
{ ……….
return –1; // et un retour avec la valeur 1
}

5. Quelques exceptions standards


 ArithmeticException : Division par zéro pour les entiers
 NegativeArraySizeException : Tentative de création d'un tableau de taille négative
 ArrayIndexOutOfBoundsException : Dépassement de limite d'un tableau

69
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Exemple :

public class ExcStd


{
public static void main (String args[])
{ try
{ int t[];
System.out.println(" taille voulue : " );
int n = ESBasique.lireInt();
t = new int[n];
System.out.println(" indice : " );
int i = EsBasique.lireInt(); t[i] = 12;
System.out.println(" fin normale " );
}
catch (NegativeArraySizeException e)
{ System.out.println(" Exception taille tableau negative : " + e.getMessage()); }
catch (ArrayIndexOutOfBoundsException e)
{ System.out.println(" Exception indice tableau : " + e.getMessage()); }
}
}
taille voulue : -2
Exception taille tableau negative : -2
taille voulue : 10
indice : 15
Exception indice tableau : 15

Exercice
Réaliser une classe EntNat permettant de manipuler des entiers naturels (positifs ou nuls). Cette
classe contient :

 un constructeur à un argument de type int qui générera une exception de type ErrConst (type
classe à définir) lorsque la valeur reçue ne conviendra pas,
 d‟une méthode getN fournissant sous forme d‟un int, la valeur encapsulée dans un objet de
type EntNat.
Écrire un petit programme d‟utilisation qui traite l‟exception ErrConst en affichant un message et en
interrompant l‟exécution.

70
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Solution
class EntNat
{ public EntNat (int n) throws ErrConst
{ if (n<0) throw new ErrConst() ;
this.n = n ;
}
public int getN () { return n ; }
private int n ;
}
class ErrConst extends Exception {}

public class TstEntNat


{ public static void main (String args[])
{ try
{ EntNat n1 = new EntNat(20) ;
System.out.println ("n1 = " + n1.getN()) ;
EntNat n2 = new EntNat(-12) ;
System.out.println ("n2 = " + n2.getN()) ;
}
catch (ErrConst e)
{ System.out.println ("*** erreur construction ***") ;
System.exit (-1) ; }}
}

Conclusion
La gestion d‟erreurs par exceptions permet d‟écrire de manière plus claire (donc plus maintenable) un
programme, en isolant le traitement d‟erreur de la suite d‟instructions qui est exécutée si aucune erreur
ne survient.

Généralement, dans les langages ne disposant pas des exceptions (comme le C), les fonctions
susceptibles de poser problème renvoient des valeurs que vous devez traiter immédiatement pour
vérifier si aucune erreur n‟est survenue. Les exceptions font partie du noyau du langage Java et leur
gestion est obligatoire.

71
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Liste des Travaux Dirigées

72
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

TD1 : Syntaxe et Eléments de base du langage Java


Exercice 1

But Savoir utiliser la structure conditionnelle

Thème condition if - nombre pair ou impair

Enoncé

Ecrivez un programme Java qui lit un nombre et indique s'il est positif, négatif ou s'il vaut
zéro et s'il est pair ou impair.

Exemple d'exécution:

Entrez un nombre entier: 5


Le nombre est positif et impair

Entrez un nombre entier: -4


Le nombre est négatif et pair

Entrez un nombre entier: 0


Le nombre est zéro (et il est pair)

Exercice 2

But Ecrivez un programme permettant de détecter des palindromes

Thème condition if - nombre pair ou impair

Enoncé

Un palindrome est un mot que l'on peut lire dans les deux sens. La distinction entre
majuscules/minuscules n'a aucune importance pour la lecture d'un palindrome. Si on ne tient
pas compte des espaces, des virgules, des tirets et des apostrophes (i.e. les caractères ' ', ',', '-'
et '\''), une phrase complète peut aussi être considérée comme un palindrome.

Exemples de palindromes:

Otto
Elu par cette crapule
Esope reste ici et se repose
Tu l'as trop ecrase, Cesar, ce Port-Salut

Exemples de non-palindromes:

Cours de Java
Concours
Technologue

73
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Travail demandé

Ecrivez un programme Palindrome.java qui lit une chaine de caractères du clavier et qui teste
s'il s'agit d'un palindrome.

Exemple d'exécution:

Entrez un mot ou une phrase : Otto


C'est un palindrome !
Pour ce programme, il convient d'utiliser plusieurs méthodes prédéfinies de la classe String,
comme par exemple charAt(), toLowerCase() et length().

Exercice 3

But Permutation du contenu de deux variables

Thème Opérateurs et expressions

Enoncé

Implémentez en Java un algorithme vous permettant de permuter les valeurs de deux


variables.

Exemple d'exécution:

Entrez x: 1
Entrez y: 2
Avant permutation:
x:1
y:2
Après permutation:
x:2
y:1
Exercice 4

But Calcul récursif et itératif de la factorielle de n

Thème Récursivité

Enoncé

Pour calculer n! (factorielle n), on peut utiliser deux formules différentes :


La formule itérative :
n! = 1 * 2 * 3 * ... * n
.La formule récursive définissant n! en fonction de (n-1)! :
0! (factorielle de zéro) = 1
pour tout entier n>0, n! = n * (n-1)!

74
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Travail à faire

Dans une classe Factorielle.java,


définissez deux méthodes factorielleRecursive et
factorielleIterative implémentant les deux méthodes de calcul décrites précédemment. La calcul
devra se faire sur des entiers compris entre 0 et 12 introduits par l'utilisateur. Une méthode
demanderNombre redemandera le nombre à l'utilisateur tant que celui-ci ne sera pas compris dans
l'intervalle souhaité.

Implémentez ensuite la méthode main qui demandera un nombre à l'utilisateur et calculera la


factorielle de ce nombre des deux manières possibles.

Pour terminer, ajouter une boucle demandant à l'utilisateur s'il souhaite recommencer.

Exemple de déroulement

Entrez un nombre entier compris entre 0 et 12 : 12


Méthode itérative :
12! = 479001600
Méthode récursive :
12! = 479001600
Voulez-vous recommencer [o/n] ? o
Entrez un nombre entier compris entre 0 et 12 : 6
Méthode itérative :
6! = 720
Méthode récursive :
6! = 720
Voulez-vous recommencer [o/n] ? n

75
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Correction TD1 : Syntaxe et Eléments de base du langage


Java
Exercice 1

Solution

import java.util.Scanner;
public class PairImpair {
public static void main(String args[]) {
private static Scanner scanner = new Scanner(System.in);
// Demander une valeur à l'utilisateur
System.out.print("Entrez un nombre entier:");
int number = scanner.nextInt();
// Premièrement, on vérifie si le nombre est zéro, car
// dans ce cas le test de parité n'est pas nécessaire
if (number == 0) {
System.out.println("Le nombre est zéro (et il est pair)");
} else {
// S'il n'est pas nul, voyons quel est son signe
if (number < 0) {
//Note: System.out.print ne commence pas de nouvelle ligne
System.out.print("Le nombre est négatif ");
} else {
System.out.print("Le nombre est positif ");
}
// Teste la parité: si le reste de la division par deux est zéro
// alors le nombre est pair
int reste = number % 2;
if (reste == 0) {
System.out.println("et pair");
} else {
System.out.println("et impair");
}
}
}
}
Exercice 2

Solution

Nous utilisons ici le fait que si une chaine s est un palindrôme, la relation suivante est vérifiée
pour tout i: s[i] = s[longeur de s - i]. L'algorithme procède alors comme suit: on parcourt la
chaine dans les deux sens en même temps: l'indice p1 sert à parcourir la chaine du début à la
fin et l'indice p2 sert à parcourir la chaine de la fin au début. On compare à chaque étape la
chaine à l'indice p1etl'indicep2.

76
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Si c'est le même caractère on progresse, sinon le mot n'est pas un palindrôme. On prend soin,
en cours de parcours, de sauter les séparateurs. On s'arrête autrement quand p1 et p2 se
rejoignent. Le mot est alors un palindrôme.

import java.util.Scanner;
class Palindrome {
public static void main (String args[]) {
private static Scanner scanner = new Scanner(System.in);
System.out.print("Entrez un original ou une phrase : ");
String original = scanner.nextLine();
// On convertit l'original en minuscules pour éviter les problèmes de casse:
String test = original.toLowerCase();
// On ne garde que les caractères alphabétiques
String allowedList = "abcdefghijklmnopqrstuvwxyz";
String temp = "";
for (int i = 0; i < test.length(); i++) {
char c = test.charAt(i);
if (allowedList.indexOf(c) != -1) {
temp += c; }
}
test = temp;
// On teste si mot2 est un palindrôme
int leftPos = 0;
int rightPos = test.length() - 1;
boolean palindrome=true;
while ((leftPos < rightPos) && palindrome) {
if (test.charAt(leftPos) != test.charAt(rightPos)) {
palindrome=false;
}
leftPos++;
rightPos--; }
if (palindrome) {
System.out.println("C'est un palindrôme !");
} else {
System.out.println("Non, ce n'est pas un palindrôme.");
}}
Exercice 3

Solution

import java.util.Scanner;
class Permutation {
public static void main(String[] args) {
private static Scanner scanner = new Scanner(System.in);
System.out.print("Entrez x: ");

77
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

int x = scanner.nextInt();
System.out.print("Entrez y: ");
int y = scanner.nextInt();
System.out.println("Avant permutation: ");
System.out.println("x : " + x);
System.out.println("y : " + y);
int tmp = x;
x=y
y = tmp;
System.out.println("Après permutation: ");
System.out.println("x : " + x);
System.out.println("y : " + y);
}
}
Exercice 4

Solution

import java.util.Scanner;
class Factorielle {
public static void main(String[] args) {
private static Scanner scanner = new Scanner(System.in);
char recommencer = 'o';
do {
int n = demanderNombre();
System.out.println("Méthode itérative :");
System.out.println(n + "! = " + factorielleIterative(n));
System.out.println("Méthode recursive :");
System.out.println(n + "! = " + factorielleRecursive(n));
System.out.println("Voulez-vous recommencer [o/n] ?");
recommencer = scanner.next().charAt(0);
} while (recommencer == 'o');
}
/**
* Demande un entier à l'utilisateur
* @return L'entier entré par l'utilisateur
*/
static int demanderNombre() {
int n;
do {
System.out.println("Donnez un nombre entier compris entre 0 et 12 (compris)");
n = scanner.nextInt();
} while ((n > 12) || (n < 0));
return n;
}

78
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

/**
* Calcul de la factorielle par la méthode itérative
* @param nombre Le nombre dont on veut calculer la factorielle
* @return nombre!
*/
static int factorielleIterative(int nombre) {
int fact = 1;
for (int i = 2; i <= nombre; i++) {
fact *= i;
}
return fact;
}
/**
* Calcul de la factorielle par la méthode récursive
* @param nombre Le nombre dont on veut calculer la factorielle
* @return nombre!
*/
static int factorielleRecursive(int nombre) {
if (nombre == 0) {
return 1;
} else {
return (nombre * factorielleRecursive(nombre - 1));
}}}

79
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

TD2 : Notion d'Objet, Classe et Constructeur


Exercice 1

But: Ecrire une classe java avec 3 constructeurs

Thème: Constructeur

Enoncé

Définir une classe nommé Livre destinée à gérer les ouvrages au sein d‟une bibliothèque.
Cette classe possède les attributs suivants :
Edition : attribut de type int.
nombreExemplaire : attribut de type double.
Et les méthodes suivantes
Livre () : créer un livre avec nombre d‟exemplaire initial 1
Livre (int Ed) : créer un livre avec nombre d‟exemplaire initial 1 et initialise l‟année
d‟édition à Ed.
Livre (int Ed, int expls) : un livre avec nombre d‟exemplaire initial expls et initialise l‟année
d‟édition à Ed.
void affiche () : affiche les attributs d‟un livre
Travail à faire

Créer un premier livre Liv1 en utilisant le premier constructeur


Créer un premier livre Liv2 en utilisant le second constructeur
Créer un premier livre Liv3 en utilisant le troisième constructeur
Ajouter des autres attributs et faire les changements adéquats à fin d‟afficher à l‟écran le
nombre d‟exemplaire de trois ouvrages.
Exercice 2

But: Ecrire une classe java

Thème: Classe, objet, constructeur, attributs et méthodes

Enoncé

Définir une classe nommée Moncompte destinée à gérer le ou les comptes d‟une personne.
Cette classe possède les deux attributs suivants :
Solde : attribut de type double,
NumCompte : attribut de type entier.
Et les méthodes suivantes :
MonCompte (double x) : crée un compte avec solde initial x.
Moncompte() : crée un compte avec un solde 0
double getSolde() : renvoi le solde du compte
void Deposer(double montant) : dépose une somme d‟argent sur le compte
void Retirer(double montant) : retire une somme d‟argent du compte
void Transferer(double montant, MonCompte compte) : transfert une somme d‟argent
d‟un compte à un autre

80
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Travail à faire

Créer un premier compte com1 avec solde initial 100.


Créer un second compte com2 en utilisant le second constructeur.
Transférer de l‟argent d‟un compte à un autre.
Afficher les soldes finaux pour ces comptes.

81
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Correction TD2 : Notion d'Objet, Classe et Constructeur


Exercice 1

Solution :

public class Livre {


int Edition;
int nombreExemplaire;
private String auteur;
private String titre;
public String getauteur()
{return auteur;
}
public String gettitre()
{return titre;
}
Livre(String auteur,String titre)
{nombreExemplaire=1;
this.titre=titre;
this.auteur=auteur;
}
Livre(int Ed,int expls,String titre,String auteur)
{ this.titre=titre;
this.auteur=auteur;
nombreExemplaire=expls;
Edition=Ed;
}
Livre(int Ed,String titre,String auteur)
{ this.titre=titre;
this.auteur=auteur;
nombreExemplaire=1;
Edition=Ed;
}
public void affiche()
{
System.out.println("le livre est "+titre+" ,"+auteur+" ,"+Edition+"
,"+nombreExemplaire);
}
}
public class testLivre {
public static void main(String[] args) {
// TODO code application logic here
Livre Liv1=new Livre("auteur1","titre1");
Livre Liv2=new Livre(1985,"auteur2","titre2");
Livre Liv3=new Livre(1979,25,"auteur3","titre3");

82
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Liv1.affiche();
Liv2.affiche();
Liv3.affiche();
}
}
Exercice 2

Solution

public class MonCompte {


double solde;
int numCompte;
MonCompte(double x)
{solde=x;}
MonCompte()
{solde=0;}
double getSolde()
{return solde;
}
void Deposer(double montant)
{solde+=montant;
}
void Retirer(double montant)
{solde+=montant;
}
void Transferer(double montant,MonCompte compte)
{ Retirer(montant);
compte.Deposer(montant); }
}
public class TestCompte {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
MonCompte compte1=new MonCompte(100);
MonCompte compte2=new MonCompte();

//AFFICHAGE DES SOLDES INITIALES


System.out.println( "AFFICHAGE DES SOLDES:");
System.out.println( " SOLDE COMPTE1"+compte1.solde);
System.out.println( " SOLDE COMPTE2"+compte2.solde);
//TRANSFERER 50 dinars du compte1 vers compte2

83
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

compte1.Transferer(50,compte2);
//AFFICHAGE DES SOLDES INITIALES
System.out.println( "AFFICHAGE DES SOLDES APRES L'OPERATION DU
TRANSFERT");
System.out.println( " SOLDE COMPTE1"+compte1.solde);
System.out.println( " SOLDE COMPTE2"+compte2.solde);
//TRANSFERER 50 dinars du compte1 vers compte2
}
}

84
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

TD3 : Objet, Classe, Attribut de classe


Exercice1 :

But Spécification et écriture de classes élémentaires

Thème objet, classe, attribut de classe

Enoncé

Il s'agit de définir une classe JAVA permettant de modéliser des comptes bancaires. Cette
classe (Compte) doit permettre à une application de créer et utiliser autant de comptes
bancaires que nécessaires, chaque compte étant un objet, instance (ou exemplaire) de la classe
Compte.

Un compte bancaire est identifié par un numéro de compte. Ce numéro de compte est un
entier positif permettant de désigner et distinguer sans ambiguïté possible chaque compte géré
par l'établissement bancaire. Chaque compte possède donc un numéro unique. Ce numéro est
attribué par la banque à l'ouverture du compte et ne peut être modifié par la suite. Dans un
souci de simplicité (qui ne traduit pas la réalité) on adoptera la politique suivante pour
l'attribution des numéros de compte : les comptes sont numérotés de 1 à n, n étant le nombre
de comptes qui ont été créés. Lorsqu‟un nouveau compte est créé, le numéro qui lui est
attribué est n+1.

Un compte est associé à une personne (civile ou morale) titulaire du compte, cette personne
étant décrite par son nom. Une fois le compte créé, le titulaire du compte ne peut plus être
modifié.

La somme d'argent disponible sur un compte est exprimée en Dinar. Cette somme est
désignée sous le terme de solde du compte. Ce solde est un nombre décimal qui peut être
positif, nul ou négatif.

Le solde d'un compte peut être éventuellement (et temporairement) être négatif. Dans ce cas,
on dit que le compte est à découvert. Le decouvert d'un compte est nul si le solde du compte
est positif ou nul, il est égal à la valeur absolue du solde si ce dernier est négatif.

En aucun cas le solde d'un compte ne peut être inférieur à une valeur fixée pour ce compte.
Cette valeur est définie comme étant - (moins) le découvert maximal autorisé pour ce compte.
Par exemple pour un

compte dont le découvert maximal autorisé est 2000 D, le solde ne pourra pas être inférieur à
-2000 D. Le découvert maximal autorisé peut varier d'un compte à un autre, il est fixé
arbitrairement par la banque à la création du compte et peut être ensuite révisé selon les
modifications des revenus du titulaire du compte.

Créditer un compte consiste à ajouter un montant positif au solde du compte. Débiter un

85
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

compte consiste à retirer un montant positif au solde du compte. Le solde résultant ne doit en
aucun cas être inférieur au découvert maximal autorisé pour ce compte.

Lors d'une opération de retrait, un compte ne peut être débité d'un montant supérieur à une
valeur désignée sous le terme de débit maximal autorisé. Comme le découvert maximal
autorisé, le débit maximal autorisé peut varier d'un compte à un autre et est fixé arbitrairement
par la banque à la création du compte. Il peut être ensuite révisé selon les modifications des
revenus du titulaire du compte.

Effectuer un virement consiste à débiter un compte au profit d'un autre compte qui sera
crédité du montant du débit. Lors de la création d'un compte seul le nom du titulaire du
compte est indispensable. En l'absence de dépot initial le solde est fixé à 0. Les valeurs par
défaut pour le découvert maximal autorisé et le débit maximal autorisé sont respectivement de
800 D et 1000 D. Il est éventuellement possible d'attribuer d'autres valeurs à ces
caractéristiques du compte lors de sa création.

Toutes les informations concernant un compte peuvent être consultées : numéro du compte,
nom du titulaire, montant du découvert maximal autorisé, montant du débit maximal autorisé,
situation du compte (est-il à découvert ?), montant du débit autorisé (fonction du solde
courant et du débit maximal autorisé).

Travail à faire

1) A partir du "cahier des charges" précédent élaborer une spécification d'une classe Java
modélisant un compte bancaire. Il s'agira en analysant le texte ci-dessus de :
o définir les attributs (variables d'instance, variables de classe) de la classe Compte,
o d'identifier les méthodes publiques proposées par la classe Compte : Pour chaque
méthode on prendra soin, outre la définition de sa signature, de spécifier son
comportement sous la forme d'un commentaire documentant.
o de proposer un ou plusieurs constructeurs pour la classe Compte. Là aussi on
complétera la donnée de la signature de chaque constructeur avec un commentaire
documentant détaillant son utilisation.
2) Réaliser une implémentation en langage Java de la classe précédemment spécifiée.
3) Ecrire un programme de test permettant de :
Créer un compte c1, au nom de Mohamed avec un solde initial de 1 000 D
Créer un compte c2, au nom de Mohamed avec un solde initial de 50 000 D, un débit maximal
autorisé de 6000 D et un découvert maximal autorisé de 5000 D.
D'afficher les caractéristiques des comptes c1 et c2 (c'est à dire les informations suivantes :
numéro du compte, nom du titulaire, découvert maximal autorisé, débit maximal autorisé,
solde du compte et si le compte est à découvert un message le signalant explicitement).
Retirer 300 D du compte c1
Retirer 600 D du compte c2
Déposer 500 D sur le compte c1
D'afficher les caractéristiques des comptes c1 et c2

86
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Virer 1000 D du compte c2 vers le compte c1


D'afficher les caractéristiques des comptes c1 et c2

Exercice 2

But: Trouver des erreurs dans le codage de méthodes

Thème: Modularisation

Enoncé

Chacune des méthodes methode1 à methode8 dans le programme ErreursMethodes.java ci-


dessous contient une seule erreur syntaxique. Il s'agit d'erreurs liées à l'utilisation des
paramètres, des variables ou de la valeur retournée par la méthode. Il n'y pas d'erreurs dans la
méthode main, ni dans la méthode methodeSansErreurs. Trouvez et corrigez les erreurs :

class ErreursMethodes {
public static void main (String[] args) {
int i1 = methode1();
int i2 = methode2();
int i3 = methode3();
int i4 = methode4();
methode5();
methode6();
methode7();
methode8();
}

static int methode1 {


int a = 0;
System.out.println("Méthode 1");
return a;
}
static int methode2 () {
int a = 0;
i1 = 10;
System.out.println("Méthode 2");
return a;
}
static int methode3 () {
int a = 0;
System.out.println("Méthode 3");
}
static int methode4 () {
String a = "0";

87
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

System.out.println("Méthode 4");
return a;
}
static void methode5 () {
double a = 0;

System.out.println("Méthode 5");
return a;
}
static methode6 () {
double a = 0;
System.out.println("Méthode 6");
return a;
}
static void methode7 () {
int a = 0;
double b = 5.5;
methodeSansErreur(a);
System.out.println("Méthode 7");
}
static void methode8 () {
int a = 0;
String b = "5.5";
methodeSansErreur(a, b);
System.out.println("Méthode 8");
}
static void methodeSansErreur (int a, double b) {
// Cette méthode ne fait rien du tout
}
}

88
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Correction TD3 : Objet, Classe, Attribut de classe


Exercice 1 :

Solution

public class CompteBancaire {


//attribut
int numCompte;
static int nombreCompte;
String Personne;
double solde;
boolean decouvert;
double decouvertMax;
double debitMax;
//constructeur
public CompteBancaire(String Personne,double dcmax,double dbmax){
nombreCompte++;
numCompte=nombreCompte;
this.Personne=Personne;
decouvertMax=dcmax;
debitMax=dbmax;
}
void crediterCompte(double montant)
{ solde+=montant; }

void debiterCompte(double montant)


{
double Res;
Res=solde-montant;
if(Res<= -decouvertMax)
{
System.out.println("operation incorrecte");
} else if(montant > debitMax)
{
System.out.println("solde insuffisant") ;
}
else
{
solde=Res;
}
}
void virement(CompteBancaire c,double mantant)
{
c.debiterCompte(mantant);
crediterCompte(mantant);

89
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

}
public String ToString()
{
return("NumCompte:"+numCompte+" titulaire: "+Personne+" solde "+solde);
}
}

public class TestCompte {

/**

* @param args the command line arguments

public static void main(String[] args) {

// TODO code application logic here

//Creation des comptes

CompteBancaire BTS;

CompteBancaire UIB;

BTS=new CompteBancaire("Mohamed",1200,1800);

System.out.println(CompteBancaire.nombreCompte);

UIB=new CompteBancaire("mohamed",1200,300);

System.out.println(CompteBancaire.nombreCompte);

BTS.crediterCompte(1000);

BTS.debiterCompte(200);

System.out.println(BTS.ToString());

UIB.crediterCompte(1000);

UIB.debiterCompte(400);

System.out.println(UIB.ToString());}}

Exercice 2 :

Solution

une liste
de paramètres dans l'en-tête. Dans ce cas, il faut ajouter des parenthèses vides.

90
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

methode2. La portée d'une variable est limitée à son bloc de déclaration, dans le cas de i1 à la
méthode main.

return. Cette instruction est


obligatoire pour toutes les méthodes qui retournent une valeur, i.e. qui n'a pas le type void
dans l'en-tête.

-
tête de la méthode.

methode5: La méthode essaie de retourner une valeur avec return. Cela n'est pas possible
si l'en-tête de la méthode est void.

pas de valeur, il faut indiquer void dans l'en-tête.

2. Le nombre d'arguments doit toujours correspondre au nombre de paramètres.

ce qui est
correct, mais le type des arguments ne correspond pas au type des paramètres.

class ErreursMethodesCorrige {

public static void main (String[] args) {


int i1 = methode1();

int i2 = methode2();
int i3 = methode3();
int i4 = methode4();
methode5();
methode6();
methode7();
methode8();
}

static int methode1 () {


int a = 0;
System.out.println("Méthode 1");
return a;
}

static int methode2 () {


int a = 0;
// i1 = 10;
System.out.println("Méthode 2");

91
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

return a;
}

static int methode3 () {


int a = 0;
System.out.println("Méthode 3");
return a; }

static int methode4 () {


// String a = "0";
int a = 0;
System.out.println("Méthode 4");
return a;
}

static void methode5 () {


double a = 0;
System.out.println("Méthode 5");
// return a;
}
static double methode6 () {
double a = 0;
System.out.println("Méthode 6");
return a;
}
static void methode7 () {
int a = 0;
double b = 5.5;
methodeSansErreur(a, b);
System.out.println("Méthode 7");
}

static void methode8 () {


int a = 0;
// String b = "5.5";
double b = 5.5;
methodeSansErreur(a, b);
System.out.println("Méthode 8");
}
static void methodeSansErreur (int a, double b) {
// Cette méthode ne fait rien du tout }}

92
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

TD4 : Modificateurs de visibilité


Exercice

But Trouver l'erreur dans un programme donné

Thème POO de base +visibilité des méthodes et des attributs

Enoncé

La classe Erreurs contient une méthode main et sert à démarrer le programme. La classe
GrillePain sert à représenter des grille-pains dans le programme sous forme d'objets dotés de
deux variables d'instance: l'année de fabrication et le nombre de tranches que l'appareil peut
griller. Il y a également une méthode d'instance afficherVariables que l'on peut appliquer sur
un objet de type GrillePain afin d'afficher les valeurs de ses variables d'instance.

NetBeans vous signale des messages d'erreurs à propos de ce programme. Pourquoi?


Corrigez-les.

L'affichage lors de l'exécution montre que la variable d'instance nbTranches a la valeur 0 pour
les deux grille-pains même si l'on a envoyé une autre valeur à la méthode constructeur.
Pourquoi? Corrigez le programme.

Exemple d'exécution du programme (après la première correction):

Objet de type GrillePain avec variables d'instance


annee = 1995 et nbTranches = 2
Objet de type GrillePain avec variables d'instance
annee = 1998 et nbTranches = 4
Code donné:

class Erreurs {
public static void main(String[] args) {
GrillePain g1 = new GrillePain(1995, 2);

g1.afficherVariables();
GrillePain g2 = new GrillePain(1998, 4);
g2.afficherVariables();
}
}
class GrillePain {
private int annee;
private int nbTranches;
private GrillePain(int a, int nbTranches) {
annee = a;
nbTranches = nbTranches;
}
private void afficherVariables() {

93
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

System.out.println
("Objet de type GrillePain avec variables d'instance année = " +
annee + " et nbTranches = " + nbTranches);
}
}

94
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Correction TD4 : Modificateurs de visibilité


Exercice

Solution

Le programmeur a trop utilisé le mot-clé private au point que l'on ne peut même pas accéder à
la méthode constructeur depuis l'extérieur de la classe, ni à la méthode afficherVariables(). Il
faut rendre ces deux méthodes publiques en supprimant le mot-clé private.

Les variables d'instance (mais pas les variables locales) reçoivent toujours des valeurs par
défaut. Si la variable d'instance nbTranches n'est pas initialisée, elle aura donc la valeur 0.
Dans la méthode constructeur, il y a une situation de shadowing où le paramètre a le même
nom que la variable d'instance. Il faut utiliser l'objet this pour différencier les deux et ainsi
affecter la valeur du paramètre nbTranches à la variable d'instance nbTranches.

Erreurs.java
* Version corrigée */
class Erreurs {
public static void main (String[] args) {
GrillePain g1 = new GrillePain(1995, 2);
g1.afficherVariables();
GrillePain g2 = new GrillePain(1998, 4);
g2.afficherVariables();
}
}

class GrillePain {
private int annee;
private int nbTranches;

public GrillePain (int a, int nbTranches) { // !!! pas de private


annee = a;
this.nbTranches = nbTranches; // !!! this
}

public void afficherVariables() { // !!! pas de private


System.out.println
("Objet de type GrillePain avec variables d'instance année = " +
annee + " et nbTranches = " + nbTranches); }}

95
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

TD5 : Héritage et polymorphisme

Exercice 1 :

But: Réviser les notions vues en cours

Thème: Héritage +interface+classe abstraite

Enoncé :

Répondez aux questions suivantes :

1-Quel mot clé doit-on utiliser pour instancier un objet ?

this

new

public

2-Que signifie créer une instance de classe ?

Créer une classe.

Initialiser un objet

Créer un objet

3-Comment appelle-t-on une méthode portant le même nom qu'une autre méthode, mais avec
des paramètres différents ?

Une méthode accentuée

Une méthode surchargée

Une erreur.

4-Quel mot clé permet de créer une variable(attrinut) de classe ?

statiq

static

statik

statique

5-Lorsqu‟une classe B hérite d‟une classe A

A est la sous-classe

B est la classe fille

96
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

A est la super-classe

B est la classe mère

6-Avec quel mot clé une classe est-elle définie comme abstraite ?

abstrakt

abstracte

abstract

7-Dans quel cas doit-on utiliser une classe abstraite ?

Pour définir une classe mère

Pour définir une classe mère qui ne doit pas être instanciée.

Pour définir une classe héritée

8-Ce code est-il correct ?

abstract class A{

abstract void toto(){

System.out.println("toto");

} }

Oui

Non

Je ne sais pas

9-Qu'est-ce qu'une interface ?

Une classe abstraite

Une classe abstraite

Une classe abstraite mais contenant uniquement des méthodes abstraites

10-Avec quel mot clé utilise-t-on une interface ?

inpléments

implement

implements
97
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

implément

11-Une classe générique (paramétrable) est

Une classe abstraite

Un modèle de classe

Un modèle d‟objet

12-Le modificateur « protected » pour un membre de classe signifie que ce membre

est accessible, partout, en dehors de la classe

est accessible uniquement à l‟intérieur de la classe

est accessible à l‟intérieur de la classe et à l‟intérieur de ses descendants

Exercice 2

But Décrire les données d'un jeu simulant des combats de


magiciens

Thème polymorphisme

Enoncé

Vous vous intéressez dans cet exercice à décrire les données d'un jeu simulant des combats de
magiciens.
Dans ce jeu, il existe trois types de cartes : les terrains, les créatures et les sortilèges.
Les terrains possèdent une couleur (parmi 5 : blanc('B'), bleu ('b'), noir ('n'), rouge ('r') et vert
('v').)
Les créatures possèdent un nom, un nombre de points de dégâts et un nombre de points de vie.
Les sortilèges possèdent un nom et une explication sous forme de texte.

De plus, chaque carte, indépendamment de son type, possède un coût. Celui d'un terrain est 0.
Dans un programme Magic.java, proposez (et implémentez) une hiérarchie de classes
permettant de représenter des cartes de différents types.
Chaque classe aura un constructeur permettant de spécifier la/les valeurs de ses attributs. De
plus, chaque constructeur devra afficher le type de la carte.
Le programme doit utiliser la conception orientée objet et ne doit pas comporter de
duplication de code.
Ajoutez ensuite aux cartes une méthode afficher() qui, pour toute carte, affiche son coût et la
valeur de ses arguments spécifiques.
Créez de plus une classe Jeu pour représenter un jeu de cartes, c'est-à-dire une collection de
telles cartes.
Cette classe devra avoir une méthode piocher permettant d'ajouter une carte au jeu. On
supposera qu'un jeu comporte au plus 10 cartes. Le jeu comportera également une méthode
joue permettant de jouer une carte. Pour simplifier, on jouera les cartes dans l'ordre où elles

98
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

sont stockées dans le jeu, et on mettra la carte jouée à null dans le jeu de cartes.
Pour finir, dans la méthode main, constituez un jeu contenant divers types de cartes et faites
afficher le jeu grâce à une méthode affic her propre à cette classe.
Par exemple la méthode main pourrait ressembler à quelque chose comme cela :

class Magic {
public static void main(String[] args) {
Jeu maMain = new Jeu(10);
maMain.piocher(new Terrain('b'));
maMain.piocher(new Creature(6, "Golem", 4, 6));
maMain.piocher(new Sortilege(1, "Croissance Gigantesque","La créature ciblée gagne
+3/+3 jusqu'à la fin du tour"));

System.out.println("Là, j'ai en stock :");


maMain.afficher();
maMain.joue();
}}
qui produirait quelque chose comme :
On change de main
Un nouveau terrain.
Une nouvelle créature.
Un sortilège de plus.
Là, j'ai en stock :
Un terrain bleu
Une créature Golem 4/6
Un sortilège Croissance Gigantesque
Je joue une carte...
La carte jouée est :
Un terrain bleu

99
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Correction TD5 : Héritage et polymorphisme

Exercice1

Solution

Quel mot clé doit-on utiliser pour instancier un objet ?

new
Que signifie créer une instance de classe ?

Créer un objet
Comment appelle-t-on une méthode portant le même nom qu'une autre méthode, mais avec
des paramètres différents ?

Une méthode surchargée


Quel mot clé permet de créer une variable(attribut) de classe ?

static

Lorsqu‟une classe B hérite d‟une classe A

B est la classe fille


A est la super-classe

Avec quel mot clé une classe est-elle définie comme abstraite ?

abstracte

Dans quel cas doit-on utiliser une classe abstraite ?

Pour définir une classe mère qui ne doit pas être instanciée.

Ce code est-il correct ?

abstract class A{
abstract void toto(){
System.out.println("toto");
}
}
Non

100
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Qu'est-ce qu'une interface ?

Une classe abstraite mais contenant uniquement des méthodes abstraites


Avec quel mot clé utilise-t-on une interface ?
implements
Le modificateur « protected » pour un membre de classe signifie que ce membre
est accessible à l‟intérieur de la classe et à l‟intérieur de ses descendants
Exercice 2 polymorphisme

Solution

/**
* Une petite classe utilitaire pour commencer
*/
class Couleur {
private char valeur;

public Couleur(char c) {
valeur = c;
}
public void afficher() {
this.afficher(false);
}
public void afficher(boolean feminin) {
switch (valeur) {
case 'r':
System.out.println("rouge");
break;
case 'v':
System.out.print("vert");
if (feminin) {
System.out.println("e");
}
break;
case 'b':
System.out.print("bleu");
if (feminin) {
System.out.println("e");
}
break;
case 'B':
System.out.print("blanc");
if (feminin) {

System.out.println("he");

101
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

}
break;
case 'n':
System.out.print("noir");
if (feminin) {
System.out.println("e");
}
break;
}
}
}
// ----------------------------------------------------------------------
// puis.. les classes principales

abstract class Carte {


private int cout;

public Carte() {
cout = 0;
}
public Carte(int cout) {
this.cout = cout;
}
public abstract void afficher();
}

// ----------------------------------------------------------------------

class Terrain extends Carte {


private Couleur couleur;

public Terrain(char c) {
couleur = new Couleur(c);
System.out.println("Un nouveau terrain.");
}
public void afficher() {
System.out.print("Un terrain ");
couleur.afficher();

System.out.println();
}
}

// ----------------------------------------------------------------------

102
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

class Creature extends Carte {

private String nom;


private int attaque;
private int defense;
public Creature(int cout, String nom, int attaque, int defense) {
super(cout);
this.nom = nom;
this.attaque = attaque;
this.defense = defense;
System.out.println("Une nouvelle créature.");
}
public void afficher() {
System.out.println("Une créature " + nom + " " + attaque + "/"
+ defense + " ");
}
}
// ----------------------------------------------------------------------

class Sortilege extends Carte {


private String nom;
private String description;

public Sortilege(int cout, String nom, String desc) {


super(cout);
this.nom = nom;
this.description = desc;
System.out.println("Un sortilège de plus.");
}
public void afficher() {
System.out.println("Un sortilège " + nom + " ");
}
}
// ----------------------------------------------------------------------

class Jeu {
private int nombreCartes;
private Carte[] cartes;
public Jeu(int nb) {
nombreCartes = nb;
cartes = new Carte[nb];
System.out.println("On change de main");
}

103
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

/**
* Joue une carte après l'autre
*/
public void joue() {
System.out.println("Je joue une carte...");
int i = 0;
while ((cartes[i] == null) && i < nombreCartes) {
i++;
}
if ((i < nombreCartes) && (cartes[i] != null)) {
System.out.println("La carte jouée est :");
cartes[i].afficher();
cartes[i] = null;
} else {
System.out.println("Plus de cartes");
}
}
/**
* Ajoute une carte à la collection
*/
public void piocher(Carte carte) {
int i = 0;
while ((i < nombreCartes) && (cartes[i] != null)) {
i++;
}
if (i < nombreCartes) {
cartes[i] = carte;
} else {
System.out.println("Nombre maximal de cartes atteint");
}
}
public void afficher() {
for (int i = 0; i < nombreCartes; ++i) {
if (cartes[i] != null) {
cartes[i].afficher();
}
}
}
}
// ----------------------------------------------------------------------
class Magic {
public static void main(String[] args) {
Jeu maMain = new Jeu(10);

104
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

maMain.piocher(new Terrain('b'));
maMain.piocher(new Creature(6, "Golem", 4, 6));
maMain.piocher(new Sortilege(1, "Croissance Gigantesque",
"La créature ciblée gagne +3/+3 jusqu'à la fin du tour"));

System.out.println("Là, j'ai en stock :");


maMain.afficher();
maMain.joue();
}
}

105
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

TD6 : Exception

Exercice 1 :

But: Comprendre le concept et l‟utilité du mécanisme


d‟exception

Thème: Exception

Enoncé

On veut écrire la fonction saisieCorrecte qui permet de saisir correctement un entier. Si


l'utilisateur saisit une donnée dont le format n'est pas celui d'un entier, le programme lève
l'exception

InputMismatchException.

Travail demandé

La fonction devra traiter cette erreur en fournissant une solution alternative. Un message
d'erreur sera affiché avec la proposition d'effectuer une nouvelle saisie.

Note:La classe InputMismatchException appartient au package java.util

2) L'entier saisi doit être impérativement supérieur à 10. On demande donc de créer une classe
d'exception adaptée à cette erreur, puis de modifier le programme afin de traiter ce cas
d'erreur.

Note: On aurait pu utiliser l'exception prédéfinie IllegalArgumentException pour vérifier


que l'entier saisi est supérieur à10.

Exercice 2

But Savoir gérer les exceptions standard et créer, lancer,


rattraper ses propres exceptions.

Thème Exception

Enoncé

On veut créer une classe définissant des cercles.Les cercles sont caractérisés par leur rayon.
Définir une classe Cercle comportant les deux accesseurs getRayon et setRayon ainsi qu'une
méthode de calcul de la surface. On définira la valeur de p comme une constante de la classe.

Travail demandé

106
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

1) Ecrire la classe TestCercle qui créera 2 instances de cercles et affichera leur surface.
2) A la création d'une instance de cercle, il faut vérifier que la valeur de son rayon est
positive. Dans le cas contraire, on souhaite que le programme de test retourne un message
d'erreur. Comment prendre en compte cette contrainte ?
3) Plutôt que d'envoyer un simple message d'erreur, il serait préférable que le programme ne
s'interrompe pas mais demande une nouvelle saisie du rayon. Modifier le programme en
conséquence.
4) On souhaite encore modifier le programme pour lui permettre d'afficher le nombre
d'instances de la classe Cercle créées.

107
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Correction TD6 : Exception


Exercice 1

Solution

import java.util.Scanner;
import static java.lang.System.*;
import java.util.InputMismatchException;
public class SaisieEntier{
static int saisieCorrecte(){
Scanner input = new Scanner(System.in);
int x;
do{
try{
out.println("entrez un entier -> ");
x = input.nextInt();
break;
}
catch(InputMismatchException e){
// il faut consommer la valeur du buffer d'entrée
s = input.next();
out.println("Erreur Recommencez");
}
}while(true);
return x;
}
public static void main(String[]args){
out.println("entier saisi : "+saisieCorrecte());
}
}
2)

import java.util.Scanner;
import static java.lang.System.*;
import java.util.InputMismatchException;

public class SaisieEntier{


static class Inf10Exception extends Exception{
public Inf10Exception(){
super( "division par zéro" );
}

108
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

public Inf10Exception(String msg){


super( msg );
}
}
static int saisieCorrecte () {
Scanner input = new Scanner(System.in);
int x = 0;
String s = null;
do {
try {
out.println("entrez un entier -> ");
x = input.nextInt();
if(x<=10) throw new Inf10Exception();
break;
}
catch ( InputMismatchException e) {
// il faut consommer la valeur du buffer d'entrée
s = input.next();
out.println(s+"n'est pas un entier");
out.println ("Erreur Recommencez");}
catch ( Inf10Exception e) {
out.println(x+" est inférieur ou égal à 10");
out.println ("Erreur Recommencez");}
} while (true);
return x;
}
public static void main(String[]args){
out.println("entier saisi : "+saisieCorrecte());
}
}
Exercice 2

Solution
1)
public class Cercle{
private double rayon;
private static final double PI=3.14159;
public Cercle( double rayon ){
this.rayon = rayon;
}
public double getRayon(){
return rayon;
}
public void setRayon( double rayon ){
this.rayon = rayon;

109
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

}
public double surface(){
return rayon*rayon*PI;}}

2)
import static java.lang.System.*;
import java.text.*;
public class TestCercle{
public static void main(String[] args){
Cercle c1 = new Cercle(23.7);

Cercle c2 = new Cercle(8.7);


NumberFormat formatter = new DecimalFormat("#.00");
String s = formatter.format(c1.surface());
out.println("surface du cercle c1 :"+s);
s = formatter.format(c2.surface());
out.println("surface du cercle c2 :"+s);
}
}

3)
public Cercle( double rayon ) throws IllegalArgumentException{
if(rayon<=0) throw new IllegalArgumentException
("la valeur du rayon est négative");
this.rayon = rayon;
}
import static java.lang.System.*;
import java.text.*;
public class TestCercle{
public static void main(String[] args){
Cercle c1,c2;
try{
c1 = new Cercle(23.7);
c2 = new Cercle(-8.7);
}catch( IllegalArgumentException e){
out.println(e);
}
NumberFormat formatter = new DecimalFormat("#.00");
String s = formatter.format(c1.surface());
out.println("surface du cercle c1 :"+s);
s = formatter.format(c2.surface());
out.println("surface du cercle c2 :"+s);
}}

110
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

4)

import static java.lang.System.*;


import java.text.*;
import javax.swing.JOptionPane;

public class TestCercle{


public static void main(String[] args){
double rayon;
String data = null;
String s = null;
int rep=0;
NumberFormat formatter = null;
do{
try{
data = JOptionPane.showInputDialog(null,
"entrer une valeur derayon",
"Boîte de saisie",
JOptionPane.INFORMATION_MESSAGE);
rayon = Double.parseDouble(data);
formatter = new DecimalFormat("#.00");
s = formatter.format(new Cercle(rayon).surface());
out.println("surface du cercle c :"+s);
rep = JOptionPane.showConfirmDialog(null,
"Voulezvouscontinuer ?",
"Votre réponse? ",
JOptionPane.YES_NO_OPTION);
}catch( IllegalArgumentException e){
out.println(e);
}
}while(rep==0);
}}

5)
public class Cercle{
private double rayon;
private static final double PI=3.14159;// ou Math.PI
private static int nbInstances=0;
public Cercle( double rayon ){
if(rayon<=0)
throw new IllegalArgumentException
("la valeur du rayon est négative");
this.rayon = rayon;
nbInstances++;

111
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

}
public double getRayon(){
return rayon;
}
public void setRayon( double rayon ){
this.rayon = rayon;
}
public double surface(){
return rayon*rayon*PI;
}
public static int getNbInstances(){
return nbInstances;
}
}

6)
On ajoute la ligne suivante à la fin du programme de test :
out.println("nombre d'instances : "+Cercle.getNbInstances());

112
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

Bibliographie

[1] BIEN DEBUTER EN JAVA BAPTISTE WICHT


[2] COURS DE BASE JAVA RENAUD ZIGMANN
[3] COURS PROGRAMMATION ORIENTEE OBJET EN JAVA
RIADH BEN HLIMA-ENIS-2008
[4] COURS PROGRAMMATION ORIENTEE OBJET EN JAVA
SLIM KANOUN –ENIS-2008
[5] DEVELOPPONS EN JAVA JEAN MICHEL DOUDOUX
[6] PENSER EN JAVA BRUCE ECKEL
[7] PROGRAMMATION ORIENTEE OBJET
TEGAWENDE F. BISSYANDE ET NABILA REMLI
[8] LE LIVRE DE JAVA PREMIER LANGAGE ANNE TASSO
[9] INTRODUCTION A LA PROGRAMMATION ORIENTEE OBJET (EN JAVA)
VINCENT LEPETIT, JEAN-CEDRIC CHAPPELIER ET JAMILA SAM
[10] LA PROGRAMMATION OBJET EN JAVA DUNOD-SCIENCES SUP

113
SUPPORT DU COURS AVEC EXERCICES CORRIGEES II PROGRAMMATION ORINTEE OBJET II ISET KASSERINE II LAILA NAKKAII

114

Vous aimerez peut-être aussi