REPUBLIQUE TUNISIENNE MINISTERE DE L’ENSEIGNEMENT

SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUE

Institut Supérieur des Etudes Technologiques de Médenine

Département Informatique

Support de cours et TD Programmation Orientée Objet

Niveau : TI2

Elaboré par : BOUABID Mohamed

Année universitaire : 2011-2012


Objectifs du cours :
Ce cours permet à l’étudiant d’acquérir les connaissances nécessaires pour écrire des
programmes orientés objets.

Objectifs spécifiques :
• Comprendre les concepts de base de la programmation orientée objet.
• Implémenter des classes d’objets : créer une classe en précisant ses propriétés
et ses opérations et leur visibilité, et en définissant ses constructeurs
• Comprendre le principe d’héritage.
• Comprendre le principe du polymorphisme
• Comprendre les notions d’interfaces et des classes abstraites.
• Comprendre le mécanisme de gestion des exceptions

Pré-requis :
Programmation, algorithmique et structure de données.

Bibliographie
• Livres de référence
o Programmer en Java de Claude Delannoy aux éditions Eyrolles
o Penser en Java, Seconde édition de Bruce Eckel

Note de cours « Apprentissage du langage Java », Serge Tahé - ISTIA -

Université d'Angers

• Autre ouvrage sur Java

o Programmation JavaTM pour les enfants, les parents et les grands-
parents, Yakov Fain (c’est un livre électronique)

p. 2
TI2 -M.BOUABID
Table des matières
Introduction à la Programmation Orientée Objet .................................................................................. 6
1. De la programmation classique vers la programmation orientée objet ............................... 6
2. Notions de base de la POO........................................................................................................ 7
2.1 Notion d'objet ........................................................................................................................ 7
2.2 Notion de classe ...................................................................................................................... 8
2.3 Notion d’encapsulation ......................................................................................................... 9
3. Les langages orientés objet ....................................................................................................... 9
Syntaxe de base du langage Java ........................................................................................................... 10
2.1. Les données de Java ........................................................................................................... 10
2.1.1 Les variables ................................................................................................................ 10
a) Les noms de variables ......................................................................................................... 10
b) Les types de base de Java.................................................................................................... 10
c) Déclarer une variable .......................................................................................................... 11
2.1.2 Les Constantes ............................................................................................................. 11
2.2. Tableaux et matrices ........................................................................................................... 12
2.3. Chaînes de caractères .......................................................................................................... 12
2.4. L’instruction d’affectation .................................................................................................. 13
2.5. Opérateurs et expressions ................................................................................................... 13
2.5.1. Expression arithmétique ................................................................................................. 13
2.5.2. Expressions relationnelles ............................................................................................... 13
2.5.3. Expressions booléennes ................................................................................................... 13
2.5.4. Combinaison d'opérateurs .............................................................................................. 13
2.5.5. Opérateurs d'incrémentation et de décrémentation..................................................... 14
2.5.6. L'opérateur ? ................................................................................................................... 14
2.6. Structures de contrôle ......................................................................................................... 14
2.6.1. Instruction conditionnelle : if ......................................................................................... 14
2.6.2. Instruction conditionnelle : switch ................................................................................. 14
2.6.3. Itérations : while, do...while et for.................................................................................. 14
2.7. Commentaires ...................................................................................................................... 15
Classes et objets..................................................................................................................................... 16
3.1. Structure d’un programme autonome Java...................................................................... 16

p. 3
TI2 -M.BOUABID
 3.2. Package ................................................................................................................................. 16
3.3. objets et classes .................................................................................................................... 17
2.3.1. Généralités ....................................................................................................................... 17
2.3.2. Accès au membre d’une classe ....................................................................................... 18
2.3.3. L'opérateur new............................................................................................................... 19
2.3.4. Le mot clé this .................................................................................................................. 19
2.3.5. Un programme de test ..................................................................................................... 20
2.3.6. Les constructeurs de classe ............................................................................................ 20
2.3.7. Les méthodes de lecture et d'écriture des attributs privés .......................................... 21
2.3.8. Les méthodes et attributs de classe ................................................................................ 23
Héritage ................................................................................................................................................. 25
5.1. La notion d'héritage ................................................................................................................ 25
5.2. Accès d’une classe dérivée aux membres de sa classe de base............................................. 26
5.3. Construction et initialisation des objets dérivés ................................................................... 26
5.4. La notion de redéfinition et surdéfinition de méthodes ....................................................... 27
5.4.1 Redéfinition ...................................................................................................................... 27
5.4.2 Surdéfinition .................................................................................................................... 28
Le polymorphisme ................................................................................................................................. 29
6.1. Concept de polymorphisme .................................................................................................... 29
6.2. Exemple et interprétations...................................................................................................... 29
6.3. Les conversions explicites de références ................................................................................ 30
Les classes abstraites et les interfaces ................................................................................................... 32
7.1. Les classes abstraites ............................................................................................................... 32
7.1.1. Concept des abstraites..................................................................................................... 32
a) Syntaxe ................................................................................................................................. 32
b) Utilisation ............................................................................................................................. 32
c) Remarques ........................................................................................................................... 32
d) Exemple ................................................................................................................................ 33
7.2. Les interfaces ........................................................................................................................... 34
7.2.1. Concept d’interface ......................................................................................................... 34
a) Définitions d’une interface.................................................................................................. 34
b) Implémentation d’une interface ......................................................................................... 34
c) Exemple ................................................................................................................................ 34
d) Interface et constantes......................................................................................................... 35
p. 4
TI2 -M.BOUABID
 e) Remarques ........................................................................................................................... 35
Les exceptions ....................................................................................................................................... 37
8.1. Traitement des exceptions ...................................................................................................... 37
8.2. Les exceptions prédéfinies ...................................................................................................... 38
8.3. Les exceptions personnalisées................................................................................................. 38

Travaux dirigés .................................................................................................................................. 40

p. 5
TI2 -M.BOUABID
Chapitre 1 –Introduction
Introduction à la Programmation orientée Objet

Chapitre 1
Introduction à la Programmation Orientée Objet

1. De la programmation classique vers la programmation orientée objet

Les premiers programmes informatiques étaient généralement constitués d’une suite
d’instructions s’exécutant de façon linéaire (l’exécution commence de la première
instruction du fichier source et se poursuivait ligne après ligne jusqu’à la dernière
instruction du programme).

Cette approche, bien que simple à mettre en œuvre, a très rapidement montré
montr ses
limites. En effet, les programmes monolithiques de ce type :
− ne se prêtent guère à l’écriture de grosses applications
− et ne favorisent absolument pas la réutilisation du code.
En conséquence est apparue
apparu une autre approche radicalement différente : l’approche
procédurale.

L’approche procédurale (classique) consiste à découper un programme en un

ensemble de fonctions
onctions (ou procédures). Ces fonctions contiennent un certain nombre
d’instructions qui ont pour but de réaliser un traitement particulier.
Exemples de traitements qui peuvent être symbolisés par des fonctions :
− Le calcul de la circonférence d’un cercle
− l’impression de la fiche de paie d’un salarié
− etc.

Dans le cas de l’approche procédurale, un programme correspond à l’assemblage de

plusieurs fonctions qui s’appellent entre elles.

F1
Bloc
monolithique
F2 P1

Fonctions et procédures F3 P
P2 P3

Exemple de langages de programmation procédurale : C, Pascal, Ada,, Cobol, Fortran, etc.

L’approche procédurale favorise :

 La création d'un code plus modulaire et structuré
 La possibilité de réutiliser le même code à différents emplacements dans le
programme sans avoir à le retaper

p. 6
TI2 -M.BOUABID
Chapitre 1 –Introduction à la Programmation orientée Objet

Malgré ses avantages, l’approche procédurale présente également des inconvénients :

 Les fonctions, procédures accèdent à une zone où sont stockées les données. Il y a
donc une dissociation entre les données et les fonctions ce qui pose des difficultés
lorsque l’on désire changer les structures de données.

 Dans les langages procéduraux, les procédures s’appellent entre elles et peuvent donc
agir sur les mêmes données .Il ya donc un risque de partage des données (écriture en
même temps dans le même le fichier).

De ces problèmes sont issus une autre manière de programmer : la programmation par objet.

L’approche orientée objet (Début des années 80).

Selon cette approche, un programme est vu comme un ensemble d’entités (ou objets). Au
cours de son exécution, ces entités collaborent en s’envoient des messages dans un but
commun.
Objet 1

Objet 2 Objet 3

Nous avons dans ce schéma un lien fort entre les données et les fonctions qui y accèdent.
Mais qu’appelle-t-on un objet ? Que représente un objet ?

2. Notions de base de la POO

2.1 Notion d'objet
Un objet est une entité caractérisée par :
− Une identité : L’identité d’un objet permet de distinguer l’objet par rapport aux
autres.
− Un état interne : correspond aux valeurs de tous les attributs à un instant donné.
− Un comportement : se défini par l’ensemble des opérations qu’il peut exécuter en
réaction aux messages envoyés (un message = demande d’exécution d’une opération)
par les autres objets.

 Exemple : l’objet « employe »

Dans une entreprise, un employé toto (son matricule 100 permet son identification unique
dans l’entreprise), est employé sur un poste de technicien dans la société X située à Tunis.

p. 7
TI2 -M.BOUABID
Chapitre 1 –Introduction à la Programmation orientée Objet

Son état est caractérisé par l’ensemble des valeurs de ses attributs.
− Matricule : 100
− nom : TOTO
− qualification : Technicien
− Lieu de travail : Tunis

Son comportement est caractérisé par les opérations qu’il peut réaliser :
− entrer/sortir de la société
− changer de qualification
− changer de lieu de travail

Bref, l’ensemble des opérations pouvant affecter ses attributs.

Un objet est caractérisé par des :

− Des attributs : des variables représentant l'état de l'objet
− Des méthodes : fonctions ou procédure décrivant son comportement.

2.2 Notion de classe

Certains objets présentent les mêmes caractéristiques. Ils ont des identités différents
mais :
− Un état défini sur les mêmes propriétés
− Un comportement similaire

Exemple :

employe 1 employe 2
100 102
Ali & Mohamed
Ingénieur technicien

« employe1 » et « employe 2 » sont caractérisés par les mêmes propriétés (matricule,

nom, qualification) mais associés à des valeurs différents. Ils ont la même
comportement (entrer/sortir de la société, changer de qualification.) mais ont des
identités différentes.
Et il en serait de même pour tous les employés.
Tous les employés obéissent à un même schéma.
On peut donc en abstraire un modèle.
En POO, un tel modèle est appelé classe.

Une classe regroupe un ensemble d'objet qui possède une structure identique (liste des
attributs) et un même comportement (liste des opérations).
Un objet est une instance d’une classe. Employe
Exemple : La classe <<Employe>>
-matricule
-nom
-qualification
-entrer()
-changerPoste()
-changerLieuTravail()
p. 8
TI2 -M.BOUABID
Chapitre 1 –Introduction à la Programmation orientée Objet

2.3 Notion d’encapsulation

Si l’on reprend l’exemple précédent, la classe est l’employé, l’instance de classe (l’objet) est
l’employé 100, TOTO, …

Par rapport à une approche « classique » que l’on peut observer dans la programmation
procédurale, l’approche objet se caractérise par le regroupement dans une même classe de la
description des attributs et des opérations (méthodes). Ce regroupement s’appelle
l’encapsulation. On masque l’information au monde extérieur.

L’état interne est visible donc de l’objet seul. Comment accéder ou modifier l’état interne de
l’objet ?en utilisant deux types de messages :
− Accesseur : accéder à la valeur d’un attribut
− Modificateur : modifier la valeur d’un attribut
Exemple : accesseur « nom »

employe1 Nom
Matricule : 100
Nom : Ali Ali
Qualification : ingénieur

3. Les langages orientés objet

Un langage est orienté objet s’il possède les mécanismes supportant le style de
programmation orientée objet.
Il ya plusieurs langages de programmation OO actuellement : Java, c++, c#, PHP, etc.
Nous allons nous intéresser dans la suite de ce cours au langage java.
Java est un langage développé par SunMicrosystems (racheté par oracle en 2009) en
1995. La particularité de ce langage est qu'il a été conçu directement comme un
langage de programmation orienté objets contrairement au C++ ou l'aspect n'est
qu'une extension du C. Java est aussi caractérisé par le faite qu'il est un langage
portable : l'utilisateur peut développer un sous windows et l'exécuter sous des
environnements et architectures diverses tels que MacOS, Linux et bien d'autres.

p. 9
TI2 -M.BOUABID
 Chapitre 2 –Syntaxe de base du langage Java

Chapitre 2
Syntaxe de base du langage Java
Nous traitons Java d'abord comme un langage de programmation classique. Nous aborderons
les objets ultérieurement, dans les chapitres suivants.
Dans un programme on trouve :
• des données
• les instructions qui les manipulent

2.1. Les données de Java

2.1.1 Les variables
Une variable est caractérisée par :
• un Nom : permet de repérer l’emplacement mémoire dans lequel la valeur est
placée.
• un Type : détermine la façon dont est traduite la valeur en code binaire ainsi
que la taille de l’emplacement mémoire.

a) Les noms de variables

Les identificateurs ne peuvent commencer que par une lettre, un souligné (’ _’) ou un
dollar (’$’). Les caractères suivants peuvent être des lettres ou des chiffres.
Exemples : nom ,_nom $nom

 Note : Il convient de réserver des noms commençant par une majuscule aux classes.
Les noms composés sont sous la forme “NomCompose” ou bien “nomCompose”, et
de façon générale, on conseille de nommer les variables et méthodes de façon parlante.
Exemple :
• classes : Personne, Livre, Matière, etc.
• nom composé : dateDeNaissance

b) Les types de base de Java

Il faut préciser le type des variables utilisées.
Dans chaque langage, il existe un nombre de types prédéfinis.
Ces types sont dits simples, car, à un instant donné, une variable de type simple ne
peut contenir qu’une et une seule valeur.

 Remarque :
Nous rencontrerons par la suite des types structurés qui permettent le stockage, sous un
même nom de variable, de plusieurs valeurs de même type ou non.
Il s’agit des tableaux, des classes, des vecteurs, etc.

Les types simples en Java sont les suivants :

• Caractères : le type caractère est char. Il est représenté sur 16 bits.
• Booléens : le type booléen est boolean. Les deux seules valeurs qu’il peut
prendre sont true et false.

p. 10
TI2 -M.BOUABID
Chapitre 2 –Syntaxe de base du langage Java

• Entiers : Ils sont très similaires à ceux du langage C. Les 4 types d’entiers sont :
o byte => entier sur 8 bits {-128..128}
o short => entier sur 16 bits {-32768..32767}
o int => entier sur 32 bits
o long => entier sur 64 bits

• Réels : Il n’y a que deux types de réels en Java :

o float=> représenté sur 32 bits
o double=> représenté sur 64 bits

 Remarque :
En langage Java, toute valeur numérique réelle est définie par défaut en double
précision (type double).
Par conséquent, la lettre d (ou D) placée en fin de valeur n’est pas nécessaire.
Par contre, dès que l’on utilise une variable float, la lettre f (ou F) est indispensable,
sous peine d’erreur de compilation.

Java est un langage très rigoureux sur le typage des données. Il est interdit d’affecter à
une variable la valeur d’une variable d’un type différent si cette seconde variable n’est
pas explicitement transformée. Par exemple :

int a;
double b = 5.0;
a = b;

est interdit et doit être écrit de la manière suivante :

int a ;
double b = 5.0 ;
a = (int)b ;

c) Déclarer une variable

En déclarant une variable, le programmeur donne le type et le nom de la variable.
Syntaxe :
type nomdevariable;
ou
type nomdevariable1, nomdevariable2;

Exemples :
int test;
char choix, temp;

 Remarque :
Les instructions de déclarations peuvent être placées indifféremment au début ou en
cours de programme.

2.1.2 Les Constantes

Une constante est une variable dont la valeur est inchangeable lors de l'exécution d'un
programme. En Java, le mot clé final permet de définir une variable dont la valeur ne
peut pas être modifiée après son initialisation.
p. 11
TI2 -M.BOUABID
 Chapitre 2 –Syntaxe de base du langage Java

Par convention, le nom des constantes est toujours en majuscules afin de les distinguer
sans équivoques des variables. La tentative de modifier une constante dans le
programme entraînera une erreur lors de la compilation

Exemple :
final int CODE = 1234;
final float PI =3.14f ;
final char VOYELLE = 'a';
final char TABULATION = '\t';
final char RETOUR_ALA_LIGNE= '\n';

2.2. Tableaux et matrices

Une variable est déclarée comme un tableau dès lors que des crochets sont présents
soit après son type, soit après son identificateur. Les deux syntaxes suivantes sont
acceptées pour déclarer un tableau d’entiers (même si la première, non autorisée en C,
est plus intuitive) :
int[] mon_tableau;
int mon_tableau2[];

Un tableau a toujours une taille fixe qui doit être précisée avant l’affectation de
valeurs à ses indices, de la manière suivante :
int[] mon_tableau = new int[20];

De plus, la taille de ce tableau est disponible dans une variable length appartenant au
tableau et accessible par mon_tableau.length.

On peut également créer des matrices ou des tableaux à plusieurs dimensions en

multipliant les crochets (ex : int[][] ma_matrice ;). À l’instar du C, on accède aux
éléments d’un tableau en précisant un indice entre crochets (mon_tableau[3] est le
quatrième entier du tableau) et un tableau de taille n stocke ses éléments à des indices
allant de 0 à n-1.

2.3. Chaînes de caractères

Les chaînes de caractères ne sont pas considérées en Java comme un type primitif ou
comme un tableau. On utilise une classe particulière, nommée String, fournie dans le
package java.lang.
• Une chaine de caractère se déclare normalement de la manière suivante :
String s1 = new String(); //pour une chaîne vide
String s2 = new String(”hello world”);
// pour une chaîne de valeur ”hello world”
Comme les strings sont un type de données très utilisé, java permet une
déclaration très simple :
String s2 = ”hello world”;

p. 12
TI2 -M.BOUABID
 Chapitre 2 –Syntaxe de base du langage Java

Java dispose d’une classe standard nommée String, permettant de manipuler des
chaînes de Caractères. La classe String est riche d'attributs et méthodes. En voici
quelques-uns :
• boolean equals(Object anObject) : Comparaison des chaines:
(chaine1.equals(chaine2) rend vrai si chaine1=chaine2, faux sinon)
• String substring(int beginIndex, int endIndex): extraction des sous chaines ()
• int length() : longueur d'une chaine
• etc.

2.4. L’instruction d’affectation

Syntaxe :
Variable = Valeur;
Ou :
Variable = expression mathématique;

Exemples :
n = 4;
p = 5*n+1;

2.5. Opérateurs et expressions

2.5.1. Expression arithmétique
Les opérateurs des expressions arithmétiques sont les suivants :
 + addition
 - soustraction
 * multiplication
 / division. Exemples : 5/2 vaut 2 et 5.0/2 vaut 2.5.
 % reste de la division.

 Priorités dans l'évaluation des expressions arithmétiques

La priorité des opérateurs lors de l'évaluation d'une expression arithmétique est la
suivante (du plus prioritaire au moins prioritaire) :
[ ( )],[ *, /, %], [+, -]
Les opérateurs d'un même bloc [ ] ont même priorité.

2.5.2. Expressions relationnelles

Les opérateurs sont les suivants : <, <=, == (égal),= (différent), >, >=

2.5.3. Expressions booléennes

Les opérateurs sont & (and) ||(or) et ! (not). Le résultat d'une expression
booléenne est un booléen.

2.5.4. Combinaison d'opérateurs

a=a+b peut s'écrire a+=b
a=a-b peut s'écrire a-=b
Il en est de même avec les opérateurs /, %,*
Ainsi a=a+2; peut s'écrire a+=2;

p. 13
TI2 -M.BOUABID
 Chapitre 2 –Syntaxe de base du langage Java

2.5.5. Opérateurs d'incrémentation et de décrémentation

La notation variable++ signifie variable=variable+1 ou encore variable+=1
La notation variable-- signifie variable=variable-1 ou encore variable-=1.

2.5.6. L'opérateur ?
L'expression cond ? expr1:expr2 est évaluée de la façon suivante : si -sinon) :si
cond alors expr1 sinon expr2

2.6. Structures de contrôle

2.6.1. Instruction conditionnelle : if
Elle permet d’exécuter des instructions de manière sélective, en fonction du résultat
d’un test.
Syntaxe :
if (expression) instruction1
if (expression) instruction1 else instruction2

2.6.2. Instruction conditionnelle : switch

Elle permet de choisir un bloc d’instruction selon la valeur d’une expression entière :
Syntaxe :
switch (expression) {
case cste1 :
instruction1; break ;
case cste2 :
instruction2; break ;
...
case csteN :
instructionN ;break ;
default :
instructionDefaut
}

2.6.3. Itérations : while, do...while et for

La structure de contrôle while évalue une condition et exécute l’instruction tant que
cette condition reste vraie.
Syntaxe :
while (condition)
instruction

Exemple :
int i=10;
while (i>=0) {
System.out.println(i);
i=i-1;
}

L’instruction do...while est une variante de la précédente. Une itération est toujours
exécutée.

p. 14
TI2 -M.BOUABID
 Chapitre 2 –Syntaxe de base du langage Java

Syntaxe :
do
instruction
while (condition)

Exemple :
int i=-1;
do {
System.out.println(i);
i=i-1;
} while (i>=0);

Enfin, l’instruction for qui comporte une initialisation, une condition d’arrêt, et une ou
des instructions de fin de boucle :
Syntaxe :
for (instruction1;condition_de_poursuite;instruction2)
instruction ;

Exemple :
for (int i=0;i<50;i++)
System.out.println(i);

2.7. Commentaires
Java reconnait trois types de commentaires :
• les commentaires sur une ligne : tous les caractères suivants //... jusqu’à la
fin de la ligne sont ignorés
Exemple :
int a ; // ce commentaire tient sur une ligne
int b ;

• les commentaires multi-lignes : tous les caractères entre /* ... et...*/ sont
ignorés
Exemple :
/*Ce commentaire nécessite
2 lignes*/
int a ;

• les commentaires de documentation : quand ils sont placés juste avant une
déclaration, les caractères entre /** ...et...*/ sont inclus dans une
documentation générée automatiquement par l’utilitaire javadoc.

p. 15
TI2 -M.BOUABID
Chapitre 3 –Classes et Objets

Chapitre 3
Classes et objets
3.1. Structure d’un programme autonome Java
Un programme écrit en Java consiste en un ensemble de classes représentant les éléments
manipulés dans le programme et les traitements associés. L'exécution du programme
commence par l'exécution d'une classe qui doit implémenter une méthode particulière
“public static void main(String[] args)”. Les classes implémentant cette méthode sont
appelées classes exécutables.
Exemple : Une classe Java Bonjour qui affiche la chaîne de caractères ”Bonjour” s'écrit :

// Fichier Bonjour.java
public class Bonjour {
public static void main(String[ ] args) {
System.out.println("Bonjour !\n");
}
}

Dans ce premier programme très simple, une seule classe est utilisée. Cependant, la
conception d'un programme orienté-objet nécessite, pour des problèmes plus complexes,
de créer plusieurs classes et la classe exécutable ne sert souvent qu’à instancier les
premiers objets.

 L’argument "args" est un tableau de chaines de caractères qui correspond aux

arguments de la ligne de commande lors du lancement du programme. Si la classe
avait été exécutée par la ligne de commande "java HelloWorld 4 toto ", ce tableau
contiendrait 2 éléments dont les valeurs seraient respectivement "4" et "toto".

3.2. Package
Java dispose d'un grand nombre de classes qui implémentent des données et des
traitements génériques utilisables par un grand nombre d’applications. Ces classes
forment l’API (Application Programming Interface) du langage Java et sont organisées en
packages (ou bibliothèques) dédiés à un thème précis.
Parmi les packages les plus utilisés, on peut citer les suivants :

Package Description
java.awt Classes de gestion d’interfaces graphiques
java.io Gestion des entrées/sorties
java.lang contient les classes standards (de base) telles que les
classes String ou Math (importé par défaut)
java.util Classes utilitaires telles que les classes Date,
StringTokenizer (découper une chaine selon des
délimiteurs), etc.
javax.swing Autres classes graphiques

p. 16
TI2 -M.BOUABID
Chapitre 3 –Classes et Objets

Pour accéder à une classe d’un package donné, il faut préalablement importer cette classe
ou son package. Par exemple, la classe Date appartenant au package java.util qui
implémente un ensemble de méthodes de traitement sur une date peut être importée de
deux manières :
• une seule classe du package est importée : import java.util.Date;
• toutes les classes du package sont importées (même les classes non utilisées) :
import java.util.*;

Le programme suivant utilise cette classe pour afficher la date actuelle :

import java.util.Date;
public class DateMain {
public static void main(String[] args) {
Date today = new Date();
System.out.println(”Nous sommes le ” + today.toString());
}

3.3. objets et classes

2.3.1. Généralités
Nous abordons maintenant, par l'exemple, la programmation objet. Un objet est une
entité qui contient des données qui définissent son état (on les appelle des attributs ou
propriétés) et des fonctions (on les appelle des méthodes). Un objet est créé selon un
modèle qu'on appelle une classe :

public Class nom_class{

type1 p1; // propriété p1
type2 p2; // propriété p2
…
type3 m3(…){ // méthode m3
…
}
type4 m4(…){ // méthode m4
…
}

A partir de la classe C1 précédente, on peut créer de nombreux objets O1, O2,… Tous
auront les propriétés p1, p2,… et les méthodes m3, m4, … Ils auront des valeurs
différentes pour leurs propriétés pi ayant ainsi chacun un état qui leur est propre.
Exemple:
Considérons la classe Personne suivante :

import java.io.*;
public class Personne{
// attributs
private String prenom;
private String nom;
private int age;

// méthode
public void initialiser(String P, String N, int age){
this.prenom=P;
p. 17
TI2 -M.BOUABID
Chapitre 3 –Classes et Objets

this.nom=N;
this.age=age;
}
// méthode
public void identifier(){
System.out.println(prenom+","+nom+","+age);
}
}

Nous avons ici la définition d'une classe, le nom de la classe représente un nouveau
type de donnée. On peut donc définir des variables de ce nouveau type; on dit alors
que nous créons des objets ou des instances de classe.
Un objet possède tous les attributs et toutes les de fonctions membres de la classe,
mais avec des valeurs d’attributs qui lui sont propres.

Programmation Procédurale VARIABLE TYPE

Programmation Orientée-Objet OBJET CLASSE

2.3.2. Accès au membre d’une classe

Les membres d'une classe peuvent être des données ou des méthodes (fonctions).
Ces champs peuvent avoir l'un des trois attributs suivants :
• private: les membres privés ne sont accessible que par les fonctions
membres de la classe.
• protected: les membres protégés sont comme les membres privés. Mais ils
sont aussi accessibles par les fonctions membres des classes dérivées
(concept d'héritage).
• Public: les membres publics sont accessibles par tous. La partie publique
est appelée interface.

 L’encapsulation consiste à masquer l’accès à certains attributs et méthodes d’une

classe. Elle est réalisée à l’aide des mots clé: private, protected.
Exemple: La méthode initialiser()
Quel est le rôle de la méthode initialiser ? Parce que nom, prenom et age sont des
données privées de la classe Personne, les instructions suivantes :

Personne p1;
p1.prenom="Ali";
p1.nom="Ben Mohamed";
p1.age=30;

sont illégales. Il nous faut initialiser un objet de type Personne via une méthode
publique. C'est le rôle de la méthode initialiser(). On écrira donc :

Personne p1;
p1.initialiser("Ali","Ben Mohamed",30);

L'écriture p1.initialiser() est légale car initialiser() est d'accès public.

p. 18
TI2 -M.BOUABID
Chapitre 3 –Classes et Objets

2.3.3. L'opérateur new

La séquence d'instructions :
Personne p1;
p1.initialiser("Ali","Ben Mohamed",30);

est incorrecte. L'instruction

Personne p1;

déclare p1 comme une référence à un objet de type Personne. Cet objet n'existe pas
encore et donc p1 n'est pas initialisé. C'est comme si on écrivait :

Personne p1=null;

où on indique explicitement avec le mot clé null que la variable p1 ne référence

encore aucun objet.

Lorsqu'on écrit ensuite :

p1.initialiser("Ali","Ben Mohamed",30);

on fait appel à la méthode initialiser de l'objet référencé par p1. Or cet objet n'existe
pas encore et le compilateur signalera l'erreur. Pour que p1 référence un objet, il faut
écrire :

Personne p1=new Personne();

Cela a pour effet de créer un objet de type personne non encore initialisé : les attributs
nom et prenom qui sont des références d'objets de type String auront la valeur null, et
age la valeur 0. Il y a donc une initialisation par défaut. Maintenant que p1 référence
un objet, l'instruction d'initialisation de cet objet

p1.initialiser("Ali","Ben Mohamed",30);

est valide.

2.3.4. Le mot clé this

Regardons le code de la méthode initialiser :
public void initialiser(String P, String N, int age){
this.prenom=P;
this.nom=N;
this.age=age;
}

L'instruction this.prenom=P signifie que l'attribut prenom de l'objet courant (this)

reçoit la valeur P. Le mot clé this désigne l'objet courant : celui dans lequel se trouve
la méthode exécutée.

p1.initialiser("Ali","Ben Mohamed",30);

La méthode initialiser aurait aussi pu être écrite comme suit :

public void initialiser(String P, String N, int age){

p. 19
TI2 -M.BOUABID
Chapitre 3 –Classes et Objets

prenom=P;
nom=N;
this.age=age;
}
Lorsqu'une méthode d'un objet référence un attribut A de cet objet, l'écriture this.A est
implicite. On doit l'utiliser explicitement lorsqu'il y a conflit d'identificateurs. C'est le
cas de l'instruction :

this.age=age;

où age désigne un attribut de l'objet courant ainsi que le paramètre age reçu par la
méthode. Il faut alors lever l'ambiguïté en désignant l'attribut age par this.age.

2.3.5. Un programme de test

Voici un programme de test :

public class TestPersonne{

public static void main(String arg[]){
Personne p1=new Personne();
p1.initialiser("Ali","Ben Mohamed",30);
p1.identifier();
}
}

2.3.6. Les constructeurs de classe

Le constructeur est une méthode portant le même nom de la classe, qui peut accepter
des arguments mais ne rend aucun résultat (même pas void) et qui est appelée lors de
la création de l'objet. On s'en sert généralement pour l'initialiser

Créons un premier constructeur à notre classe Personne :

import java.io.*;
public class Personne{
// attributs
……
// Constructeurs
Public personne () {
Nom="nnondef"; // nnondef : nom non encore défini
Prenom="pnondef"; // pnondef : prenom non encore défini
age =0;
}

// méthode
……
}
Voici un programme de test :

import java.io.*;
public class TestPersonne{
public static void main(String arg[ ]){
p. 20
TI2 -M.BOUABID
Chapitre 3 –Classes et Objets

Personne p1=new Personne();

p1.identifier();

Ce programme affiche : nnondef, pnondef, 0. On remarque donc que les instructions

définies dans le constructeur ont été exécuté lors de la déclaration de l'objet p1 qui est
de type Personne.

 Si une classe C n'a aucun constructeur, elle en a un par défaut qui est le
constructeur sans paramètres : public C(). Les attributs de l'objet sont alors
initialisés avec des valeurs par défaut.
 Une classe peut avoir un ou plusieurs constructeurs.

Exemple : Ajoutons un autre constructeur à la classe Personne :

import java.io.*;
public class Personne{
// attributs
……
// Constructeurs
Public personne () {
Nom="nnondef"; // nnondef : nom non encore défini
Prenom="pnondef"; // pnondef : prenom non encore défini
age =0;
}

Public personne (String nom, String prenom, int age) {

this.nom=nom;
this.Prenom=prenom;
this.age=age;

// méthode
……
}

Le programme de test suivant :

import java.io.*;
public class TestPersonne{
public static void main(String arg[]){
Personne p1=new Personne('ben mohamed','ali',20);
p1.identifier();

affiche ce qui suit : Ben mohamed, ali, 20

 Le constructeur qu'on venait de définir, peut se contenter de faire appel à la

méthode initialiser défini précédemment.

2.3.7. Les méthodes de lecture et d'écriture des attributs privés

p. 21
TI2 -M.BOUABID
Chapitre 3 –Classes et Objets

Nous rajoutons à la classe Personne les méthodes nécessaires pour lire ou modifier
l'état des attributs des objets :

public class Personne{

private String prenom;
private String nom;
private int age;
public personne(String P, String N, int age){
this.prenom=P;
this.nom=N;
this.age=age;
}
public void identifier(){
System.out.println(prenom+","+nom+","+age);
}
// accesseurs
public String getPrenom(){
return prenom;
}
public String getNom(){
return nom;
}
public int getAge(){
return age;
}
//modifieurs
public void setPrenom(String P){
this.prenom=P;
}
public void setNom(String N){
this.nom=N;
}
public void setAge(int age){
this.age=age;
}
}

Testons donc la nouvelle classe avec le programme suivant :

public class TestPersonne{

public static void main(String[] arg){
Personne P=new Personne("Ali","Ben Mohamed",34);
System.out.println("P=("+P.getPrenom()+","+P.getNom()+","+P.getAge()+")");
P.setAge(56);
System.out.println("P=("+P.getPrenom()+","+P.getNom()+","+P.getAge()+")");
}
}

p. 22
TI2 -M.BOUABID
Chapitre 3 –Classes et Objets

Nous obtenons les résultats suivants :

P=(Ali,Ben Mohamed,34)
P=(Ali,Ben Mohamed,56)

2.3.8. Les méthodes et attributs de classe

Supposons qu'on veuille compter le nombre d'objets personne créées dans une
application. On peut soi-même gérer un compteur mais on risque d'oublier les objets
temporaires qui sont créés ici ou là. Il semblerait plus sûr d'inclure dans les
constructeurs de la classe Personne, une instruction incrémentant un compteur.

La variable compteur (nbPersonne) est une variable partagée par toutes les instances
d’une classe. C'est une variable de classe. Comme c'est un attribut de la classe elle-
même et non d'un objet particulier de cette classe, on le déclare différemment avec le
mot clé static :

private static long nbPersonnes; // nombre de personnes créées

Pour rendre la valeur de nbPersonnes, la méthode n'a pas besoin d'un objet particulier :
en effet nbPersonnes n'est pas l'attribut d'un objet particulier, il est l'attribut de toute
une classe. On a besoin d'une méthode de classe déclarée elle aussi static :
public static long getNbPersonnes(){ return nbPersonnes; }

qui de l'extérieur sera appelée avec la syntaxe Personne.getNbPersonnes().

La classe Personne devient la suivante :

public class personne{

// attribut de classe
private static long nbPersonnes=0;
// attributs d'objets
…
// constructeurs
public personne(String P, String N, int age){
this.nom=nom;
this.Prenom=prenom;
this.age=age;
nbPersonnes++;
}
// méthode
…
// méthode de classe
public static long getNbPersonnes(){
return nbPersonnes;
}
}

Avec le programme suivant :

public class Test1{
public static void main(String arg[ ]){
personne p1=new personne("Ali","Ben Mohamed",30);

p. 23
TI2 -M.BOUABID
Chapitre 3 –Classes et Objets

personne p2=new personne(p1);

new personne(p1);
System.out.println("Nombre de personnes créées:"+personne.getNbPersonnes());
}
}

On obtient les résultats suivants : Nombre de personnes créées : 3

p. 24
TI2 -M.BOUABID
Chapitre 4 -Héritage

Chapitre 4
Héritage

Comme nous l’avons déjà signalé au chapitre 1, le concept d’héritage constitue l’un des
fondements de la programmation orientée objet. Il est notamment à l’origine des
possibilités de réutilisation des composants logiciels que sont les classes. En effet, il
permet de définir une nouvelle classe, dite classe dérivée, à partir d’une classe existante
dite classe de base. Cette nouvelle classe hérite des fonctionnalités de la classe de base
(champs et méthodes) qu’elle pourra modifier ou compléter à volonté, sans qu’il soit
nécessaire de remettre en question la classe de base.

5.1. La notion d'héritage

Nous allons voir comment mettre en œuvre l’héritage en Java, à partir d’un exemple
simple de classe. Supposez que nous disposions de la classe Personne décrite dans le
chapitre précédent :
public class Personne{
private String nom;
private String prenom;
private int age;

Supposons qu'on veuille créer une classe enseignant : un enseignant est une personne
particulière. Il a des attributs qu'une autre personne n'aura pas : la spécialité qu'il
enseigne par exemple (génie électrique, génie informatique,etc.). Mais il a aussi les
attributs de toute personne : prénom, nom et âge. Un enseignant fait donc pleinement
partie de la classe personne mais il a des attributs supplémentaires. Plutôt que d'écrire
une classe enseignant en partant de rien, on préfèrerait reprendre l'acquis de la classe
personne qu'on adapterait au caractère particulier des enseignants. C'est le concept
d'héritage qui nous permet cela.

Pour exprimer que la classe enseignant hérite des propriétés de la classe personne, on
écrira :
public class Enseignant extends Personne

Personne est appelée la classe de base (ou mère) et enseignant la classe dérivée (ou
fille). Un objet enseignant à toutes les qualités d'un objet personne : il a les mêmes
attributs et les mêmes méthodes. Ces attributs et méthodes de la classe parent ne sont
pas répétées dans la définition de la classe fille : on se contente d'indiquer les
attributs et méthodes rajoutés par la classe fille :

class enseignant extends personne{

// attributs
private int specialite;
}

p. 25
TI2 -M.BOUABID
Chapitre 4 -Héritage

Ici la classe enseignant rajoute aux méthodes et attributs de la classe personne :

• un attribut specialite qui décrit la spécialité enseignée par l'enseignant.

5.2. Accès d’une classe dérivée aux membres de sa classe de base

• Une classe dérivée n’accède pas aux membres privés de sa classe de base
• Elle accède aux membres publics et protégés de sa classe de base

5.3. Construction et initialisation des objets dérivés

Rappelons que le constructeur de la classe personne était :
// constructeur
public Personne (String P, String N, int age){
this.prenom=P;
this.nom=N
this.age=age
}
On sait que ce constructeur initialise les champs prenom, nom et age.
Le constructeur de la classe enseignant, qui initialise les champs nom, prenom,age et
specialite est le suivant :

// constructeur
public enseignant(String P, String N, int age,int specialite){
this.prenom=P;
this.nom=N
this.age=age
this.specialite=specialite;
}

C'est impossible. La classe personne a déclaré privés (private) ses trois champs
prenom, nom et age. Seuls des objets de la même classe ont un accès direct à ces
champs. Tous les autres objets, y compris des objets dérivés comme ici, doivent
passer par des méthodes publiques pour y avoir accès. Cela aurait été différent si la
classe personne avait déclaré protégés (protected) les trois champs : elle autorisait
alors des classes dérivées à avoir un accès direct aux trois champs.
Dans notre exemple, il faut utiliser le constructeur de la classe parent. C'est la
méthode habituelle : lors de la construction d'un objet fils, on appelle d'abord le
constructeur de l'objet parent puis on complète les initialisations propres cette fois à
l'objet fils (specialite dans notre exemple).

L'appel au constructeur de la classe parent, se fait en utilisant l'instruction super :

// constructeur
public enseignant(String P, String N, int age,int specialite){
super(P,N,age);
this.specialite=specialite;
}

p. 26
TI2 -M.BOUABID
Chapitre 4 -Héritage

Exemple d'un programme de test

public class test1{
public static void main(String arg[]){
System.out.println(new Enseignant("ali","med",25,501).identifier());
}

Ce programme ce contente de créer un objet enseignant et de l'identifier. La classe

enseignant n'a pas de méthode identifier() mais sa classe parent en a une qui de plus
est publique : elle devient par héritage une méthode publique de la classe enseignant.

5.4. La notion de redéfinition et surdéfinition de méthodes

5.4.1 Redéfinition
Nous avons vu qu’un objet d’une classe dérivée peut accéder à toutes les
méthodes publiques de sa classe de base. Considérons :
class Personne
{ .....
public void affiche()
{
System.out.println ("Je suis " +prenom+","+nom+","+age) ;
}

class Enseignant extends Personne

{ ..... // ici, on suppose qu’aucune methode ne se nomme affiche
private int specialite ;
}
Personne p ; Enseignant e;

L’appel p.affiche() fournit tout naturellement les informations relative à

l’objet p de type Personne.
L’appel e.affiche() fournit également les informations de l’objet e de type
Enseignant, mais bien entendu, il n’a aucune raison d’en fournir le code de la
specialite.

Pour faire cela, nous allons définir dans la classe dérivée une fonction portant
le même nom, et qui aura pour rôle d'afficher les données privées de la classe
dérivée. On parle alors de redéfinition d'une fonction de la classe de base.
class Enseignant extends Personne
{ ..... // ici, on suppose qu’aucune methode ne se nomme affiche
private int specialite ;
public void affiche ()
{ super.affiche() ;
System.out.println (" mon code specialite : " + specialite) ;
}
}

p. 27
TI2 -M.BOUABID
Chapitre 4 -Héritage

 Même si cela est fréquent, une redéfinition de méthode n’entraîne pas

nécessairement comme ici l’appel par super de la méthode correspondante
de la classe de base.
 Une méthode de classe (static) ne peut pas être redéfinie dans une classe
dérivée. Cette restriction va de soi puisque c’est le type de l’objet appelant
une méthode qui permet de choisir entre la méthode de la classe de base et
celle de la classe dérivée. Comme une méthode de classe peut être appelée
sans être associée à un objet, on comprend qu’un tel choix ne soit plus
possible.

5.4.2 Surdéfinition
Surdéfinir une méthode consiste à lui donner plusieurs significations. Nous
choisirons la bonne signification en fonction du contexte dans lequel cette
méthode sera utilisée.
Exemple :
class A
{ public void f (int n) { ..... }
.....
}
class B extends A
{ public void f (float x) { ..... }
.....
}
Aa;Bb;
int n ; float x ;
.....
a.f(n) ; // appelle f (int) de A
a.f(x) ; // erreur de compilation
b.f(n) ; // appelle f (int) de A
b.f(x) ; // appelle f(float) de B

 Ne pas confondre la redéfinition avec la surcharge :

• Redéfinition : même type de retour et mêmes paramètres.
• Surcharge : type de retour et paramètres différents, les paramètres au
moins doivent être différents.

p. 28
TI2 -M.BOUABID
Chapitre 5 -Le polymorphisme

Chapitre 5
Le polymorphisme

6.1. Concept de polymorphisme

Le polymorphisme est un concept extrêmement puissant en POO. Il permet de
manipuler des objets sans en connaître tout à fait le type tout en se basant sur la
relation d’héritage.
Le polymorphisme se base sur cette affirmation : un objet a comme type non
seulement sa classe mais aussi n’importe quelle classe dérivée.

6.2.Exemple et interprétations
//classe de base
Class graphique {
Private int x,y ;
Public graphique (int x ,int y) {this.x=x ;This y=y ;}
Public void identifier () {
System.out.prntln(« Je suis une forme géométrique ») ;}
Public void affiche () {
This.identifier() ;
System.out.println(« Le centre de l’objet se trouve dans : »+x
+ « et » +y) ;}
Double surface () {return (0) ;}
}//fin de la classe graphique
//classe dérivée 1
Class Cercle extends graphique {
Private double rayon=1 ;
Public Cercle (int x,int y, double r) {
super (x,y) ;
Rayon=r ;}
Public void identifier () {
System.out.prntln(« Je suis un cercle ») ;}
Double surface()
{return (rayon*2*3.14) ;}
}
// Classe dérivée2
Class rectangle extends graphique {
Private int larg, longueur ;
Rectangle (int x, int y, int l1, int l2)
{super (x,y) ;
Longueur =l1 ; larg=l2 ;
}
Double surface () {return (longueur * largeur) ;}

p. 29
TI2 -M.BOUABID
Chapitre 5 -Le polymorphisme

Public void identfie () {

System.out.println(« Je suis un Rectangle ») ;}
}// fin de la classe Rectangle
//Classe de test
Class test_poly {
Public static void main (Sring [ ] args) {
Graphique g= new graphique (3,7) ;
g.identifier() ;
g= new Cercle (4,8,10)
// compatibilité entre le type de la classe et de la classe dérivée
g.identifier() ;
g= new Redtangle (7,9,10,3) ;
//compatibilité entre le type de la classe et de la classe dérivée
g.identifier() ;
}
}

Résultat de l’exécution :
Je suis une forme géométrique
Je suis un cercle
Je suis un rectangle
Interprétation :
• Le même identificateur « g » est initialisé :
o Dans la 1ére instruction avec une référence de type « graphique »
o Dans l’instruction 2, avec une référence de type « Cercle »
o Et dans 3éme instruction, on a changé sa référence avec une référence
de type « Rectangle »
• Ces affectations confirment la compatibilité entre un type d’une classe de base
et la référence d’une classe dérivée.
• Le résultat de méthode « identifier » a changé dans chaque appel selon le type
effectif de la variable « g ».

6.3. Les conversions explicites de références

Il ya une comptabilité entre une référence à un objet d’un type donné et une référence
à un objet d’un type ascendant.
Dans le sens inverse, la compatibilité n’est pas implicite.
Exemple :

Class graphique {……}

Class Cercle {……..}
……..
Graphique g,g1 ;
Cercle c ;c1 ;
C=new graphique (…….) :
G=new cercle (….)
G1= new graphique (…….) ;
p. 30
TI2 -M.BOUABID
Chapitre 5 -Le polymorphisme

C1= new cercle(…..) ;

C1=g1 ;
G1=c1 ,

p. 31
TI2 -M.BOUABID
Chapitre 6 – Les classes abstraites et les interfaces

Chapitre 6
Les classes abstraites et les interfaces

7.1. Les classes abstraites

7.1.1. Concept des abstraites
Une classe abstraite est une classe qui ne permet pas d’instancier des objets, elle
ne peut servir que de classe de base pour une dérivation.
Dans une classe abstraite, on peut trouver classiquement des méthodes et des
champs dont héritera toute classe dérivée et on peut trouver des méthodes dites
« abstraites » qui fournissent uniquement la signature et le type de retour.
a) Syntaxe
Abstract class A {
public void f() {……} // f est définie dans A
public abstract void g (int n) ; //g est une méthode abstraite
//elle n’est pas définie dans A
}

b) Utilisation
Aa;
// on peut déclarer une référence sur un objet de type A ou dérivé
A = new A (….) :
// Erreur pas d’instanciation d’objets d’une classe abstraite

Si on dérive une classe B de a qui définit les méthodes abstraites de A, alors

on peut : a= new B(….) ; // juste car B n’est pas une classe abstraite

c) Remarques
• Dès qu’une classe abstraite comporte une ou plusieurs méthodes
abstraites, elle est abstraite, et ce même si l’on n’indique pas le mot
clé « abstract » devant sa déclaration.
• Une méthode abstraite doit être obligatoirement déclarée « public »,
ce qui est logique puisque sa vacation est d’être redéfinie dans une
classe dérivée.
• Les noms d’arguments muets doivent figurer dans la définition
d’une méthode abstraite public abstract void g(int) ;// Erreur : nom
argument fictif est obligatoire.
• Une classe dérivée d’une classe abstraie n’est pas obligé de
redéfinir toutes les méthodes abstraites, elle peut ne redéfinir
aucune, mais elle reste abstraite tant qu’il y a encore des méthodes
abstraites non implémentées.
• Une classe dérivée d’une classe non abstraite peut être déclarée
abstraite.

p. 32
TI2 -M.BOUABID
Chapitre 6 – Les classes abstraites et les interfaces

d) Exemple
Abstract class graphique {
Private int x,y ;
Graphique (int x, int y) {this.x=x ; this.y=y ;}
Void affiche () {
System.out.println (« le centre de l’objet se trouve dans : »+x+
« et » +y) ;}
Abstract public double surface () ; // méthode abstraite
} // fin de la classe graphique.
// Classe dérivée1
Class Cercle extends graphique {
Private double rayon=1 ;
Void affiche () {
System.out.println (« C’est un cercle de rayon » + rauon) ;
Super.affiche() ; }
Double surface () {return (rayon *2*3.14) ; }}

// Classe dérivée 2
Class rectangle extends graphique {
Private int largeur, longueur ;
Rectangle (int x, int y, int l1, int l2){
Super (x,y) ;
longueur= l1 ; largeur=l2 ;}
Double surface () { return (longeur*largeur) ;}
} // fin de la classe Rectagle
// classe de test
Class test_poly2 {
Public static void main (String [ ]args) {
Graphique [ ] tab = new graphique [6] ;
//tab [0] = new graphique (3,2) ; erreur car une classe abstraite ne
//peut pas être instanciée
Tab[0]=new Cercle (3,2,7) ;
Tab[1]= new Cercle (10,7,3) ;
Tab[2]= new Rectangle (4,7,8,6) ;
Tab[3]= new Rectangle (8,10,12,10) ;
Tab[4]= new Cercle (8,5,3) ;
Tab[5]=new Rectangle (10,17,3,8) ;
For (int i=0 ; i <=5 ; i++) { tab[i].affiche() ;}
}
}

Une classe abstraite peut ne comporter que des méthodes abstraites et

aucun champ. Dans ce cas, elle est appelée une interface.

p. 33
TI2 -M.BOUABID
Chapitre 6 – Les classes abstraites et les interfaces

7.2. Les interfaces

7.2.1. Concept d’interface
Une interface est une classe abstraite n’implantant aucune méthode et aucun
champ (sauf les constantes).

a) Définitions d’une interface

Public interface I{
void f(int n) ; // public abstract facultatifs
void g () ; // public abstract facultatifs
}

Toutes les méthodes d’une interface sont abstraites. On peut ne pas

mentionner le modificateur de visibilité (par défaut public) et le mot clé
« abstract »

b) Implémentation d’une interface

Lorsqu’on définit une classe, on peut préciser qu’elle impémente une
interface donnée en utilisant le mot clé « impléments »
Public interface I1
{……}
Public interface I2
{……}
Class A Implements I1, I2
{…. A doit définir les méthodes de I1 et I2}

c) Exemple
interface Affichable {
void affiche() ;
}
class entier implements Affichable{
private int val ;
public Entier (int n){val=n ;}
Public void affiche () ;{
System.outprintln (« Je suis un entier de valeur » + val) ;}
}
class Flottant implements Affichable {
private int val ;
public flottant (float n) {val=n ;}
public void affiche () {
system.out.println (« Je suis un flottant de valeur » +val ;}
}
Public class testInterface {
Public static void main (string [ ] args) {

p. 34
TI2 -M.BOUABID
Chapitre 6 – Les classes abstraites et les interfaces

Affichable [ ] tab=new Affichable [2] ;

tab[0]=new Entier (25) ;
tab[1]=new flottant (1.25) ;
tab[0].affiche() ; tab [1].affiche ;
}
}

Résultat de l’exécution :
Je suis un entier de valeur 25
Je suis un flottant de valeur 1.25

d) Interface et constantes
Une interface peut renfermer aussi des constantes symboliques qui seront
accessibles à toutes les classes implémentant l’interface :
public interface I{
void f (int n) ;//public abstract facultatifs
void g () ; //public facultatifs
static final int max=100 ;
}

Les constantes déclarées sont toujours considérées comme « static » et

« final »

e) Remarques
• Une classe peut implémenter plusieurs interfaces (alors qu’une
classe ne pouvait dériver que d’une seule classe abstraite).
• Les interfaces peuvent se dériver.

Exemple1

Interface I1 {……..}
Interface I2 {……..}
Class A impléments I1 {……..}
Class B extends A implements I1, I2{………}

Exemple 2

Interface I1{
void f(int n) ;
static final int max=100 ;
}
Interface I2 e extends I1{
g (int n) ;
static final int min=10 ;
}
En fait la définition de I2 est équivalente à interface I2
{
p. 35
TI2 -M.BOUABID
Chapitre 6 – Les classes abstraites et les interfaces

void g(int n) ;
static final int min=10 ;
void f(int n) ;
static final max=100 ;
}

Exemple 3

Interface I1{
void g() ; //g est une méthodes abstraite de I1
}
Interface I2{
int g() ; // g est aussi une méthode abstraite de I2
}
Class A implements I1, I2{
/*Erreur car void g() et int g () ne peuvent pas coexister au sein de la même
classe*/

p. 36
TI2 -M.BOUABID
Chapitre 6 – Les classes abstraites et les interfaces

Chapitre7
Les exceptions
Introduction
Imaginons que nous ayons oublié une accolade fermante dans notre code Java. Il se
produirait une erreur de compilation, qu’on pourrait facilement corriger.
Mais il se produit aussi ce qu’on appelle des erreurs d’exécution (run-time errors),
lorsque notre programme cesse tout à coup de fonctionner correctement. Par exemple :
• Lecteur d’un fichier qui est introuvable
• Division par zéro
• Débordement du tableau

Que se passe-t-il si une fonction fait la division d’un entier par zéro ? Le programme
s’écroule-t-il en affichant un message d’erreur déroulant, ou reste-t-il en vie en affichant
un message compréhensible comme ; «’’Impossible de faire la division par zéro.’’?
En Java, les erreurs d’exécution sont appelées des exceptions et le traitement des erreurs
est appelé gestion des exceptions

8.1. Traitement des exceptions

Les exceptions sont traitées via des blocs try/catch qui veulent littéralement dire
essayer/attraper-capturer. On exécute les instructions susceptibles de lever une
exception dans le bloc try et en cas d’erreur ce sont les instructions du bloc catch qui
seront exécutions, pourvu qu’on attrape bien l’exception levée.
Syntaxe :
Try {
// Instructions susceptibles de provoquer des erreurs ;
}
Catch ( Type Exception 1 e) {
//Instructions de traitement de l’erreur ; en cas d’une exception de type Exception1
}
Catch (TypeException2e) {
// Instructions de traitement de l’erreur ; en cas d’une exception de Type Exception2
}

Catch (Exception e) {
// que faire dans les autres cas
}
Finally {
//toujours passer ici, quoiqu’il arrive !
}

p. 37
TI2 -M.BOUABID
Chapitre 7 –Les exceptions

Exemple
public class TestException {
public static void main (java.lang.String args) {
int i=3 ;
int j=0 ;
try {
System.out.println( ″résultat= ″ +(i/j)) ;
}
catch (Arithmetic Exception e) {
System.out.println(″ erreur division par zéro″) ;
}
}
}

8.2. Les exceptions prédéfinies

Comme Java est un langage orienté objet, une exception est manipulée comme un
objet. Les classes d’exceptions java se divisent en plusieurs catégories et héritent
toutes de la classe Throwable. (java.lang.throwable). Cette classe dispose d’un
ensemble de méthodes tel que les méthodes:
• Getmessage() : renvoie la chaîne de caractères passé au constructeur de
l’exception, en principe le texte du message d’erreur.
• ToString() : renvoie une chaîne de caractères contenant le nom de la classe et
le résultat de getMessage(). Exemple : « IOException : fichier non ouvert en
écriture »
• PrintStackTrace () : imprime sur la console l’ensemble des appels parcourus
par l’exception

Quelques exceptions prédéfinies

Voici quelques exceptions prédéfinies dans Java :
• IOException : levée lorsqu'une erreur d'entrée/sortie se produit
• FileNotFoundException : levée lors d'une tentative d'accès à un fichier ou un
répertoire qui n'existe pas sur le disque.
• ArithmeticException : levée en cas d'erreurs au cours d'une opération
arithmétique (division par exemple)
• NumberFormatException : erreur lors de la conversion d’une chaine de
caractères en nombre
• ArrayIndexOutOfBoundsException : erreur lors de l’accès à une case
inexistante dans un tableau où au i éme caractère d’une chaîne de caractères
de taille inférieure à i.

8.3. Les exceptions personnalisées

Pour créer son propre type d’exception, il faut écrire une classe héritant de la classe
Exception. Allons-y donc, créons une exception qu’on appellera
AgeNonValideException qu’on lèvera si l’utilisateur de notre programme entre un
age < 0. Voici à quoi ressemble notre classe AgeNonValideException.
p. 38
TI2 -M.BOUABID
Chapitre 7 –Les exceptions

Public class AgeNonValideException extends Exception {

//Constructeur
AgeNonValideException () {
Super (″L’age de peut être négatif″) ; // Appelle simplement le
//constructeur de la superclasse
// et lui passe le message d’erreur à afficher
}
}

Le constructeur d’initialisation d’une personne doit ressembler à ce qui suit.

Public personne ‘String Nom, String prenom, int age) throws AgeNonValideException
{
if(age<0)
throw new AgeNonValideException () ;
else
{

this.nom=nom ;
this.prenom=prenon ;
this.age=age ;
}
}

public class test_exception {

public static void main (String arg [0]) {
personne p=null ;
try {
p= new Personne ( ″Ahmed″, ″ ben Mohamed″, -10) ;
}
catch (AgeNomValideException e){
system.out.println (e.getMessage()) ;
p=new personne() ;
}
}
}

 La présence de clause throws dans la signature de la méthode est obligatoire pour toute
méthode qui peut lever une exception.
 Pour lever une exception il faut utiliser du mot clé throw suivi du type de l’exception
qu’on instancie.

p. 39
TI2 -M.BOUABID