Prsentation de JAVA

1
Présentation de JAVA

• Mise en uvre des concepts de la programmation
  orientée objets

2

• Identificateurs de variables

Nimporte quel identificateur, notamment celui
dune variable, est de longueur quel- conque et
débute par une lettre, _ ou . Les autres
caractères sont quelconques à lexception des
opérateurs de Java (, -, , /, etc.) qui ne
peuvent être choisis. Lespace nest pas un
caractère admissible.
Java fait la distinction entre une lettre
minuscule et une majuscule.
Types de données de base et variables
Il existe 8 types de données de base en JAVA et
les variables dun type de base sont les seuls
éléments de JAVA qui ne sont pas des objets.
Les noms qui désignent les types de données de
base sont des mots-clés en JAVA. Ils ne peuvent
donc être utilisés à dautres fins.
Lensemble des valeurs prises par une variable
dun type de donnée de base est toujours le même,
peu importe lenvironnement de programmation dans
lequel vous travaillez.
La déclaration dune variable peut se retrouver
nimporte où dans votre programme en autant que
la déclaration précède toujours son utilisation.
3

• Types de données entiers

Ces variables peuvent prendre des valeurs
positives ou négatives et diffèrent seulement par
lensemble des valeurs que peut prendre une
variable de ce type.
byte -128 à 127 1 octet short -32768 à
32767 2 octets int -2147483648 à
2147483647 4 octets long -9223372036854775808
à 9223372036854775807 8 octets
Les littéraux entiers sont de type int par
défaut. Autrement, si vous voulez définir un
entier de type long, vous ajoutez L à la fin du
littéral.
Ex. -123L
Par contre, vous ne pouvez pas spécifier
explicitement un littoral de type byte ou short.
Ex.  long i 999999999L // L permet de définir
une constante de type long. int j // la
variable j est initialisée à 0 par défaut. short
k 1, m 2
4

• Types de données réels

Ces variables peuvent prendre des valeurs réelles
positives ou négatives avec comme précision un
nombre fixe de chiffres.
float -3.4E38 à 3.4E38 4 octets une précision
de 7 chiffres environ, double -1.7E308 à
1.7E308 8 octets une précision de 15 chiffres
environ.
Note 17 000 000 et 17 000 001 sont identiques
avec la représentation de type float.
Ex. double Distance_soleil 1.496E8 float
Masse_electron 9E-28F float poids
176.4f, grandeur 5.75F
Les littéraux réels sont de type double par
défaut. Autrement, si vous voulez définir un réel
de type float, vous ajoutez f ou F à la fin du
littéral.
Ex. -345.78 // Valeur de type
double. 3.14159f // Valeur de type float.
5

• Types de données caractères

Chaque variable de type char permet de stocker un
seul caractère à la fois en occupant 2 octets en
mémoire.
Ex. char C 'x'
char D '\u0058' // D renferme aussi le
caractère x dont le code // hexadécimal est
0058 en mode ASCII.
Types de données booléens
Les variables de type boolean peuvent prendre la
valeur true ou false.
Ex. boolean etat true
Opérateurs daffectation , , -, , / et
Permet dinitialiser une variable à la valeur
dune expression.
Ex. int x 5, y y x x 3 // On ajoute
3 à x et le résultat est affecté à y. x y
6 // Cela équivaut à x x y 6
6
Note

• Les types primitifs existent comme classe avec
  des méthodes associées.

Ex.
public class TypePrimitifCommeClasse public
static void main(String args) Integer varI
new Integer(5) int varJ 2 System.out.pr
intln("varI " varI) System.out.println("var
J " varJ) varI 1 varJ
1 System.out.println("varI "
varI) System.out.println("varJ "
varJ) varJ varI varI
varJ System.out.println("varI "
varI) System.out.println("varJ "
varJ)
types innées
classes correspondantes
int Integer long Long float Float double Double b
oolean Boolean byte Byte char Character void Void
7

• Expressions arithmétiques

Opérations sur les entiers
Les opérateurs de base sont , -, , / et où
/ et désignent respectivement la partie entière
et le reste de la division effectuée.
Ex. 11 / 3 nous donne 3 comme résultat. 11
3 nous donne 2 comme résultat.
Les opérateurs dincrémentation et de
décrémentation et -- sont aussi disponibles.
Ex. int compteur 20, x x compteur //
Ajoute 1 à compteur et x prend la valeur 21. x
compteur // Ajoute 1 à compteur et x prend la
valeur 20 // car la valeur de compteur est
utilisée dans // lexpression avant de
lincrémenter.
Les opérateurs et -- peuvent être utilisés
dans une expression contrairement à lopération
daffectation compteur compteur 1
8
Opérations sur les entiers plus courts
Dans une expression où lon retrouve des
variables de type short ou byte, le calcul est
effectué en mode 32 bits et le résultat est un
nombre sur 32 bits.
Ex. short compteur 20, x 10 x (short)
(compteur x) // x prend la valeur 30.
Une conversion explicite est donc nécessaire. Les
16 bits les moins significatifs sont retenus.
Dans une expression où lon retrouve des
variables de type long, une conversion implicite
de type long est effectuée pour les autres
valeurs puis, le calcul est effectué en mode 64
bits et le résultat est un nombre sur 64 bits.
Ex. long compteur 20L int x 10 compteur
compteur x Ex. long compteur 20L int x
10 x (int) (compteur x)
Une conversion explicite est donc nécessaire.
9
Opérations logiques sur les chaînes de bits
et logique ou exclusif ou
logique négation (complément à 1)
Ex. int a 0x66CD int b 0x000F System.out
.println(a b)
Impression de a b.
Ces opérateurs sappliquent à des valeurs de type
int seulement autrement, il y a conversion
implicite.
Ex. short a 0x66CD short b 0x000F short
c (short) (a b) System.out.println(c)
Une conversion explicite est nécessaire.
10
Opérations de décalage sur les chaînes de bits
ltlt décalage vers la gauche en insérant des zéros
à la droite, gtgt décalage vers la droite en
propageant le bit de signe à la gauche,
gtgtgt décalage vers la droite en insérant des
zéros à la gauche.
3 bits perdus
3 bits perdus
3 zéros insérés
3 zéros insérés
3 bits perdus
Le signe est propagé.
11
Opérations sur les réels
Les opérateurs de base sont  , -, et
/. Lopérateur est aussi disponible x y
correspond au reste de la division de x par y un
nombre entier de fois.
Ex. 12.6 5.1 nous donne comme résultat 2.4.
Les opérateurs et -- peuvent aussi être
utilisés avec des valeurs réelles en mode préfixe
ou suffixe. Les effets sont les mêmes quavec les
entiers.
Conditions aux limites pour des valeurs réelles
seulement
Un réel positif (négatif) divisé par zéro nous
donne Infinity (-Infinity).
Un réel non nul divisé par ?Infinity nous donne
0. Zéro divisé par zéro nous donne NaN ce qui
signifie Not-a-Number.
Ex. float a -5.0f float b
0.0f System.out.println(-5 (a / b))
Ex. float a 0.0f float b
0.0f System.out.println(-5 (a / b))
Infinity est affiché.
NaN est affiché.
12
Conversions implicites ou explicites
Lors de lévaluation dexpressions arithmétiques
renfermant différents types, la 1ière règle qui
sapplique est celle qui est utilisée.
Si lune des opérandes est de type double,
lautre est converti en type double avant
deffectuer le calcul.
1.
Si lune des opérandes est de type float, lautre
est converti en type float avant deffectuer le
calcul.
2.
Si lune des opérandes est de type long, lautre
est converti en type long avant deffectuer le
calcul.
3.
Si aucune des opérandes est de type double, float
ou long, elles sont de type int, short ou byte et
larithmétique sur 32 bits sapplique.
4.
Lors dune affectation, si la valeur de
lexpression à droite nest pas du même type que
la variable à gauche de lopérateur, une
conversion implicite est effectuée si lordre de
cette séquence est respecté byte ? short ? int
? long ? float ? double.
Autrement, une conversion explicite doit être
effectuée.
13
Priorité des opérateurs
Liste des opérateurs en commençant par les plus
prioritaires
? ? ? ? ? ? ? ? ? ? ? ? ? ?
Un opérateur de plus grande priorité est exécuté
en premier et des opérateurs de même priorité
(sur une même ligne du tableau) sont exécutés de
gauche à droite (?) ou de droite à gauche (?)
selon le cas.
14
Présence de commentaires dans un programme
int i 1 // Ceci est un commentaire. // En
voilà un autre.
/ Il existe une autre façon dinsérer des
commentaires dans un programme. /
15

• Alternatives, répétitions expressions logiques

Opérateurs de comparaison
Nous avons 6 opérateurs relationnels lt, gt, lt,
gt, et ! pour comparer deux valeurs. Ces
valeurs peuvent être des variables, des
constantes ou des expressions dont le type est
byte, short, int, long, char, float ou double.
Le résultat de lexpression logique est une
valeur de type boolean et peut être stocké dans
une variable de ce type.
Ex. boolean etat false etat x y a
b
Les opérateurs arithmétiques sont
prioritaires p/r aux opérateurs de comparaison.
Opérateurs logiques
La différence entre (resp. ) et (resp. )
est la suivante avec lopérateur (resp.
), après évaluation de lopérande de
gauche, si le résultat est false (resp. true),
alors lopérande de droite nest pas évaluée.
et logique et conditionnel ou
logique ou conditionnel ! négation
Ex. etat c gt 'a' c lt 'z' // c est une
variable de type char.
16
Instructions conditionnelles if
if (expression logique) instruction
Ex. if (i 5) i
if (expression logique) instruction instructio
n . . .
Ex. if (i 5) i j i
if (expression logique) instruction else
instruction
Ex. if (i 5) i else --i
if (expression logique) instruction instructio
n . . . else instruction instruction .
. .
Ex. if (i 5) i j
i else --i
17
Instructions conditionnelles if (suite)
On peut retrouver des instructions
conditionnelles imbriquées. La clause else est
alors associée à la clause if la plus proche non
encore sélectionnée et ne faisant pas partie dun
autre bloc.
if (i lt 0) if (j gt 0) i i 5 else i j
if (i lt 0) if (j gt 0) i i 5 else i j
18
Opérateur ternaire
expression_logique ? expression1 expression2
Si lexpression logique est vraie, le résultat de
lopération coïncide avec la valeur de
expression1 autrement, le résultat est la valeur
de expression2.
Ex. int a, b, c . . . c a gt b ? a b //
c renfermera le maximum entre a et b.
Linstruction switch
Permet de choisir parmi un nombre fixe
dalternatives basées sur les différentes valeurs
dune expression. La valeur dune telle
expression doit être de type char, byte, short ou
int autrement, le programme ne compilera pas.
Ex. int code . . . switch(code)
case 1 System.out.println("Division par
zero") break case 2
System.out.println("Debordement de
capacite") break default
System.out.println("Erreur fatale") break
19
Lexécution de linstruction break nous reporte à
linstruction qui suit les accolades
de linstruction switch. Si linstruction break
est absente pour une valeur de lexpression, on
poursuit lexécution des instructions en
séquence.
Ex. int nb . . . System.out.println("1") sw
itch(nb) case 1000 System.out.println("0")
case 100 System.out.println("0") case 10
System.out.println("0") case 1
break default System.out.println("Donnee
invalide.")
Les mêmes instructions peuvent être exécutées
pour des valeurs différentes de lexpression.
20
Ex. char test 'o' . . . switch(test) c
ase 'n' case 'N' System.out.println("Test
non reussi.") break case 'o' case
'O' System.out.println("Test reussi.") brea
k
Note
Il ny a pas de goto en JAVA. Interdit de poser
une affectation comme condition dans une
expression ex. if (V 5) . . .
21

• Portée des variables à lintérieur dun bloc

Une variable déclarée à lintérieur dun bloc
entre accolades est dite variable locale.
Règles

• Une variable nexiste pas avant sa déclaration.
• Après sa déclaration, une variable existe à
  lintérieur du bloc où elle
• est déclarée, ce qui est vrai aussi pour des
  blocs intérieurs à ce bloc.

Ex. int i 1 . . . if (i 1) int a
1 // a est accessible mais b ne lest
pas. // a est accessible mais b ne lest
pas. int b 2 // a et b
existent. // a est accessible mais b ne
lest pas.
22

• Instructions itératives

Boucle for
for (instruction initiale1 expression
booléenne2 instruction3) une suite
dinstructions à exécuter.
instruction initiale1 est exécutée une fois au
début de lexécution de linstruction for. Elle
permet habituellement dinitialiser voire même de
déclarer un compteur ditérations.
expression booléenne2 est évaluée au début de
chaque itération. Si la valeur de lexpression
est vraie, la suite dinstructions est exécutée.
Autrement, on poursuit le traitement après le
bloc dinstructions de la boucle for.
instruction3 est exécutée à la fin de chaque
itération. Elle permet habituellement dincrément
er ou de décrémenter le compteur ditérations.
Ex. for (int i 1 i lt 5 i) int
j j 2 i 1 System.out.println(j)
23
Notes (i) On peut retrouver plusieurs
instructions dans instruction initiale1
ou instruction3 elles sont séparées par une
virgule et exécutées de gauche à droite.
Ex. int somme 0 for (int i 1, j 0 i lt
5 i, j) somme i j
(ii) On peut utiliser des variables réelles
comme compteur ditérations.
Ex. for (double r 1.0 r lt 2.0 r 0.2)
System.out.println("Surface "  3.14159 r
r)
Par contre, on obtient une boucle infinie avec le
test suivant
Ex. for (double r 1.0 r ! 2.0 r 0.2)
System.out.println("Surface "  3.14159 r
r)
À éviter.
24
Boucle while
while (expression booléenne) une suite
dinstructions à exécuter.
Lexpression booléenne est évaluée au début de
chaque itération. Si elle est vraie, le bloc
dinstructions est exécuté et on recommence.
Autrement, on poursuit à la suite de ce bloc.
Ex. int i 0, somme 0 while (i lt
10) somme i
25
Boucle do while
do une suite dinstructions à exécuter.
while(expression booléenne)
Idem à la boucle while exception faite que
lexpression booléenne est évaluée à la fin de
chaque itération. Le bloc dinstructions est
alors exécuté au moins une fois.
Ex. int i 0, somme 0 do somme
i while (i lt 10)
Les accolades ne sont pas nécessaires ici.
26
Clause continue
Permet domettre en partie ou en totalité
lexécution des instructions à lintérieur dune
boucle.
Ex. int somme 0 for (int i 0 i lt 100
i) if (i 2 0) continue somme
i // somme renferme la somme des entiers
impairs.
27
Clause break
Permet de terminer lexécution dune boucle.
Ex. // Impression des nombres premiers entre 2
et 50. int n 50 boolean Premier true for
(int i 2 i lt n i) Premier
true for (int j 2 j lt i j) if (i
j 0) Premier false break
if (Premier) System.out.println(i)
28

• Tableaux

Nous distinguons la déclaration dune variable
tableau
double nombres // Aucun espace mémoire na
été alloué et // le nombre déléments nest
pas défini.
de la création du tableau lui-même
nombres new double10 // Lespace mémoire
est alloué pour dix // composantes.
On peut combiner les deux double nombres
new double10
Les éléments du tableau sont nombres0,
nombres1, , nombres9.
Une variable tableau peut être réutilisée pour
créer un nouveau tableau de réels
nombres new double50
ainsi, lancien tableau de 10 éléments est perdu.
Note
Une variable tableau dun type T ne peut référer
quà un tableau déléments de type T. T peut
être quelconque et même une classe définie par le
programmeur.
29
Un tableau peut être initialisé lors de sa
déclaration
int premiers 2, 3, 5, 7, 11, 13, 17, 19
ou composante par composante
int premiers new int8 . premiers0 2
Deux variables tableaux peuvent référer au même
tableau
int premiers 2, 3, 5, 7, 11, 13, 17,
19 int nombres_premiers premiers
On peut accéder aux composantes dun tableau
comme suit
double moyenne 0.0 for (int i 0 i lt 50
i) moyenne nombresi moyenne moyenne /
50.0
Pour rendre le code indépendant du nombre
déléments du tableau, on peut utiliser la
fonction length comme suit
double moyenne 0.0 for (int i 0 i lt
nombres.length i) moyenne
nombresi moyenne moyenne / nombres.length
30
Pour déclarer un tableau à deux dimensions, on
procède comme suit
double temps new double550 . doubl
e moyenne 0.0 for (int i 0 i lt
temps.length i) for (int j 0 j lt
temps0.length j) moyenne
tempsij moyenne moyenne / (temps.length
temps0.length)
Les tableaux peuvent être de longueur variable
comme dans lexemple suivant
double P new float5 . for (int i
0 i lt P.length i) Pi new doublei 1
Ces principes sappliquent à des tableaux à trois
dimensions ou plus.
On peut bien entendu définir des tableaux de
caractères
char message new char20 char voyelles
'a', 'e', 'i', 'o', 'u', 'y'
31
Structure dun programme simple
La structure dun programme Java peut comprendre
plusieurs fichiers sources renfermant chacun la
définition dune classe. Lune dentre elles doit
contenir une méthode appelée main() dans une
application, cest cette méthode qui
sera exécutée en premier.
public class MonProgramme // Définition de la
classe renfermant la // méthode main().
Le nom du fichier renfermant cette classe doit
être  MonProgramme .
Soit un programme Java élémentaire renfermant
uniquement la méthode main() public class
PremierProgramme public static void
main(String args) // Définition de la
méthode main() int i 12 System.out.printl
n("Premier essai") System.out.println("Valeur d
e i " i)
32
Les mots clés précédents ont la signification
suivante  public  accès global static  acce
ssible même si aucun objet de la classe
nexiste void  aucune valeur de
retour System  classe de base avec des
attributs static dans le package
java.lang permettant les opérations dentrée /
sortie standards out  objet de la classe
System représentant le flot de sortie sur
un écran daffichage println()  méthode
public appartenant à lobjet out qui permet
dafficher des données.
33

• Le concept de classe

Une classe renferme  ? des variables de
nimporte quel type et même des objets de
nimporte quelle classe, ? des méthodes
lesquelles opèrent sur les variables de la classe.
Un objet dune classe est une instance de cette
classe.
Dans une classe, on retrouve 2 types de
variables  ? les variables associées aux objets
de la classe Chaque objet de la classe
possède sa propre copie de ces variables et par
conséquent, des valeurs qui lui sont
spécifiques. Cela permet de différencier un
objet dun autre. ? les variables partagées par
tous les objets de la classe Il existe une
seule copie de ces variables peu importe le
nombre dobjets créés de cette classe et même si
aucun objet na été créé. Lorsquun objet
modifie une telle variable, cette modification
est accessible par tous les objets. Ces
variables doivent être déclarées avec le mot clé
static.
34
Dans une classe, on retrouve 2 types de méthodes 
? les méthodes associées aux objets de la classe
Ces méthodes peuvent être exécutées
seulement en lien avec un objet
particulier. ? les méthodes propres à la classe
Ces méthodes peuvent être exécutées même
quand aucun objet de la classe na été créé.
Elles ne peuvent donc référer à des variables
associées aux objets de la classe. Ces
méthodes doivent être déclarées avec le mot clé
static.
Ex. Méthode retournant le nombre dobjets de
cette classe qui ont créés.
Une classe peut aussi être définie uniquement
comme un ensemble de méthodes. Par exemple, la
classe standard Math renferme uniquement des
fonctions mathématiques classiques et des
variables constantes celles-ci sont
déclarées static.
Ex. double racine Math.sqrt(Math.PI)
Le principe dencapsulation est très bien
respecté notez que les méthodes sont définies à
lintérieur de la classe (incluant le corps des
méthodes).
35
Exemple 1
class Sphere static final double PI
3.14159 // final désigne une variable
constante. static int Nombre_de_spheres_creees
0 double xc, yc, zc, rayon double
volume() return 4.0 / 3.0 PI rayon
rayon rayon static int Compteur() //
Les variables non statiques ne sont pas //
accessibles dans une méthode statique. return
Nombre_de_spheres_crees void
inserer_rayon(double R) rayon R // à
compléter !
Note
Laccès aux données membres dans une méthode se
fait comme en C.
36
Exemple 2
public class JourDeLaSemaine // Objets
constants daccès public et static de la classe
String. public final static String JourLundi
"lundi" public final static String JourMardi
"mardi" public final static String JourMercredi
"mercredi" public final static String
JourJeudi "jeudi" public final static String
JourVendredi "vendredi" public final static
String JourSamedi "samedi" public final
static String JourDimanche "dimanche" //
Tableau dobjets constants daccès private et
static de la classe String. private final
static String Jours new String JourLundi,
JourMardi, JourMercredi, JourJeudi, JourVendred
i, JourSamedi, JourDimanche // Données
membres privées. private String nom
JourLundi private int Indice 0
37
Exemple 2 (suite)
public String AccesNom() return
nom public int AccesIndice() return
Indice public void InitIndice(int
i) Indice i nom Joursi //
Méthode constante daccès public et static.
public static final String AccesNom(JourDeLaSema
ine j) return Joursj.AccesIndice()
38
Exemple 2 (suite et fin)
public class DonneeMethodeStatique public
static void main(String args) System.out.pr
intln(JourDeLaSemaine.JourLundi) JourDeLaSemai
ne jour new JourDeLaSemaine() jour.InitIndice
(4) System.out.println(jour.AccesNom()) Syst
em.out.println(JourDeLaSemaine.AccesNom(jour))

39
Passage de paramètres
Le passage des paramètres avec des types de
données de base se fait par valeur. Ainsi, une
copie seulement de chaque paramètre est
accessible à la méthode. Par conséquent, la
méthode ne peut pas modifier la valeur de la
variable du programme appelant. On peut utiliser
nimporte quelle expression pour un argument en
autant que le type de lexpression coïncide avec
le type du paramètre correspondant de la
méthode. Par contre, lorsque le paramètre dune
méthode est un objet, cest une référence
à lobjet et non lobjet lui-même qui est passé
en paramètre.
la variable this
Dans une méthode, il sagit dune référence à
lobjet courant. this est utilisé implicitement
lorsquune méthode réfère à une donnée membre de
la classe.
Ex.
Sphere S new Sphere() // S est un objet de la
classe Sphere. . . . double vol S.volume() //
La variable this dans la méthode volume() //
réfère à lobjet S de sorte que rayon //
correspond à la donnée rayon de S.
40
On peut utiliser la variable this pour distinguer
entre le nom dun paramètre dune méthode et une
donnée membre de la classe, lorsquils portent le
même identifi- cateur.
void inserer_rayon(double rayon) this.rayon
rayon
Ex.
la présence de constructeurs même usage quen
C
Rôle permettre dinitialiser les données
membres appartenant à lobjet créé.

• méthode qui ne retourne jamais de valeur (aucun
  type de retour ni void).
• le nom de la méthode coïncide avec le nom de la
  classe.

41
public class Sphere static final double PI
3.14159 // final désigne une variable
constante static int Nombre_de_spheres_creees
0 double xc, yc, zc, rayon Sphere(double R,
double x, double y, double z) rayon
R xc x yc y zc z Nombre_de_spheres_
creees 1 // Un nouvel objet est
créé. double volume() return 4.0 / 3.0
PI rayon rayon rayon static int
Compteur() return Nombre_de_spheres_crees
void inserer_rayon(double R) rayon R
42
la création dobjets
Sphere S // Aucun objet nest créé uniquement
une variable de type // Sphere est créée
laquelle référera éventuellement à un // objet
de type Sphere. S new Sphere(10.0, 1.0, 1.0,
1.0) // Un objet de type Sphere est créé. Sphere
B S // Deux variables différentes réfèrent
au // même objet.
la durée de vie dun objet
La durée de vie dun objet est fonction de la
portée de la variable qui y réfère. Lorsquil
nexiste plus de variables qui réfèrent à
lobjet, lobjet est marqué  à détruire . S
null // Lobjet référé par S est marqué  à
détruire  si S était la seule // référence à
lobjet.
La libération de lespace mémoire est automatique
en JAVA. Toutefois, même si un objet est marqué
 à détruire , lespace mémoire ne sera pas
nécessaire- ment libéré immédiatement. La méthode
System.gc suggère lutilisation du ramasse-miette.
43
Le passage dobjets à une méthode
Lorsquun paramètre dune méthode est un objet,
le mécanisme de passage est celui par référence
i.e. une copie de la référence à lobjet est
transférée au lieu de lobjet lui-même.
public static void main(Stringargs) . rayon
  10.0 Sphere S new Sphere(10.0, 1.0, 1.0,
1.0) Objet.change(S) .. Sphere
change(Sphere q) .. q.inserer_rayon(1.0) //
S est modifié en conséquence. return q
rayon 10.0 xc 1.0 yc 1.0 zc 1.0
S
copie
q
44
Le passage de tableaux à une méthode
Lorsquun paramètre dune méthode est un tableau,
le mécanisme de passage est aussi celui par
référence.
public class TableauxEnParametre public static
void Modifier(int tab) for (int i 0 i
lt tab.length i) tabi 2 public
static void main(String args) int tab
new int 1, 2, 3, 4, 5 System.out.println()
System.out.println("Contenu du tableau avant
modification") for (int i 0 i lt tab.length
i) System.out.println(tabi) Modifier(tab
) System.out.println("Contenu du tableau apres
modification") for (int i 0 i lt tab.length
i) System.out.println(tabi)
45
la surcharge de méthodes
Java permet de définir plusieurs méthodes avec le
même nom en autant que chacune delles possède un
ensemble unique de paramètres. Il faut noter
que le type de donnée de la valeur de retour ne
permet pas de distinguer ces méthodes.
les constructeurs multiples
Permet de définir un objet dune classe de
différentes façons.
public class Sphere static final double PI
3.14159 // final désigne une variable
constante static int Nombre_de_spheres_creees
0 double xc, yc, zc, rayon Sphere(double R,
double x, double y, double z) rayon
R xc x yc y zc z Nombre_de_spheres_
creees 1 // Un nouvel objet est créé.
46
Sphere(double x, double y, double z) rayon
1.0 xc x yc y zc z Nombre_de_sphe
res_creees 1 // Un nouvel objet est
créé. Sphere() rayon 1.0 xc
0.0 yc 0.0 zc 0.0 Nombre_de_spheres_creee
s 1 // Un nouvel objet est créé. .
On peut ainsi créer des objets de la classe
Sphere comme suit
Sphere P new Sphere(1.0, 2.0, 3.0) Sphere Q
new Sphere()
47
duplication des objets
Sphere R S // Ne fournit pas une copie de
lobjet S. // R et S sont 2 références au même
objet. // Aucun appel de constructeur nest
fait. Pour effectuer une copie dun objet, il
sagit de créer un nouveau constructeur  Sphere(
Sphere U) rayon U.rayon xc U.xc yc
U.yc zc U.zc Nombre_de_spheres_creees
1 // Un nouvel objet est créé. on peut alors
créer un nouvel objet distinct  Sphere R new
Sphere(S)
48
Exemple
class Point double x double y Point(double
Px, double Py) x Px y Py Point(Point
Q) x Q.x y Q.y Point(Segment S1,
Segment S2) double num (S2.Fin.y -
S2.Debut.y)(S2.Debut.x - S1.Debut.x)-
(S2.Fin.x - S2.Debut.x)(S2.Debut.y -
S1.Debut.y) double den (S2.Fin.y -
S2.Debut.y)(S1.Fin.x - S1.Debut.x)-
(S2.Fin.x - S2.Debut.x)(S1.Fin.y -
S1.Debut.y) x S1.Debut.x (S1.Fin.x -
S1.Debut.x)num/den y S1.Debut.y (S1.Fin.y
- S1.Debut.y)num/den void Deplacer(double
xinc, double yinc) x xinc y
yinc double Distance(Point Q) return
Math.sqrt((x - Q.x)(x - Q.x) (y - Q.y)(y -
Q.y)) void Affiche() System.out.println("P
osition du point " x ", " y)
49
class Segment Point Debut Point
Fin Segment(Point Debut, Point
Fin) this.Debut new Point(Debut) // On
doit créer 2 nouveaux points pour
sassurer this.Fin new Point(Fin) // que le
segment est indépendant des objets //
transmis au constructeur. Autrement, une //
modification de ces objets entraînerait
une // modification au segment. Segment(
double xd, double yd, double xf, double
yf) Debut new Point(xd, yd) Fin new
Point(xf, yf) double Longueur() return
Debut.Distance(Fin)
50
public class Application public static void
main(String args) Point Debut new
Point(0.0, 1.0) Point Fin new Point(5.0,
6.0) Segment S1 new Segment(Debut,
Fin) Segment S2 new Segment(4.0, -5.0, 9.0,
10.0) Point Intersection new Point(S1,
S2) Intersection.Affiche() Fin.Deplacer(-2.
0, -9.0) new Point(S1, S2).Affiche() // Aucun
changement.
51

• La notion de package

Un package est un ensemble de classes. Cette
notion facilite lajout de classes dans un
programme. Chaque classe fait partie dun
package. Les classes que nous avons
définies jusquà maintenant font partie dun
package par défaut lequel ne possède pas
de nom. Les classes standards dans Java que nous
avons utilisées jusquà maintenant font partie du
package java.lang lequel est disponible
automatiquement dans nos programmes.
Création dun package
Toutes les définitions de classes dun même
package doivent être présents dans un même
répertoire dont le nom est celui du package.
1.
Ex. Dans lexemple précédent, nous avons créé
un répertoire dont le nom est celui du package,
soit Geometrie. Geometrie renferme alors 2
fichiers Point.java et Segment.java
qui contiennent respectivement la définition des
classes Point et Segment.
52
Pour insérer une classe dans un package, vous
devez ajouter une déclaration à cet effet avant
la définition de la classe.
2.
Dans le fichier Point.java, on a
package Geometrie public class Point //
Définition de la classe.
Le mot clé public est nécessaire si vous voulez
que la classe Point soit accessible à lextérieur
du package sans quoi la classe sera
accessible seulement par les autres classes du
package.
Pour inclure toutes les classes dun package ou
quelques-unes dans un programme, vous devez
utiliser la clause import comme suit 
3.
import Geometrie. // Il ne faut pas hésiter à
importer des packages entiers.
au tout début du programme dapplication.
Le programme dapplication se trouve dans le
répertoire qui renferme le package Geometrie.
53
Remarque
Le nom dun package peut être simple ou composé.
Supposons que nous avons un répertoire Geometrie
lequel renferme deux sous-répertoires Figure_2D
et Figure_3D, la classe Sphere ferait alors
partie du package Geometrie.Figure_3D comme
suit  package Geometrie.Figure_3D public
class sphere . Pour inclure toutes les
classes dun package ou quelques-unes dans un
programme, vous devez utiliser la clause import
comme suit  import Geometrie.Figure_3D. //
Toutes les classes de Geometrie.Figure_3D //
sont retenues. ou encore, import
Geometrie.Figure_3D.Sphere // La classe Sphere
est retenue. Si vous importez plusieurs fois les
mêmes classes, cela ne gêne pas.
Si lon retrouve les mêmes noms de classe dans
des packages différents, vous ne pouvez pas les
importer tous les deux mais vous pouvez les
désigner au complet.
Ex. les classes Geometrie.Figure_3D.Vecteur et
Geometrie.Figure_2D.Vecteur.
54
Packages standards en JAVA
Il existe un grand nombre de packages disponibles
(3278 classes dans JAVA 1.5). Ceux-ci nous seront
particulièrement utiles  java.lang Ce sont les
classes de base de Java et celles permettant
de manipuler les tableaux et les chaînes de
caractères. Ce package est toujours disponible
par défaut il est importé par défaut dans tous
les programmes JAVA. java.io Ce sont les
classes reliées aux opérations dentrées /
sorties. java.util On y retrouve plusieurs
utilitaires notamment, pour manipuler
des données.
Pour programmer efficacement, une bonne
connaissance de ces packages est indispensable.
Remarque
Pour utiliser des classes dun package autre que
java.lang, la clause import est nécessaire
ainsi, on peut référer à une classe uniquement
par son nom. Autrement, il faut expliciter le
nom au complet Ex. Geometrie.Point P new
Geometrie.Point(3.2, 1.5)
55
Accès aux variables et méthodes dune classe
À lintérieur dun package donnée, une classe a
accès aux noms des autres classes pour créer de
nouveaux objets par exemple. Mais les variables
et les méthodes de ces autres classes ne sont pas
nécessairement accessibles cela dépend des
modes daccès de ces membres.
Quatre modes daccès aux membres dune classe A
sont disponibles  Mot-clé Signification aucu
n laccès est donné à nimporte quelle classe du
package public laccès est donné à nimporte
quelle classe private aucun accès nest donné à
lextérieur de la classe A protected laccès est
donné à nimporte quelle classe du package et
nimporte quelle classe dérivée de A.
Package renfermant A, B et C
Classe A
Classe B
Sous-classe C
oui
oui
int x public int y protected int z private int
w
oui
oui
oui
oui
non
non
56
Package renfermant A
Package renfermant B
Package renfermant C
Classe A
Classe B
Sous-classe C
non
non
int x public int y protected int z private int
w
oui
oui
non
oui
non
non
57
Ex.
public class Point private double x private
double y public Point(double Px, double
Py) x Px y Py public Point(Point
P) x P.x y P.y public void
Deplace(double Dx, double Dy) x Dx y
Dy public double AccesX() return
x public double AccesY() return y .
58
La méthode finalize()
Nous pouvons inclure cette méthode dans une
classe cela joue le rôle de destructeur.
Cette méthode est appelée automatiquement par
JAVA avant que lobjet soit détruit et avant que
lespace mémoire occupé par lobjet soit libéré.
Lorsquun objet nest plus accessible dans un
programme, cela signifie quil est détruit pour
ce programme mais ce nest pas le cas pour
lenvironnement JAVA où lobjet peut être détruit
ultérieurement cest à ce moment-là que la
méthode finalize serait appelée.
protected void finalize() // Actions
permettant de libérer des ressources du
système. // Ex. Fermeture dun fichier sur
disque.
59

• Le concept dhéritage

Lorsquune classe est dérivée dune classe de
base, elle hérite des membres de la classe de
base sous certaines conditions  1er cas  la
classe de base et la classe dérivée font partie
du même package Une classe dérivée a accès à
toutes les données membres dune classe de base
à lexception de celles étiquetées
private. 2ième cas  la classe de base et la
classe dérivée font partie de packages
différents. La classe de base doit être
déclarée obligatoirement public. Une classe
dérivée a accès à toutes les données
membres dune classe de base à lexception de
celles étiquetées private et de celles qui ne
sont pas étiquetées. Ces règles sappliquent
aussi aux variables statiques. Les règles
dhéritage des méthodes sont les mêmes que les
données membres à lexception des constructeurs
qui ne peuvent être hérités.
60
Note
Ces règles dhéritage définissent les modalités
daccès aux membres de la classe de base. Même si
un membre nest pas accessible dans la classe
dérivée, cela ne signifie pas quil nexiste pas
dans la classe dérivée. Au contraire, tous les
membres de la classe de base doivent être
présents dans la classe dérivée pour son
bon fonctionnement.
Exemple
public class Animal private String
type_Animal public Animal(String
A) type_Animal new String(A) public
void Afficher() System.out.println(type_Anima
l)
61
// La classe chien hérite de Animal i.e. de la
méthode Afficher() seulement. public class chien
extends Animal // La classe chien est dérivée de
Animal. private String nom private String
race public chien(String N) // 1e constructeur
de la classe dérivée super("Chien") // Doit
être la 1ière instruction du constructeur. //
Il sagit dun appel du constructeur de
Animal // car il nest pas accessible
directement. nom N race
"Inconnu" public chien(String N, String
R) // 2ième constructeur de la classe
dérivée super("Chien") // Doit être la
1ière instruction du constructeur. // Il
sagit dun appel du constructeur de
Animal // car il nest pas accessible
directement. nom N race R
62
public class Test public static void
main(String args) chien C new
chien("Fido", "Chihuahua") C.Afficher() // La
classe chien hérite de la méthode
Afficher() // seulement. Dans la classe
dérivée chien, on peut redéfinir la méthode
Afficher() comme suit  public void
Afficher() super.Afficher() // Appel de la
méthode Afficher() de Animal // laquelle est
cachée par celle de chien. System.out.println("No
m  " nom "Race  " race)
Note
On devrait toujours appeler un constructeur de la
classe de base à lintérieur dun constructeur
dune classe dérivée cet appel doit être la
1ière instruction du constructeur de la classe
dérivée.
Sil en est autrement, un appel à un constructeur
par défaut de la classe de base sera effectué
super() celui-ci doit exister sans quoi, le
compilateur générera une erreur.
63

• Le mot-clé final

On peut utiliser le mot clé final pour empêcher
la redéfinition dune méthode dune classe dans
une classe dérivée. On peut utiliser le mot clé
final lors de la déclaration dune classe pour
empêcher la création de nouvelles classes
dérivées de celle-ci.
64

• Le concept de polymorphisme

À partir dune même variable, plusieurs méthodes
peuvent être appelées selon le contenu de
celle-ci. Plus précisément, une variable dont le
type correspond à la classe de base peut ranger
un objet appartenant à lune ou lautre des
classes dérivées cette variable permet alors
dappeler une méthode de lune ou lautre
des classes dérivées dépendamment de la classe de
l'objet. Le choix de la méthode est fixé au temps
dexécution et non à la compilation.
Exemple
Application du polymorphisme avec les méthodes
 Afficher  et  son_emis .
class Animal private String type_Animal publi
c Animal(String A) type_Animal new
String(A) public void Afficher() System.ou
t.println(type_Animal) public void
son_emis() // Cette fonction avec un bloc
d'instructions vide // doit être insérée afin
de pouvoir appliquer le // polymorphisme avec
cette méthode.
65
class chien extends Animal // La classe chien est
dérivée de Animal. private String nom private
String race public chien(String N) // 1e
constructeur de la classe dérivée super("Chie
n") nom N race "Inconnu" public
chien(String N, String R) // 2ième constructeur
de la classe dérivée super("Chien") nom
N race R public void Afficher() supe
r.Afficher() // Appel de la méthode Afficher()
de Animal // laquelle est cachée par celle de
chien. System.out.println("Nom " nom "
Race " race) public void
son_emis() System.out.println("Woof
Woof")
66
class chat extends Animal // La classe chat est
dérivée de Animal. private String nom private
String race public chat(String N) // 1e
constructeur de la classe dérivée super("Chat
") nom N race "Inconnu" public
chat(String N, String R) // 2ième constructeur de
la classe dérivée super("Chat") nom
N race R public void Afficher() supe
r.Afficher() // Appel de la méthode Afficher()
de Animal // laquelle est cachée par celle de
chat. System.out.println("Nom " nom "
Race " race) public void
son_emis() System.out.println("Miaou
Miaou")
67
public class ApplicationPolymorphisme public
static void main(String args) Animal
Mes_animaux new chien("Fido",
"Batard"), new chat("Tas de poil") for
(int i 0 i lt 2 i) Mes_animauxi.Affi
cher() Mes_animauxi.son_emis() Anima
l A new Animal("Monstre a 4 pattes") A.Affich
er() // Les fonctions Afficher et son_emis de la
classe A.son_emis() // Animal. chien B
new chien("Pitou") B.Afficher() // Les
fonctions Afficher et son_emis de la
classe B.son_emis() // chien.
Note
On remarque que dans chaque cas, les méthodes
Afficher et son_emis utilisées sont
déterminées au temps dexécution.
68

• La classe Object

Toutes les classes définies en JAVA sont des
sous-classes de la classe de base Object. Ceci
est automatique et na pas besoin dêtre
spécifié. Un intérêt de ceci est de pouvoir
définir une variable de type Object laquelle
peut référer à un objet dune classe quelconque.
Cest avantageux en particulier lorsque vous
voulez définir une méthode qui doit manipuler des
objets de type inconnu.
Dans la classe Object, 7 méthodes sont daccès
public et 2 sont daccès protected. Les classes
définies par un programmeur hériteront de ces 9
méthodes. Nous en verrons 4. Méthode Fonctionnal
ité (i) toString() Retourne un objet de la
classe String décrivant lobjet courant.
Il sagit du nom de la classe suivi de _at_ suivi
dune représentation hexadécimale de
lobjet. Ex. Ajoutons à la fin de la méthode
main() de lexemple précédent linstruction
suivante System.out.println(B.toString())
ce qui donne chien_at_45a877
69
Note
Si cela ne nous agrée pas, on peut ajouter à la
classe Animal la méthode
public String toString() return "Ceci est
un " type_Animal " eh oui un "
super.toString().substring(0,
super.toString().indexOf('_at_'))
(ii) getClass() Retourne un objet de type Class
permettant didentifier la classe de lobjet
courant.
Ex.  Animal C new chat("Max") Class
type_objet C.getClass() System.out.println(typ
e_objet.getName()) // getName() est une
méthode de la classe Class qui retourne le nom de
la // classe comme un objet String i.e.
chat. Note  Dautres méthodes de la classe
Class sont aussi disponibles (voir I. Horton,
Beginning JAVA. Wrox, p. 222).
70
(iii) finalize() Cest la méthode qui est appelée
lorsquun objet est détruit. On peut effectuer
une surcharge de cette méthode à lintérieur
de sa propre classe en autant que lon fasse
appel à super.finalize().
(iv) clone() permet de créer un nouvel objet du
même type que lobjet courant où chaque
variable du nouvel objet reçoit la même valeur
que celle de lobjet courant. Cependant,
lorsque des variables de la classe réfèrent à
des objets, ceux-ci ne sont pas automatiquement
dupliqués lors du clonage. Ainsi, 2 objets
peuvent partager un même objet comme donnée
membre.
(iii) et (iv) ont comme mode daccès protected
dans la classe Object.
public class Chien_compagnie extends
Animal implements Cloneable // Essentiel pour
cloner des objets de cette classe. private
String nom private String race public
Chien_compagnie(String N, String
R) super("chien de compagnie") nom N race
R public void Change_Nom(String N) nom
N public String Acces_Nom() return
nom public void Afficher() super.Afficher
() System.out.println("Nom  " nom "Race 
" race)
Ex.
71
public class Mes_animaux implements Cloneable //
Cette classe peut être clonée. Chien_compagnie
C // Renferme un chien de compagnie comme //
donnée membre. public Mes_animaux(String N,
String R) C new Chien_compagnie(N,
R) public void Change_Nom(String
N) C.Change_Nom(N) public String
Acces_Nom() return C.Acces_Nom() public
Object clone() throws CloneNotSupportedException
// La méthode clone() de la classe Object doit
être surchargée avec un mode // daccès public
elle est nécessaire pour cloner un objet de la
classe // Mes_animaux et elle doit être appelée
ainsi sans quoi la compilation // échoue. La
prise en compte de cette exception se fait à
laide dun bloc try // et dun bloc catch dans
la fonction main (voir plus loin). return
super.clone()
72
Voyons maintenant comment le clonage
seffectue  Mes_animaux Les_miens new
Mes_animaux("Toc", "Chihuahua") Pour le cloner,
on procède ainsi  Mes_animaux Les_tiens
(Mes_animaux)Les_miens.clone() Il faut noter
que le chien de compagnie C réfère à la même bête
dans lobjet Les_miens et son clone. Ainsi, en
changeant le nom du chien de compagnie C du clone
Les_tiens. Change_Nom("Tac") vous changez
aussi le nom du chien de compagnie C dorigine.
73

• Pour éviter que cela se produise, on peut
  procéder en deux étapes 
• (i) la méthode clone() de la classe Mes_animaux
  est revue 
• public Object clone() throws CloneNotSupportedExc
  eption
• Mes_animaux pA
• pA (Mes_animaux)super.clone()
• pA.C (Chien_compagnie)C.clone()
• return pA
• la méthode Chien_compagnie.clone() doit être
  ajoutée 
• public Object clone() throws CloneNotSupportedExc
  eption
• return super.clone()

74

• Conversion de types dobjets

La conversion de types dobjets est possible dans
une structure hiérarchique de classes.
La conversion dun type dérivé à un type de base
est implicite.
Animal A new chien("Dog") chat B new
chat("Max") Animal C B
Ex.
En convertissant un objet à une classe de base,
JAVA conserve toute linformation propre à
lobjet avant la conversion sans quoi le
polymorphisme serait impossible.
chat D (chat) C
Ex.
Usage de instanceof
Il peut arriver des situations où lon doit
effectuer une conversion sans être certain du
type de conversion à effectuer. Par exemple,
imaginez une méthode ayant un paramètre de type
Object pour convertir à un type dérivé, il faut
sassurer que la conversion est légale.
chat E If (C instanceof chat) E (chat) C
Ex.
75

• Hiérarchie, agrégation de classes

Ex. Construction dune liste chaînée
Nous allons créer une classe polygone renfermant
une liste de points.
Étape 1 Définition dune classe Sommet
class Sommet Point P // Le point de ce
sommet Sommet suivant // Réfère au sommet
suivant Sommet(double x, double y) // Créer un
nouveau sommet P new Point(x, y) suivant
null Sommet(Point Q) // Créer un nouveau
sommet P new Point(Q) suivant
null void Ranger_suivant(Sommet
S) // Permet de ranger le sommet
suivant suivant S Sommet
Acces_Sommet_suivant() // Retourne le sommet
suivant dans la liste et permet ainsi de la
parcourir. return suivant
76
Étape 2 Définition dune classe Polygone
public class Polygone private Sommet debut //
Le premier sommet de la liste private Sommet
fin // Le dernier sommet de la liste public
Polygone(Point Q) debut new
Sommet(Q0) fin debut for(int i 1 i lt
Q.length i) Ajouter_Point(Qi) public
void Ajouter_Point(Point P) Sommet
Nouveau_sommet new Sommet(P) fin.Ranger_suiva
nt(Nouveau_sommet) fin Nouveau_sommet pu
blic void Ajouter_Point(double x, double
y) Sommet Nouveau_sommet new Sommet(x,
y) fin.Ranger_suivant(Nouveau_sommet) fin
Nouveau_sommet
77
Ex. Généralisation à une liste chaînée
quelconque
Étape 1 Définition dune classe Element.
class Element Object P // Lobjet faisant
partie de cet élément. Element suivant //
Réfère à lélément suivant dans la
liste. Element(Object Q) // Créer un nouvel
élément. P Q suivant null void
Ranger_suivant(Element S) // Permet de ranger
lélément suivant. suivant S Element
Acces_Element_suivant() // Retourne lélément
suivant dans la liste et permet ainsi de la
parcourir. return suivant Object
Acces_Objet() // Retourne lobjet de lélément
courant. return P
78
Étape 2 Définition dune classe Liste_simple
grâce à la classe Object.
public class Liste_simple private Element
debut // Le premier élément de la
liste. private Element fin // Le dernier
élément de la liste. private Element courant //
Lélément courant de la liste. public
Liste_simple(Object E) debut new
Element(E) fin debut public
Liste_simple(Object Q) debut new
Element(Q0) fin debut for(int i 1 i
lt Q.length i) Ajouter_Objet(Qi) public
void Ajouter_Objet(Object P) Element
Nouvel_Element new Element(P) fin.Ranger_suiv
ant(Nouvel_Element) fin Nouvel_Element
79
public Object Acces_premier_objet() courant
debut return debut.Acces_Objet() public
Object Acces_objet_suivant() courant
courant.Acces_Element_suivant() return courant
null ? null  courant.Acces_Objet()
Étape 3 Définition dune classe Polygone.
public class Polygone Liste_simple P public
Polygone(Point Q) P new Liste_simple(Q)
public void Ajouter_point(Point Q) P.
Ajouter_Objet(Q) public void
Ajouter_point(double x, double y) P.
Ajouter_Objet(new Point(x, y))
80

• Classes abstraites

Lorsque nous définissons des classes de base, il
arrive que certaines méthodes naient aucun sens
dans la classe de base mais uniquement dans des
classes dérivées. Par conséquent, limplantation
de telles méthodes dans les classes de base nest
pas pertinente elles sont là seulement pour
tirer profit des avantages du polymorphisme. Java
a alors introduit le concept de classes
abstraites. Une telle classe renferme au moins
une méthode qui est déclarée mais non définie.
Ex.
public abstract class Animal private String
type_Animal public Animal(String
A) type_Animal new String(A) public
void Afficher() System.out.println(type_Anima
l) public abstract void son_emis()
81
Le mode daccès dune méthode abstraite ne peut
être privé car une méthode dont le mode daccès
est privé ne peut être héritée. Une classe
dérivée où les méthodes abstraites ne sont pas
toutes définies est elle-même abstraite et doit
être définie avec le mot clé abstract. Nous
pouvons déclarer des objets de classes abstraites
pour référer à des objets de classes dérivées.
82

• Interface

On peut définir en Java toute une hiérarchie de
classes où lon retrouve dans chacune delles un
ensemble commun de méthodes. Pour faciliter la
déclaration de cet ensemble, on introduit la
notion dinterface. Une interface est un
ensemble de constantes (publiques, statiques et
finales par défaut) et/ou de méthodes (publiques
et abstraites par défaut). Vous pouvez implanter
une interface dans une classe en définissant ses
méthodes abstraites ses constantes sont alors
disponibles dans la classe. Ex.  public
interface syndique double Taux_de_cotisation
0.98 double Cotisation_annuelle(double
Traitement) Une interface peut aussi être
définie à partir (ou dérivée) dune
autre. public interface professeur_syndique
extends syndique double Traitement_annuel(int
Nb_annees_anciennete)
83
Pour implanter une interface dans une classe, on
procède comme suit (chaque méthode abstraite doit
être définie) public class professeur
implements professeur_syndique . public
double Cotisation_annuelle(double
Traitement) . public double
Traitement_annuel(int Nb_annees_anciennete)
. Si au moins une des méthodes de
linterface nest pas définie, la classe doit
être déclarée abstraite.
84

• Gestion dexceptions

Une exception est un objet dune classe dérivée
de la classe de base Throwable, peu importe que
lexception soit définie et lancée par vous-même,
que ce soit une exception standard lancée à la
suite dune erreur dans votre code ou une
exception lancée par une méthode appartenant à un
des packages standards.
Les exceptions standards sont prises en compte
par les classes dérivées Error et Exception
suivantes
Object
Throwable
Error
Exception
...
...
Exceptions que nous pouvons prendre en compte
Exceptions que lon ne peut prendre en compte
85
Les exceptions de la classe Exception.
Une classe importante RuntimeException dérivée de
la classe Exception a la particularité de ne pas
nécessiter le traitement des exceptions ce qui
nest pas le cas des autres classes dérivées de
la classe Exception comme par exemple, la classe
IOException du package java.io.
Les sous-classes de RuntimeException sont
définies dans les packages java.lang et java.util.
java.lang
ArithmeticException Division par
zéro. ArrayStoreException Incompatibilité de type
lorsquon tente de stocker un objet comme
composante dans un tableau. ClassCastException Co
nversion de type dobjet invalide. IllegalArgument
Exception Passage dun argument à une méthode
dont le type est invalide. IllegalMonitorStateExce
ption Voir le concept de fils dexécution
( threads ). IndexOutOfBoundsException Usage
dun indice hors de portée dun tableau, dun
objet de la classe String ou de la classe
Vector. NegativeArraySizeException Définition
dun tableau de dimension négative. NullPointerExc
eption Accès à un membre dun objet via une
variable de valeur null. SecurityException Violat
ion aux règles de sécurité. EmptyStackException
Opération illégale sur une pile vide dans la
classe Stack. NoSuchElementException Usage de la
méthode nextElement() (voir linterface Enumera
tion) lorsque lélément suivant nexiste pas.
java.util
86
Traitement des exceptions
Pour les classes dérivées de la classe Exception
autre que la classe RuntimeException ou une
dérivée, lorsquune méthode dans votre
programme dapplication peut générer une
exception de lune de ces classes, deux
options soffrent à vous.
1. Spécification des exceptions qui peuvent être
lancées par une méthode
Il sagit simplement dajouter une clause throws
dans la définition de la méthode.
Ex.
double MaMethode() throws EOFException,
FileNotFoundException // Code renfermant des
opérations dentrées / sorties dans // le package
java.io qui peuvent lancer des exceptions //
représentées par des objets des classes
EOFException et // FileNotFoundException.
87
2. Prise en compte de lexception
Pour prendre en compte une exception là où elle
est détectée, nous avons les blocs suivants
try il renferme le code qui peut donner lieu
à une ou des exceptions.
try // Code pouvant entraîner une exception.
Si le bloc try est absent, on ne peut prendre en
compte lexception là où elle est détectée.
catch il renferme le code qui prend en compte
des exceptions.
Ce bloc suit immédiatement le bloc try qui
renferme le code qui peut don