INTRODUCTION AU LANGAGE

JAVA
Dr. ADG
UADB
AMRT2 / 2019

1
 Plan du cours
• Généralités
• Syntaxe de base
• Structures de contrôle
• Programmation Orientée Objet
• L‟héritage
• Classes abstraites et interface
• Packages
• Tableaux
• Chaines de caractères
• Gestion des Exceptions 2
 Bibliographie java (1/2)
• Le langage java, [Link], [Link],
Thomson,1996.
• Programmer en Java, Claude Delannoy, 2000
• Le livre de Java premier langage: Avec 109
exercices corrigés, Anne Tasso, 2012.
• Algorithmique et programmation en Java:
Cours et exercices corrigés, 2000.
• Le langage java-Programmer par l’exemple,
[Link], [Link], Technip, 2000.
• Algorithme et Programation objet en java,
[Link], Dunod, 2001. 3
 Bibliographie java (2/2)
• Initiation à l’algorithme objet, A. Cardon,
[Link], Eyrolles, 2001.
• Thinking in java, [Link], Printice Hall, 2000,
Disponible sous forme électronique à l‟URL
[Link]
• Le poly de java, [Link], Polycopié,
Université de la Méditerranée, 2003.
• Site java de sun: [Link]
Ou
[Link]
4
Chapitre 1: GENERALITES

5
 C‟est quoi java?
• Langage orienté objet (moderne) développé par sun Microsystems
en 1990 (aujourd‟hui racheté par Oracle).
• Excellente portabilité: une fois votre programme créé, il
fonctionnera automatiquement sous windows, Mac, Linux, etc.
Le compilateur java génère un pseudo-code (appelé bytecode)
exécuté par un interpréteur.
• On peut avoir de nombreuses programmes avec java:
– Des applications sous forme de fenêtre ou de console
– Des applets qui sont des programmes java incorporés à des
pages web
– Des sockets pour la programmation réseau
– Des applications pour appareils mobiles, avec J2ME
– Et bien d‟autres J2EE, JMF, J3D, etc.
• Grande richesse des APIs proposés: interfaces graphiques, bases
de données, réseau
• Syntaxe proche de C++
• Dernière version: Java 8
6
 C++/java
C++ : langage compilé
• La compilation du source permet d‟obtenir des
instructions natives exécutables.
• Le code exécutable obtenu est très performant.
Java: langage interprété qui utilise une
machine virtuelle
• Machine virtuelle: simulation d‟un ordinateur réel.
• La compilation d‟un source java permet d‟obtenir un
code exécutable, le bytecode, par la machine virtuelle
java.
• La machine virtuelle java est capable de comprendre
les instructions contenues dans le bytecode et de les
exécuter effectivement dans l‟environnement réel
courant

7
 Java est portable

Interpréteur
Complilateur Java pour PC
Java pour PC

Pseudo-
Compilateur Interpréeur
Code java
Code java Java pour Java pour
Indépendant
source PowerPC PowerPC
De la platefome
.class

Compilateur
Java pour Interpréteur
Sun Solaris Java pour
Sun Solaris

8
 Kit de développement java(1)

3 choix sont possibles:

 Choix 1: le JDK de sun ([Link]
• reférence pour développer en java.
• Comporte tous les outils indispensables à la
réalisation et l‟exécution d‟un programme java.
• Totalement gratuit
• Ne comporte pas de véritable environnement de
développement.

9
 Kit de développement java(2)
 Choix 2: Freeware ou shareware
• Offrent une interface graphique au JDK
• Des outils supplémentaires (générateurs
d‟interface…)
• Exemple: Eclipse, NetBeans
 Choix 3: Environnement de développement
professionnel
• Très puissants
• Très chers…
• Exemples:
 JBuilder 2 de Inprise (anciennement Borland)
 Visual J++ de Microsoft

10
JRE (Java Runtime Environnment)

11
Chapitre 2: Syntaxe de base

12
 Premier programme java
// un premier programme
public class HelloWorld {
public static void main(String [ ] args) {
[Link]("Hello World !");
}
}

13
Structure du programme (1/2)

14
Structure du programme (2/2)

15
Contenu du programme

16
 Lire les entrées clavier

• import [Link];
• Afin de vous préparer à saisir des informations,
veuillez afficher un message à l‟écran
1. Scanner sc = new Scanner([Link]);
[Link]("Veuillez saisir un mot :");
• Pour recupérer le mot
2. String str = [Link]();
3. [Link]("Vous avez saisi : " + str);
• Si c‟est un nombre à saisir:
– nextInt () pour un entier
– nextFloat () pour un réel simple
– nextDouble () pour un réel à double précision
17
– nextByte () pour un byte
Compilation et Exécution d‟un
programme

18
 Les commentaires
• /* commentaire sur une ou plusieurs lignes */
– Identiques à ceux existant dans le langage C
• // commentaire qui se tient sur une ligne
– Identiques à ceux existant en C++
• /** commentaire d'explication */
– Les commentaires d'explication se placent
généralement juste avant une déclaration
(d'attribut ou de méthode)
– Ils sont récupérés par l'utilitaire javadoc et
inclus dans la documentation ainsi générée.

19
 Instructions, blocs et blancs
• Les instructions Java se terminent par un ;
• Les blocs sont délimités par :
{ pour le début de bloc
} pour la fin du bloc
Un bloc permet de définir un regroupement
d‟instructions. La définition d‟une classe ou d‟une
méthode se fait dans un bloc.
• Les espaces, tabulations, sauts de ligne sont
autorisés. Cela permet de présenter un code
plus lisible.
20
 Identificateurs (1)
• On a besoin de nommer les classes, les
variables, les constantes, etc. ; on parle
d‟identificateur.
• Les identificateurs commencent par
une lettre, _ ou $
Attention : Java distingue les majuscules des
minuscules
• Conventions sur les identificateurs :
– Si plusieurs mots sont accolés, mettre une majuscule
à chacun des mots sauf le premier.
• exemple : uneVariableEntiere
– La première lettre est majuscule pour les classes et
les interfaces 21
• exemples : MaClasse, UneJolieFenetre
 Identificateurs (2)

• Conventions sur les identificateurs :

– La première lettre est minuscule pour les
méthodes, les attributs et les variables
• exemples : setLongueur, i, uneFenetre
– Les constantes sont entièrement en
majuscules
• exemple : LONGUEUR_MAX

22
 Les Types Primitifs

Java dispose d‟un certain nombre de types de base dits primitifs, permettant de
manipuler des entiers, des flottants, des caractères et des booléens.
Ce sont les seuls types du langage qui ne sont pas des classes.
Les types primitifs(au nombre de 8) se répartissent en quatre grandes catégories
selon la nature des informations qu‟ils permettent de manipuler:
- nombres entiers,
- nombres flottants,
- caractères
- booléens

23
 Le type entier

Ils servent à représenter les nombres entiers relatifs, ils sont au nombre de
4.
BYTE (1 octet) SHORT (2 octets) INT (4 octets) LONG (8 octets)
byte 8 bits : −128 à 127
short 16 bits : −32768 à 32767
int 32 bits : −2147483648 à 2147483647
long 64 bits : −9223372036854775808 à
9223372036854775807

Les types élémentaires ont une taille identique quelque soit la

plate−forme d'exécution.

24
 Le type flottant

Ils permettent de représenter , de manière approchée, une partie des

nombres réels.
Java prévoit deux types de flottants correspondant chacun à des
emplacements mémoire de tailles différentes: float et double.

Double : 64 bits
Float : 32 bits
Exemple :

float pi = 3.141f; // nécessaire de suffixer par la lettre f sinon erreur de compila

double v = 3d ; // suffixe d non nécessaire 3d = 3
float f = +1.1f , d = 1e10f; // déclaration de plusieurs variables de même type

25
 Le type caractère

CHAR ( 2 octets) et STRING

char : caractère isolé
-codage unicode sur 16 bits non signé
-expression littéral char entre apostrophes
„+‟, „a‟ ,‟\t‟ , „\u???‟
Une variable de type caractère se déclare:
char c1; char c1,c2 ; // c1 et c2 sont 2 variables
caractère
String : chaîne de caractères
-une expression littérale de type String
String s1 = "bonjour", s2 = new String( );
ATTENTION : String est une classe du paquetage [Link] .

26
 Le type booléen

Ce type sert à représenter une valeur logique du type vrai/faux

BOOLEAN
-Deux états: true / false
-Exemples:
boolean ok=false;
if (n<p) … //n<p est expression booléenne valant vrai ou
faux
boolean ordonne ; // déclaration d‟une variable de type
booléenne
………………
ordonne =n<p; //ordonne reçoit la valeur de l‟expression n <
p

27
 Initialisation des variables (1/2)

Exemple :

int nombre; // déclaration de la variable nombre

nombre = 100; //initialisation de la variable nombre
int nombre = 100; //déclaration et initialisation de la variable nombre

valeur = opérateur d‟affectation

nom
type ( associatif de droite à gauche)
Remarque :
Une variable manipulée dans une méthode (variable locale) ou un bloc devra
toujours être initialisée avant toute utilisation.
La déclaration d‟une variable réserve de la mémoire pour stocker sa valeur .
28
 Initialisation des variables (2/2)

En java, toute variable appartenant à un objet (définie comme étant un

attribut de l'objet) est initialisée avec une valeur par défaut en accord avec
son type au moment de la création.
Cette initialisation ne s'applique pas aux variables locales des méthodes de la
classe (cf :remarque précédente).
TYPE VALEUR PAR DÉFAUT
boolean false
byte, short, int, long 0

float, double 0.0

char u\000
classe null
29
 Utilisation des variables

package [Link] ;

public class UtilVariable

{ String chaine ; // variable de type (class ) String, valeur par défaut null
double solde ; // valeur par défaut 0.0 assignée à solde
public static void main(String [ ] args)
{
[Link](" valeur de solde =" +solde); new pour
} créer un objet
public void affiche( )
{ chaine = new String(" bonjour" ); // objet de type String initialisée
long nombre ; // erreur de compilation car nombre non initialisée
[Link](" valeur de nombre= "+nombre);
}}
30
 variables finales
(le mot clé final)

Java permet de déclarer que la valeur d‟une variable ne doit pas être
modifiée pendant l‟exécution du programme
package [Link] ; Une fois convenablement
public class VariableFinale initialisée une variable finale
{ final long NOMBRE ; ne peut pas voir sa valeur évoluée .
final double MAX = 100 ; // variable finale = constante
public static void main(String [ ] args)
{
[Link](" utilisation de variable constante" );
}
public void affiche( )
{ NOMBRE = 1000 ; // initialisation différée de la variable NOMBRE
[Link](" valeur de MAX= "+MAX);
} 31
}
 Les Opérateurs
(arithmétiques binaires)

package [Link] ;
public class Op_Arith_Binaire + - * / sont des
{ public static void main(String [ ] args)opérateurs arithmétiques
{ int a =100, b = 50 ; binaires qui portent sur deux
int addit = a+b; opérandes de même type et
renvoient un résultat du même
soustr = a – b ; type que le type des opérandes ..
div = a/ b;
addit = 150
multi = a*b; soustr = 50
[Link](" addit =" +addit ); div = 2
[Link](" soustr =" +soustr ); multi = 5000
[Link](" div =" +div );
[Link](" multi =" +multi );
32
}
 Les Opérateurs
(unaire et modulo)

package [Link] ;
public class Op_Unaire_et_Modulo Opérateur modulo:
{ public static void main(String [ ] args) fournit le reste de la
{ int a =100, b = 50 ; division de deux
opérandes.
int _modulo = 100 % 50 ;
[Link](" le reste de la division de " +a+" par" +b+" est" +_modulo );
float x = + 10.2f ;
-
double d= 50.2 ;
[Link] (" x et d sont des opérateurs unaires portant sur un seul opérande" );
}
} le reste de la division de 100 par 50 est 0
x et d sont des opérateurs unaires portant sur un seul opérande

33
 Exception sur la manipulation
des opérateurs(1/2)

package [Link] ;
/* test sur la division par zero de nombres entiers */
public class Test {
public static void main (String args[])
{
int valeur=10;
double résultat = valeur / 0;
[Link]("index = " + résultat);
}
} Exception in thread « main »
[Link]:/
by zéro at [Link] ( [Link]

34
 Exception sur la manipulation
des opérateurs(2/2)

Pour les entiers, la division par zéro (par / ou %) conduit à une erreur
d‟exécution. Plus précisément, il y a déclenchement de ce que l‟on
nomme une exception de type ArithmeticException.
Nous verrons plus tard comment traiter les excceptions.
Si nous ne le faisons pas, nous aboutissons à l‟arrêt de l‟exécution du
programme, avec un message de ce type:
Exception in thread « main » [Link]:/ by zéro at
[Link] ( [Link])
REMARQUE :
Pour les flottants, aucune opération ne conduit à un arrêt de
l‟exécution (pas même une division par zéro ) ; seulement
on a une valeur non exploitable.
35
 Les opérateurs relationnels(1/2)

Les quatre premiers(

Opérateur signification <, <=, >, >=) sont de
< inférieur à même priorité. Les
<= inférieur ou égal à deux derniers(= = et
!=) possèdent
> supérieur à également la même
>= supérieur ou égal à priorité, mais celle-ci
== égal à est inférieur à celle
des précédents
!= différent de

Ces opérateurs sont moins prioritaires que les opérateurs arithmétiques.

Ils soumettent eux aussi leurs opérandes aux promotions numériques et
ajustement de type .
36
 Les opérateurs relationnels(2/2)

Exemple :
public class Oper_Relat {
public static void main(String args [])
{ int n = 10 ;
short s =10 ;
float x = 100;
double d= 200;
[Link]("Affichage 1 :"+(n = = s) );
[Link]("Affichage 2 :"+(d <= x) );
}
} Affichage 1 : true
Affichage 2 : false

37
 Les opérateurs logiques(1/3)

Java dispose d‟opérateurs logiques classées par ordre de priorités

décroissantes (il n‟existe pas deux opérateurs de même priorité).

Opérateur Signification
Le résultat
est ! négation
toujours un & et
booléen.
^ ou exclusif
| ou inclusif
&& et(avec cout-circuit)
|| Ou inclusif(avec court-circuit

38
 Les opérateurs logiques (2/3)

(a<b) && (c<d) ou (a<b) & (c<d)

prend la valeur true (vrai) si les deux expressions a<b et c<d sont toutes
les deux vraies (true), la valeur false (faux) dans le cas contraire.
(a<b) || (c<d) ou (a<b) | (c<d)
prend la valeur true si l‟une au moins des deux conditions a<b et c<d
est vraie, la valeur false dans le cas contraire.
(a<b) ^ (c<d)
prend la valeur true si une et une seule des deux conditions a<b et c<d
est vraie, la valeur false dans le cas contraire.
!(a<b)
prend la valeur true si la condition a<b est fausse, la valeur false
dans le cas contraire. Cette expression possède la même valeur que
a>=b.

39
 Les opérateurs logiques (3/3)

Les opérateurs de cout-circuit && et || .

Ces deux opérateurs recèlent une propriété très

importante: leur second opérande (figurant à droite de
l‟opérateur) n‟est évalué qui si la connaissance de sa
valeur est indispensable pour décider si l‟expression
correspondante est vraie ou fausse.

Exemple :
( 15 <10 ) && ( 10 > 4) //on évalue 15 <10 , le résultat
// est faux donc on n‟ évalue pas
// 10 > 4

40
 Opérateurs
d’incrémentation et de décrémentation(1/2)

incrémentation
int i = 10 ; En fait en écrivant :
post incrémentation
int n= i++ ;
i++ ; // cette expression vaut 10 on a :
//mais i vaut 11 n= i ;
int j = 10 ; i = i+1 ;
Et en écrivant :
++j ; // cette expression vaut 11 int p= ++j ;
//et j vaut aussi 11 on a:
j = j+ 1 ;
pré incrémentation
p =j ;

Il existe un opérateur de décrémentation notée - -

41
 Opérateurs
d’incrémentation et de décrémentation(2/2)

Les opérateurs d‟incrémentation et de décrémentation permettent d‟alléger

l‟écriture de certaines expressions et ils n‟appliquent aucune conversion à leur
opérande.
package [Link] ;

public class TestIncrementation {

public static void main(String args [])
{ byte n = 10 ;
int s =n +1 ; // ici on ne peut pas écrire n = n+ 1

[Link]("Affichage 1 :" + ++n); // n reste byte

[Link]("Affichage 2 :"+ s); // n est converti en int
}
} Affichage 1 : 11
Affichage 2 : 11

42
 Opérateurs
d’affectation élargie

int i= 20 ;
i = i + 1 ; // i vaut 21
i += 1 ; //i vaut aussi 21 Leur rôle =
byte b = 2 ; condenser les
expressions.
Pas de conversion.
b *=2 ; // on évalue b * 2 en int
// mais le résultat est
//converti en byte

variable = variable opérateur expression  variable opérateur =

expression
Liste complète des opérateurs d‟ affectation élargie :

+= -= *= /= |= ^= &= <<= >>= >>>=

43
 Opérateur
de cast

On a vu qu‟il n‟était pas possible d‟écrire :

byte b = 10;
b = b + 1 ; //erreur de compilation
// incompatible type for =. Explicit cast
//needed to convert int to short.
Mais on peut faire ceci :
byte b = 10;
b =(byte) (b + 1) ; // OK   b +=1
On force le résultat dans le type byte
(double) 10/3 = (double)(10/3)
ATTENTION
44
 Opérateur
Conditionnel
?:

if(ciel == bleu)
temps ="beau"
else temps =ciel==bleu ?"beau" : " mauvais"
temps=" mauvais"

45
 Priorité des opérateurs (1/2)
(ordre de priorité décroissante)

les parenthèses ()
les opérateurs d'incrémentation ++ -- --

les opérateurs de multiplication, division, et * / %

modulo

les opérateurs d'addition et soustraction + -

les opérateurs de décalage << >>

les opérateurs de comparaison < > <= >=

46
 Priorité des opérateurs (2/2)
(ordre de priorité décroissante)

les opérateurs d'égalité == !=

l'opérateur OU exclusif ^
l'opérateur ET &
l'opérateur OU |

l'opérateur ET logique &&

l'opérateur OU logique ||
les opérateurs d'assignement = += -=

47
 Les mots réservés de Java

abstract default goto null synchronized

boolean do if package this

break double implements private throw

byte else import protected throws

case extends instanceof public transient

catch false int return true

char final interface short try

class finally long static void

continue float native super volatile

const for new switch while

FIN DU MODULE
48
Chapitre 3: Les structures de contrôle

49
 Les structures de contrôles

• Les structures de contrôle classiques

existent en Java :
– if, else
– switch, case, default, break
– for
– while
– do, while

50
Les structures de contrôles : if / else
• Instructions conditionnelles
if (condition)
{ bloc d’instructions}
condition doit être un booléen ou renvoyer une valeur
booléenne
– Effectuer une ou plusieurs instructions si une certaine
condition est vérifiée sinon effectuer d‟autres
instructions
if (condition)
{ 1er bloc d’instructions}
else
{2ème bloc d’instruction}

51
 Les structures de contrôles : if / else

• Exemple de condition
if (age >= 65)
[Link]("Vous êtes une personne âgée.")

[Link]("L'année prochaine vous aurez "+age + 1,

" ans.")

52
Les structures de contrôles : if / else if /
else

• Il est possible d'ajouter plusieurs conditions

successives, et un bloc par défaut (else =
sinon)
if (condition1)
Instructions 1
else if (condition 2)
Instructions 2
else
instructions exécutées si condition1 et condition2 sont
fausses...
53
Les structures de contrôles : if / else if /
else
• Exemple de condition
• Lire dans age
if (age == 0)
[Link]("Vous êtes un nouveau-né́ .")
else if ( age < 18)
[Link]("Vous êtes un enfant.")
else if (age >= 65)
[Link]("Vous êtes une personne
âgée.")
else
[Link]("Vous êtes un adulte.")
print("L'année prochaine vous aurez ", age + 1, " an
54
Les structures de contrôles : if / else if /
else

• Les conditions peuvent être imbriquées

Lire dans age

if (age == 0)
[Link]("Vous êtes un nouveau-né.")
if poids > 10.0 :
[Link]("Je pense qu'il y a une erreur sur
le poids !")

55
 Les structures de contrôles : while
• Boucles indéterminées
– On veut répéter une ou plusieurs instructions un
nombre indéterminés de fois : on répète l‟instruction
ou le bloc d‟instruction tant que une certaine
condition reste vraie
– nous avons en Java une première boucle while (tant
que)
• while (condition) {bloc d’instructions}
• les instructions dans le bloc sont répétées tant
que la condition reste vraie.
• On ne rentre jamais dans la boucle si la condition
est fausse dès le départ
56
Les structures de contrôles : while

• Boucles indéterminées
– un autre type de boucle avec le while:
• do {bloc d’instructions} while (condition)
• les instructions dans le bloc sont répétées
tant que la condition reste vraie.
• On rentre toujours au moins une fois dans
la boucle : la condition est testée en fin de
boucle.

57
 Les structures de contrôles : while
[Link]

import [Link].*;

public class Facto1

{
public static void main(String args[])
{
int n, result,i;
n = [Link]([Link]().readLine("Entrer une valeur pour n:"));
result = 1; i = n;
while (i > 1)
{
result = result * i;
i--;
}
[Link]("la factorielle de "+n+" vaut "+result);
}
}

58
 Les structures de contrôles : for

• Boucles déterminées
– On veut répéter une ou plusieurs instructions un nombre
déterminés de fois : on répète l‟instruction ou le bloc
d‟instructions pour un certain nombre de pas.
– La boucle for
for (int i = 1; i <= 10; i++)
[Link](i); //affichage des nombres de 1 à 10
– une boucle for est en fait équivalente à une boucle while
for (instruction1; expression1; expression2) {bloc}
… est équivalent à …
instruction 1; while (expression1) {bloc; expression2}}

59
 Les structures de contrôles : for
[Link]

import [Link].*;

public class Facto2

{
public static void main(String args[])
{
int n, result,i;
n = [Link]([Link]().readLine("Entrer une valeur pour n:"));
result = 1;
for(i =n; i > 1; i--)
{
result = result * i;
}
[Link]("la factorielle de "+n+" vaut "+result);
}
}

60
Les structures de contrôles : switch

• Sélection multiples
– l‟utilisation de if / else peut s‟avérer lourde quand
on doit traiter plusieurs sélections et de multiples
alternatives
– pour cela existe en Java le switch / case assez
identique à celui de C/C++
– La valeur sur laquelle on teste doit être un char ou
un entier (à l‟exclusion d‟un long).
– L‟exécution des instructions correspondant à une
alternative commence au niveau du case
correspondant et se termine à la rencontre d‟une
instruction break ou arrivée
61 à la fin du switch
 Les structures de contrôles : switch

[Link]

import [Link].*; Variable contenant la valeur

que l‟on veut tester.
public class Alternative
{ Première alternative :
public static void main(String args[]) on affiche Un et on sort
{ du bloc du switch au break;
int nb = [Link]([Link]().readLine("Entrer une valeur pour n:"));
switch(nb)
{ Deuxième alternative :
case 1: on affiche Deux et on sort
[Link]("Un"); break; du bloc du switch au break;
case 2:
[Link]("Deux"); break;
default:
[Link]("Autre nombre"); break; Alternative par défaut:
} on réalise une action
} par défaut.
62
}
 La méthode main(1)

• Premier sous-programme exécuté au

lancement d‟une application.
• Signature:
public static void main(String[] args){
…
}
• Le paramètre est un tableau de chaînes
utilisé pour les arguments transmis à partir
de la ligne de commande.
63
 La méthode main(2)
• Exemple avec arguments:
public class Somme{
public static void main(String[] args){
int x = [Link](args[0]);
int y = [Link](args[1]);
[Link](‟‟la somme de
„‟+x+‟‟ et „‟+y+‟‟ est: „‟+(x+y));
}
}
• Utilisation:
java Somme 12 14
 la somme de 12 et 14 est: 26
64
Concepts généraux de l’OO

65
La POO

66
 Notion de classe

•Une classe est la description d‟une famille d‟objets

ayant même structure et même comportement.

•Elle regroupe un ensemble d‟attributs (données

représentant l‟état de l‟objet) et un ensemble de
méthodes (opérations applicables aux objets).

•Objet = instanciation d‟une classe.

Fraction
+num : int
+den : int
afficher()
 Notion de classe (Exemple1)
• Une classe encapsule, c‟est à dire
regroupe des propriétés et des
comportements.
• Par exemple, la classe Humain définit des
propriétés (deux bras, deux jambes, etc.)
et des comportements (marcher, parler,
voir, etc.)

Classe Humain 68
 Notion de classe (Exemple1)
• Les comportements sont appelés
méthodes et les propriétés variables
d’instance
• Notons que les propriétés des classes
peuvent être elles-mêmes des objets
• Par exemple la propriété bras de notre
exemple peut être un objet de type „Bras‟
• Si nous prenons l‟exemple d‟une voiture,
la classe „Voiture‟ sera l‟ensemble des
plans de la voiture
69
 Notion de Classe (Exemple2)
La classe représente (modélise par abstraction) un ensemble
d‟objets de même nature (partagent propriétés et méthodes)
Exemple : classe Employe
1) Diaw
2) camara Objets représentant des instances de classe
Une classe est décrite par son nom (Employe) par ses
propriétés (matricule, nom, qualification…) et ses opérations
(embaucher()…)
Classe Employe
propriétés: matricule Propriétés avec les types de données
correspondant et la portée (visibilité) à
nom savoir: public privée, protégée…
…
Opérations: embaucher()
promotion()

70
 Notion d‟objet
Un objet se définit par un triplet:
– Un identificateur (OID ou Object Identifier) qui
permet de le référencer de façon unique.
– Des données (attributs) caractérisant l‟objet.
– Et des fonctions (méthodes) agissant sur ces
données. Elles caractérisent son comportement, i.e
l‟ensemble des opérations que l‟objet est à même
de réaliser. Ces opérations permettent de faire
réagir l‟objet aux sollicitations extérieures (ou d‟agir
sur les autres objets.
Objet Propriétés
méthodes

71
 Notion d‟objet (Exemple1)
• Un objet est une instance de classe, i.e un exemplaire
utilisable créé à partir de cette classe et en valorisant
certaines propriétés.
• Par exemple Balla ou Lissa sont des instances de la
classe Humain, i.e des humains ayant des propriétés
spécifiques (Balla est un humain aux yeux noirs et Lissa
aux yeux marrons
• Notons que le concept de classe est abstrait: personne
n‟a jamais vu d‟humain dans la nature alors que le
concept d‟objet est fondalementalement concrêt: il est
concevable de croiser des personnes physiques, i.e des
instances d‟Humain

72
Schematisation

73
 Notion d‟objet (Exemple 2)

• Exemple:
Dans une société X, le cadre Camara qui
est ingénieur au service d‟automatisme
embauché le 06/10/08 perçoit un salaire et
est enregistré sous le matricule 00745/C
est un objet concret (ou physique).
On peut afficher les informations concernant
cet objet.

74
 Notion d‟objet (Exemple2)
L‟ état de cet objet correspondant par exemple à sa date d‟embauche à
l‟instant t0
etat1 etat2
* matricule 00745/C ---
* nom Camara ---
* qualification ingénieur ingénieur chef
* poste de travail automatisme Product Division
* date d‟embauche 06/10/08 ---
* salaire 300000 600000
L‟objet peut avoir des transitions: passer d‟un état à un autre: c‟est le
comportement de l‟objet qui se caractérise par les opérations qu‟il
peut exécuter.
embaucher ()
promotion()
Comportement muter ()
salaire()
afficher()

75
 Notion de référence sur un objet

• Dans les programmes, un objet est une zone mémoire

qui est pointée par une ou plusieurs références
• Une fois l‟objet instancié, il correspond en réalité à une
zone mémoire donnée. Cette zone mémoire, pour être
utilisée doit être référencée
• Par exemple, Balla est une référence sur l‟objet de type
Humain correspondant et vaut l‟adresse mémoire
E515:FB80.
• Instancions l‟objet Lissa: il ya une réservation d‟une
seconde place mémoire référencée (pointée) par la
référence Lissa valant E515:FF90

76
 Notion de référence sur un objet

• Un objet peut posséder plusieurs références: par

exemple, si on fait Lissa=Balla, celà signifie qu‟ils
référencent le même objet, la même zone mémoire
• Dans ce cas, l‟objet Lissa est donc perdu, car il n‟est
plus référencé
• Les références Lissa et Balla désignent maintenant le
même objet
• Dans la suite, nous designerons par abus de langage
une référence sur un objet par le terme „objet‟. Par
exemple, „‟l’objet Lissa de type Humain‟‟ au lieu de „‟la
référence Lissa sur l’objet correspondant de type
Humain‟‟
77
 Définition d‟une classe

Les champs x et y ne sont visibles

La méthode est accessible depuis
n‟importe quel programme. qu‟à l‟intérieur de la classe et non à
l‟extérieur : principe de
l‟encapsulation des données. Les
public class Point données ne seront accessibles
{ que par l‟intermédiaire de méthodes
private int x ; // champ x d‟un objet Point prévues à cet effet.
private int y ; // champ y d‟un objet Point
public void initialise ( int abs, int ord )
{ x = abs ;
y = ord ; Permet d‟attribuer des valeurs initiales
} aux champs de l‟objet.
Une méthode qui ne NB :on verra que c‟est au constructeur
} // fin de la classe
fournit aucun résultat: d‟effectuer ce travail.
 void
78
 Remarques

Une méthode peut être déclarée private : dans ce cas elle n‟est visible qu‟à
l‟intérieur de la classe où elle est définie. Pour pouvoir l‟utiliser dans un
autre programme, il faut nécessairement passer par une méthode publique
de sa classe ayant l‟appelée.

Il est fortement déconseillé de déclarer des champs avec l‟attribut public ,

cela nuit à l‟encapsulation des données.

79
 Créer un objet = instancier une classe

int a = 10 ; // réservation de l‟emplacement mémoire pour une variable de type int

float x ; // réservation de l‟emplacement mémoire pour une variable de type float
Point a ; // cette déclaration ne réserve pas d‟emplacement pour un objet de type
// Point mais simplement une référence à un objet de type Point.
La création d‟un objet (on parle d‟instanciation ) se fait avec l‟opérateur new :
new Point ( ) ; // crée un emplacement pour un objet de type Point et
// fournit sa référence comme résultat
on pourra écrire :
a= new Point ( ) ; // crée un objet de type Point et on met sa reference
//dans // la variable a x
référence ?
? y objet
a
Point
80
 Manipulation d’objets

Une fois qu‟une référence à un objet est convenablement initialisée,

on peut appliquer n‟importe quelle méthode à l‟objet correspondant .

[Link] ( 2,4 ) ; //appelle la méthode initialise du type Point en

// l‟appliquant à l‟objet de référence a, et en lui transmettant
// les arguments 2 et 4
Opérateur d‟accès.

81
 Petit programme de test

class Point01
{ On a deux classes dans le
private int x ; // champ x d‟un objet Point même fichier source. Seule
private int y ; // champ y d‟un objet Point la classe contenant le
public void initialise ( int abs, int ord ) programme principal (main)
{ x = abs ; doit être déclarée avec
y = ord ; l‟attribut public.
}
} // fin de la classe Point01
public class TestPoint01
{ public static void main( String args [ ] )
{ Point01 a = new Point01 ( ) ;
[Link]( 10,12 ) ; // le champ x aura la valeur 10 et y 12
}
} // fin de la classe TestPoint01
82
 Le constructeur (1/3)

En Java, la création d‟objet se fait par allocation dynamique grâce à

l‟opérateur
new qui appelle une méthode particulière : le constructeur.
Dans l‟exemple précèdent, il n‟y avait pas de constructeur mais plutôt c‟était
la méthode initialise qui se chargeait d‟initialiser correctement les champs
d‟un objet de type Point. La démarche proposée suppose que l‟utilisateur fera
appel de cette méthode au moment opportun pour initialiser correctement un
objet.
En fait un constructeur permet d‟automatiser l‟initialisation d‟un objet.

Un constructeur est une méthode qui porte le même nom que le

nom de la classe et qui est sans valeur de retour.
Il peut disposer d‟un nombre quelconque d‟arguments.
83
 Le constructeur (2/3 )

class Point02
{
private int x ; // champ x d‟un objet Point
private int y ; // champ y d‟un objet Point
public Point02 ( int abs, int ord ) // un constructeur à deux
arguments
{ x = abs ;
y = ord ;
}
public void deplace (int dx, int dy )
{ x += dx ; y += dy ;
}
public void affiche( )
{ [Link]("Point de coordonnées" + x + " et " +y);
}
} //fin de la classe Point02 84
 Le constructeur ( 3/3)

public class TestPoint02

{ public static void main( String args [ ] )
{ Point02 a = new Point02 ( 10, 12 ) ; // le champ x aura la valeur 10 et
y 12 [Link]( ) ;
[Link]( 10,12 ) ;
[Link]( ) ; Point de coordonnées : 10 et 12
} // fin de la classe TestPoint02 Point de coordonnées : 20 et 24

85
 Quelques règles sur les constructeurs

Une classe peut disposer de plusieurs constructeurs: ils se différencieront par le nombre
et le type de leurs arguments.

Une classe peut ne pas disposer de constructeur; dans ce cas on peut instancier des
objets comme s‟il existait un constructeur par défaut sans arguments et ne faisant rien.

Mais dès qu‟une classe possède au moins un constructeur, ce constructeur par défaut
ne peut plus être utilisé, dans le dernier exemple on ne pouvait pas faire :
Point a = new Point ( ) ;// incorrect s‟il y‟a un constructeur
Une classe peut disposer d‟un constructeur sans arguments qui est bien différent du
constructeur par défaut (appelé souvent pseudo-constructeur).

Un constructeur peut appeler un autre constructeur de la même classe (A VOIR).

Un constructeur peut être déclaré public ou privé.

86
 Construction d’un objet

La construction et l‟initialisation des champs d‟un objet se font en 3 étapes :

 l‟initialisation par défaut de tous les champs à une valeur "nulle",
 l‟initialisation explicite lors de la déclaration du champ,
 l‟exécution des instructions du constructeur.

public class TestInit

{ private int nombre ;
private int diviseur = 12 ; nombre =24 nombre = 0 nombre = 0
public TestInit( ) { nombre = 24 ;} diviseur =12 diviseur =12 diviseur =0
public float diviser( )
{ return (float) nombre / diviseur ;
}
} Résultat : 2.0
87
 Valeur "nulle" suivant le type
du champ

Type du champ Valeur par défaut

booléen false
char caractère de code nul
entier(byte, short, int, long) 0
flottant( float, double) 0.f ou 0
objet null

Initialisation par défaut des champs d‟un objet

88
 Champ déclaré avec l’attribut
final

public class ChampFinal

{ private final int NOMBRE ;// initialisation différée
private final float MAX ; // initialisation différée
private final int DIVISEUR = 12 ;// valeur fixée à la déclaration
public ChampFinal( int nbre)
{ NOMBRE = nbre ;// la valeur de NOMBRE dépendra de celle de nbre
MAX = 20 ; // la valeur de MAX est fixée à 20 une seule fois.
}
public float diviser( )
{ return (float) NOMBRE / DIVISEUR ;
}
ATTENTION: chaque objet possédera son propre champ NOMBRE,
} malgré que ce dernier est déclaré final.

89
 Affectation et comparaison d’objets

Point a ; 12
10
a = new Point (12,10 ) ;
a
11
Point b = new Point ( 11, 14 ); 14
b
affectation d‟objet 12
a=b; a 10

Sera candidat au 11
ramasse-miettes b
14
s‟il n‟est plus référencé
Désormais a et b désignent le même objet.
 Référence nulle: le mot clé
null

class Point03
{
private int x ; // champ x d‟un objet Point
private int y ; // champ y d‟un objet Point
public Point03 ( int abs, int ord ) // un constructeur à deux arguments
{ x = abs ;
y = ord ;
} Les variables locales de type objet
public Point03 coincide (Point03 p ) doivent toujours être initialisées
{ Point03 t = null ; // t est locale donc nécessite de l‟initialiser
if ((p.x = = this.x) && ( p.y = = this.y )) t = this;
else t = null;
return t ;
}
} //fin de la classe Point03
91
 Comparaison d’objets (1/2):
= = versus equals
public class Point03
{ private int x ; // champ x d‟un objet Point
private int y ; // champ y d‟un objet Point
public Point03 ( int abs, int ord ) // un constructeur à deux arguments
{ x = abs ;
y = ord ;
}
public static void main(String args [ ] )
{
Point03 a = new Point03 ( 1,1 );
Point03 b = new Point03 ( 1,1 );
[Link] ("avec = = : " + a == b);
[Link] ("avec equals :" + [Link] ( b ));
}
} //fin de la classe Point03 Résultat avec = = : false
avec equals : false
92
 Comparaison d’objets (2/2)

== teste s‟il s‟agit du même objet ( pas d‟une copie ).

equals teste l‟égalité de contenu de deux objets .

ATTENTION :
dans l‟exemple précédent la méthode equals dont il s‟agit est celle
de la classe Object (la super classe de toutes les classes en Java).
Souvent, vous serez emmené à redéfinir cette méthode.
Elle a pour en-tête:
public boolean equals (Object o )

L‟opérateur != s‟applique également à des références d‟objet pour tester la différence.

93
 Méthodes de classe

Une méthode d‟une classe ayant un rôle indépendant de toute instance de la classe
doit être déclarée avec le mot clé static et elle ne pourra être appliquée à aucun objet
de cette classe, contrairement aux méthodes d‟instances.
L‟appel de la méthode ne nécessitera que le nom que de la classe.

Une méthode statique ne peut pas agir sur des champs

ATTENTION : usuels, c‟est-à-dire non statiques.

94
 Surdéfinition de méthodes

La surdéfinition de méthodes signifie qu‟un même nom de méthode

peut être utilisé plusieurs fois dans une même classe .
Dans ce cas, le nombre et/ou le type des arguments doit
nécessairement changé.

On peut parler indifféremment de surdéfinition, surcharge ou

overloading (en Anglais).
95
 Exemple de surdéfinition de méthode

public class ExempleSurdefinition {

private int x ;
private int y ;
public ExempleSurdefinition (int abs, int ord ) { x=abs; y=ord; }
public void deplace (int dx, int dy) { x += dx ; y += dy ; }
public void deplace (int dx ) { x += dx ;
}
public void affiche(){ [Link](" Point de coordonnees :"+ x+ " "+y);}
public static void main(String[] args) {
ExempleSurdefinition ex = new ExempleSurdefinition(10,10);
[Link] ( 10 );// appel de deplace ( int )
[Link] ( );
[Link]( 10, 10 );// appel de deplace (int , int )
[Link]( ); Point de coordonnes : 20 10
} Point de coordonnes : 30 20
} 96
 ATTENTION :

Il peut y avoir des cas d‟ambiguïté :

public void deplace (int dx, short dy)
{ x += dx ;
y += dy ;
}
public void deplace (short dy, int dx )
{ x += dx ;
}
avec : ExempleSurdefinition a = new
ExempleSurdefinition( 10, 12) ; short b;
l‟appel [Link]( b ,b) causera une erreur.

97
 Surdéfinition de constructeurs

Les constructeurs peuvent être surdéfinis comme toute autre méthode.

public class Individu {
private String nom;
private String prenom; Attribut de type
private Compte c; objet. Il doit exister
/* constructeur à deux arguments*/ obligatoirement une
public Individu ( String lenom, String leprenom ) { classe Compte.
nom = lenom;
prenom = leprenom;
}
/* constructeur à trois arguments */
public Individu (String lenom, String leprenom, Compte cp) {
nom = lenom;
prenom = leprenom;
c = cp;
} }
 Transfert d’informations
avec les méthodes
En Java, la transmission d‟informations se fait toujours par valeur.
La transmission, par exemple d‟un argument à une méthode ou
d‟une valeur de retour se fait toujours par valeur.

Cette transmission a des conséquences totalement

A RETENIR
différentes, selon que l‟on manipule des types primitifs ou
bien des types objet ( c-à-d des références).

Transmission par valeur : la méthode reçoit une copie de la

RAPPEL valeur de l‟argument effectif sur laquelle elle travaille. Pas de
possibilité d‟agir sur la valeur de l‟argument effectif.
Transmission par référence ( par adresse): la méthode reçoit
l‟adresse de l‟argument effectif sur laquelle elle travaille
directement. Ici, possibilité de modifier donc la valeur de
l‟argument effectif.
 Illustration de la transmission de messages avec
les méthodes (1/2)

public class TransValeurTypePrimitif {

private double res;
public TransValeurTypePrimitif (double n) {
res = n; Argument muet.
2
}
public double add ( double p ) 10
{ p
p contient
return res += p;
4 une copie
}
public static void main(String[] args) { 3 de la valeur
de l‟argument
TransValeurTypePrimitif trans = new TransValeurTypePrimitif (12);
effectif.
[Link] ( [Link] ( 10 ) ); 10
}
1 Argument effectif.
}
 Illustration de la transmission de messages avec
les méthodes (2/2)

public class Point {

private int x;
private int y;
public Point (int abs, int ord) { Référence à un objet de type Point
x = abs; transmise en argument d‟une
y = ord; Méthode.
}
public boolean coincide ( Point p)
p
{
return ( p.x == x && p.y == y); 12
} 12
public static void main (String [ ] args) {
Point a = new Point(10,12); b
Point b = new Point(12,12);
10
[Link]( [Link] ( b ) );
a 12
}} 101
 Autoréférence : this ( ½)

Dans un appel de la forme [Link]( b ), la méthode reçoit une information lui

permettant d‟identifier l‟objet ayant fait l‟appel. Si l‟information est transmise, la
méthode pourra agir sur les champs spécifiques de l‟objet.
Cette transmission est gérée automatiquement par le compilateur.
Mais on peut vouloir agir sur l‟objet globalement au lieu d‟agir sur les champs.
Dans ce cas Java utilise le mot clé this. Dans l‟exemple précédent, on peut
remplacer la méthode coincide par celle-ci:

public boolean coincide ( Point p)

{ // this reference ici l‟objet courant ie celui ayant fait l‟appel de coincide
return ( p.x == this.x && p.y == this.y);
}

Dans un appel [Link] (b) a désigne l‟objet courant.

 Autoréférence : this ( 2/2)

L‟utilisation de this est très pratique dans l‟écriture des méthodes et surtout des
constructeurs.

// noms de champs et noms d‟attributs // noms de champs et noms d‟attributs

//différents //identiques
public Point ( int abs, int ord ) { public Point ( int x, int y ) {
x = abs; this.x = x;
y = ord; this.y = y;
} }

103
 Appel d’un constructeur dans un
autre constructeur. (1/2)
Un constructeur peut appeler un autre constructeur de la même classe en utilisant
le mot clé this. L‟objectif majeur est la simplification du code et aussi pour des
problèmes de sécurité.

public class Individu { Cette classe peut être

private String nom; écrite de façon plus
private String prenom; sophistiquée comme
private Compte c; suit …
public Individu ( String lenom, String leprenom ) {
nom = lenom;
prenom = leprenom;
}
public Individu (String lenom, String leprenom, Compte c1) {
nom = lenom;
prenom = leprenom;
c = c1;
} }
 Appel d’un constructeur dans un
autre constructeur. (2/2)
public class Individu2 {
private String nom;
private String prenom;
private Compte c;
public Individu2 ( String nom, String prenom ) {
[Link] = nom;
[Link] = prenom;
}
public Individu2 (String nom, String prenom, Compte c) {
// appel du constructeur a deux arguments
this (nom, prenom);
this. c = c;
} }
L‟appel this (…) doit nécessairement être la première
ATTENTION : Instruction du constructeur appelant.
 Objet membre

Objet membre = référence à un objet

public class Point { public class Cercle {

private int x; private double r; //rayon du cercle
private int y; private Point p;// objet membre
public Point (int abs, int ord) { public Cercle (double r, int x, int y) {
x = abs; this.r = r ;
y = ord; p = new Point (x, y);
} }
public void affiche ( ) public void affiche ( )
{ {[Link]("Cercle de rayon :" +r);
[Link](" Point :" +x " " +y); [Link](" et de centre:" );
} [Link]());
} }
}
Concepts de POO

107
 Concepts de POO
• Généralement, les données sont plus stables et
pérennes que les traitements qu‟on leur
applique.
• Donc, il est préférable de structurer un système
par rapport à ses données plutôt que par rapport
à ses fonctions.
→ Concept de POO: tout est dirigé par les
données.
• Les concepts principaux de la POO:
 Encapsulation
 Héritage
 polymorphisme

108
 Concepts de POO: Encapsulation (1)
• Mécanisme consistant à empaqueter données et
traitements au sein d‟une même structure en ne
la rendant accessible que par le biais des
opérations (interface) laissées visibles à cet
usage.
• On empêche l‟accès aux données par un autre
moyen que les services proposés.
• Cette structure qui encapsule les données et les
traitements s‟appelle l‟objet.
• L‟encapsulation permet donc de garantir
l‟intégrité des données contenues dans l‟objet.

109
 Concepts de POO: Encapsulation (2)
• Intuition
On ne peut parler de l‟état de l‟employé Camara au
sein de la société X que s‟il est embauché ou plus
précisément à partir du moment où on exécute
l‟opération embaucher. Autrement les données ne
sont accessibles qu‟au travers des méthodes des
opérations. On dit que les données sont cachées
(encapsulées) dans les opérations
L‟encapsulation consiste à rattacher les données et
les méthodes à la classe.
On accède aux opérations par le nom de la classe et
au données par les opérations
classe méthode donnée

110
 Visibilité des champs et méthodes
• Le principe d‟encapsulation permet d‟introduire
celui de protection des attributs et méthodes.
• Les modifications de visibilité en java
– Public: accessible par toutes les classes. Hérité par
les sous classes.
– Private: accessible que par les seules méthodes de
sa classe. Non hérité.
– Protected: accessible par les classes du même
package. Hérité par les sous classes.
– Par défaut: accessible par les classes du même
package. Hérité par les sous classes que si elles se
trouvent dans le même package.
111
 L‟héritage
• L‟héritage permet de définir une nouvelle
classe à partir d‟une (ou plusieurs)
classe(s) existante(s).
• Les classes sont souvent organisées en
hiérarchies; toutes les classes java
héritent de la classe [Link].
• Java n‟autorise que l‟héritage simple.
• L‟héritage multiple est „‟remplacé‟‟ par la
notion d‟interface.
112
L‟héritage simple: Exemple 1

Etudiant
+nom:int
numIns:int
setNumIns
getNumIns()
Afficher()

EtudiantBoursier
+bourse:double

113
 L‟héritage simple:exemple
Public class EtudiantBoursier extends Etudiant{
public double bourse;
public EtudiantBoursier(String nom, double bourse){
super(nom); //appel au constructeur Etudiant(String)
[Link]=bourse;
}
public EtudiantBoursier(String nom){
this(nom,0); //appel au constructeur précédant
}
public void afficher(){ //redéfinition
[Link](„‟etudiant:‟‟+[Link]);
[Link](„‟bourse:‟‟+[Link]);
}
114
}
 Notion d‟héritage (Exemple 2)
• A titre d‟exemple: le cadre Camara et la secrétaire sont tous des employés.
• On peut considérer différentes catégories d‟employés dans notre société X
tel que le cadre possède une propriété: indemnité de suggestion que ne
possède pas la secrétaire
• Inversement la secrétaire peut avoir un prime annuel spécial, mais ils ont
tous des propriétés communes
cadre
Employe

Matricule
Nom
…. Non
Embaucher() cadre

Superclasse sous classe

Chaque sous classe peut avoir des propriétés et des méthodes qui lui sont
propres tout en héritant des propriétés et des méthodes de la superclasse

115
 Notion d‟héritage: Exemple 3

Supposons disposer d‟une classe CompteBancaire:

On se propose de spécialiser la gestion

public class CompteBancaire { des comptes. On crée alors une classe
double solde ; CompteChèque et une autre classe
CompteBancaire (double solde ) CompteEpargne qui dérivent de la classe
{ [Link] = solde; CompteBancaire.
}
void deposer ( double montant)
{ solde +=montant;
}
void retirer (double montant)
{ if (solde >=montant ;
solde -=montant ;
}
} 116
 Notion d‟héritage: Exemple 3

CompteBancaire
champs

solde
deposer ( ) méthodes
dérivation
retirer ()

CompteEpargne
CompteCheque taux
interets
decouvertAutorise
calculInterets( )
changeDecouvert ( )
crediterInterets( )
retirer ( )
changerTaux( ) 117
 Notion d‟héritage: Exemple 3

En Java, on utilise la
public class CompteCheque extends CompteBancaire { mention extends pour
signaler au compilateur
double decouvertAutorise; que la classe
CompteCheque (double solde, double decouvertAutorise) CompteCheque dérive
{ super (solde); de la classe
CompteBancaire.
[Link] = decouvertAutorise;
}
Ici, on rajoute un nouveau
void retirer (double montant) // methode redefinie champ decouvertAutorise.
{ if (solde + decouvertAutorise >=montant ; Et la méthode retirer est
solde -=montant ; redéfinie.
}
//………
} 118
 Notion d‟héritage: Exemple 3

Ici, on rajoute un nouveau

champ taux.
public class CompteEpargne extends CompteBancaire {

double taux;
CompteEpargne (double solde, double taux)
{ super (solde);
this. taux = taux;
}
// pas de methode retirer

//………
}

119
 Accès aux membres {champs et méthodes}
de la classe de base.

Avec l‟instruction :
CompteEpargne ce = new CompteEpargne ( 20000, 0.05) ;
On peut bien faire:
[Link] (10000) ;
malgré que la méthode retirer n‟est pas définie dans la
classe CompteEpargne.

Un objet d‟une classe dérivée accède aux membres publics de

sa classe de base, exactement comme s‟ils étaient dans la classe dérivée
elle-même .

Une méthode d‟une classe dérivée n‟a pas accès aux

membres privés de sa classe de base .
120
 Construction des objets dérivés

La construction d‟un objet dérivé est intégralement prise en compte par le

constructeur de la classe dérivée.

Par exemple, le constructeur de CompteCheque:

- initialise le champ decouvertAutorise (déjà membre de CompteCheque);
- appelle le constructeur de Compte pour initialiser le champ solde (hérité)
dans l‟initialisation de champs d‟un objet dérivé , il est fondamental et très
important de respecter une contrainte majeure:

Si un constructeur d‟une classe dérivée appelle un constructeur d‟une

classe de base, il doit obligatoirement s‟agir de la première instruction
du constructeur et ce dernier est désigné par le mot clé super.
121
 Quelques remarques

Nous avons mentionné précédemment qu‟il est possible d‟appeler dans un

constructeur un autre constructeur de la même classe, en utilisant le mot clé

this comme nom de méthode . Comme celui effectué par super, cet appel
doit correspondre à la première instruction du constructeur .
Dans ces conditions, on voit bien qu‟il n‟est pas possible d‟exploiter les deux
possibilités en même temps . Autrement dit, dans un constructeur d‟une
Classe dérivée il n‟est pas possible d‟appeler en même temps un
constructeur de la même classe et un constructeur d‟une classe de base.
L‟appel par super ne concerne que le constructeur de la classe de base de niveau
immédiatement supérieur (vu qu‟1 classe peut dériver d‟une classe qui aussi dérive
d‟1autre). 122
 Redéfinition de membres (1/4)

class CompteBancaire { class CompteCheque extends CompteBancaire {

double solde ;
// ……… double decouvertAutorise;
// methode redefinie
void retirer (double montant)
void retirer (double montant)
{ if (solde >=montant ;
solde -=montant ; { if (solde + decouvertAutorise >=montant ;
} solde -=montant ;
void imprimeHistorique( ) }
{ [Link] (" solde =" void imprimeHistoriqueCheque( )
+solde ); { [Link] (" solde =" +solde + " " +
} "decouvertAutorise=" +decouvertAutorise);
}
} 123
 Redéfinition de membres (2/4)

Avec :
CompteBancaire cb; CompteCheque cc;
l‟appel : [Link] ( 20000);
appelle la méthode retirer de CompteBancaire.
l‟appel : [Link] ( 20000);
appelle la méthode retirer de CompteCheque.
On se base tout simplement sur le type de l‟objet pour déterminer la classe
de la méthode appelée.
Pour bien voir l‟intérêt de la redéfinition des méthodes, examinons la méthode
imprimeHistorique de la classe CompteBancaire qui permet d‟afficher le solde pour
un compte et la méthode imprimeHistoriqueCheque de la classe CompteCheque qui
affiche non seulement le solde (qui est un membre hérité) mais aussi le
decouvertAutorise.
Dans cette dernière, il y a une information qui est déjà prise en compte dans la
méthode imprimeHistorique. La situation précédente peut être améliorée de
cette façon: 124
 Redéfinition de membres (3/4)

class CompteBancaire { class CompteCheque extends CompteBancaire {

double solde ;
// ……… double decouvertAutorise;
// methode redefinie
void retirer (double montant)
void retirer (double montant)
{ if (solde >=montant ; { if (solde + decouvertAutorise >=montant ;
solde -=montant ; solde -=montant ;
} }
void imprimeHistorique( ) void imprimeHistoriqueCheque( )
{ [Link] (" solde =" {
+solde ); imprimeHistorique( );
} [Link] (" et le decouvertAutorise ="
+decouvertAutorise);
} 125
}
 Redéfinition de membres (4/4)

class CompteBancaire { class CompteCheque extends CompteBancaire {

double solde ;
// ……… double decouvertAutorise;
// methode redefinie
void retirer (double montant)
void retirer (double montant)
{ if (solde >=montant ; { if (solde + decouvertAutorise >=montant ;
solde -=montant ; solde -=montant ;
} }
void imprimeHistorique( ) void imprimeHistorique( )
{
{ [Link] (" solde =" [Link]( );
+solde ); [Link] (" et le decouvertAutorise ="
} +decouvertAutorise);
} 126
super obligatoire.
}
 Redéfinition et dérivation successive

A* f est redéfinie
ici.

f est redéfinie C*
B
ici.

*
D E F

L‟appel de f conduira, pour chaque classe, à l‟appel de la méthode indiquée en regard :

class A : méthode f de A class D: méthode f de D
class B: méthode f de A class E: méthode f de A
class C: méthode f de C class F: méthode f de C 127
 Surdéfinition et héritage

Calcul c; CalculXXX cx;

int n; float p;
class Calcul {
public double division ( int a) // 1 [Link] (n); // appel de 1
{ // instructions
} [Link] (p); // erreur de compilation
}
[Link] (n); // appel de 1
class CalculXXX extends Calcul {
public float division ( float a) // 2 [Link] (p); // appel de 2

{ // instructions La recherche d‟une méthode acceptable ne se

} fait qu‟en remontant la hiérarchie d‟héritage,
} jamais en la descendant. C‟est pourquoi l‟appel
[Link] (p); ne peut être satisfait.
 Contraintes sur la redéfinition (1/2)

En cas de redéfinition, Java impose seulement l‟identité des signatures

mais aussi du type de la valeur de retour

Valeurs de retour identiques Signatures identiques

class CompteBancaire { class CompteCheque extends CompteBancaire {

double solde ; double decouvertAutorise;
// ……… // methode redefinie
void retirer (double montant)
void retirer (double montant)
{ if (solde >=montant ; { if (solde + decouvertAutorise >=montant ;
solde -=montant ; solde -=montant ;
}} } 129
}
 Contraintes sur la redéfinition (2/2)

La redéfinition d‟une méthode ne doit pas diminuer les droits d‟accès

à cette méthode.
Par contre, elle peut les augmenter.

class A class A
{ public void f ( int n){……} { private void f ( int n){……}
} }
class B extends A class B extends A
{// impossible de mettre private {// augmente les droits d acces:
private void f ( int n) {….} possible
} public void f ( int n) {….}
}
 Duplication de champs

class A
{ public int resultat;
class B extends A
{ /* le champ resultat est duplique */
// instructions
public int resultat ;
}
float calcul( int n)
{ return resultat + [Link] +n;
}
}

On utilise le mot clé super

pour accéder à un champ de la super classe
131
 Le Polymorphisme

Surclassement
La réutilisation de code est un aspect important de l‟héritage, mais ce n‟est peut
être pas le plus important.
Un autre aspect fondamental est la relation qui relie une classe à sa super
classe.

Une classe B qui hérite d‟une classe A peut être vue comme un sous-type (sous -
ensemble) du type défini par la classe A.
CompteBancaire
Un CompteCheque est un CompteBancaire

L‟ensemble des compte chèque est inclus

CompteCheque dans l‟ensemble des compte bancaires
132
 Surclassement
Tout objet instance de la classe B peut être aussi vu comme une instance de la classe A.

Cette relation est directement supportée par le langage JAVA.

« à une référence déclarée de type A, il est possible d‟affecter une valeur qui
est une référence vers un objet de type B (surclassement ou upcasting) »

CompteBancaire CompteBancaire cb;

cb = new CompteCheque( 100000, 50000 );
« plus généralement, à une référence d‟un type donné,
CompteCheque il est possible d‟affecter une valeur qui correspond à une
référence vers un objet dont le type effectif est n‟importe
quelle sous-classe directe ou indirecte du type de la
référence ».
 Surclassement

Lorsqu‟un objet est « sur-classé » il est vu comme un objet du type de la référence

utilisée pour le désigner.
« ses fonctionnalités sont alors restreintes à celles proposées par la classe du type
de la référence ».
CompteCheque cc = new CompteCheque(100,50);
CompteBancaire CompteBancaire cb;
solde cb = cc; // surclassement
deposer ( ) [Link] (50);
retirer () [Link]( 25);

[Link] (500);
CompteCheque [Link] ( 250);
decouvertAutorise [Link] ( );
changeDecouvert ( )
retirer ( ) [Link]( ); 134
 Liaison dynamique

Résolution des messages

« Que va donner [Link] ( 50) ? »

CompteBancaire
CompteBancaire cb = new
void retirer (double montant)
CompteCheque (500,100);
{ if (solde >=montant )
solde -=montant ;
? }
[Link] ( 50)
? CompteCheque
void retirer (double montant)
{if (solde + decouvertAutorise >=montant )
solde -=montant ;

} 135
 Liaison dynamique

Résolution des messages

CompteBancaire
CompteBancaire cb = new
void retirer (double montant)
CompteCheque (500,100);
{ if (solde >=montant ;
solde -=montant ;
? }
[Link] ( 50)
CompteCheque
void retirer (double montant)
{if (solde + decouvertAutorise >=montant ;
solde -=montant ;

} 136
 Liaison dynamique

Résolution des messages

VRAIMENT A RETENIR

Lorsqu‟une méthode d‟un objet est accédée au

travers d‟une référence « surclassée », c‟est la
méthode telle qu‟elle est définie au niveau de la
classe effective de l‟objet qui est réellement
invoquée et donc exécutée.

137
 La super classe Object

En Java, toute classe dérive implicitement de la classe Object.

Elle est donc la classe de base de toute classe.

Une déclaration comme celle-ci :

class Point { …}
est équivalente à:
class Point extends Object { …}

Quelles en sont les conséquences ?

138
 Classes abstraites

Une classe abstraite ne peut instancier aucun objet.

Une telle classe ne peut servir qu’à une dérivation (héritage).
Dans une classe abstraite, on peut trouver :
- des méthodes et des champs, dont héritera toute classe dérivée.
- des méthodes abstraites,(avec signature et type de valeur de retour).
Le recours aux classes abstraites facilite largement la Conception Orientée Objet.
En effet, on peut placer dans une classe abstraite toutes les fonctionnalités dont on
souhaite disposer pour toutes ses descendantes :
- soit sous forme d’une implémentation complète de méthodes(non abstraites) et
de champs(privés ou non) lorsqu’ils sont communs à toutes ses descendantes ,
- soit sous forme d’interface de méthodes abstraites dont on est alors sûr qu’elles
existent dans toute classe dérivée instanciable.
139
 Généralités

On définit une classe abstraite en Java en utilisant le mot clé abstract

devant le nom de la classe:

abstract class Forme {

// champs usuels et constantes
// méthodes définies ou méthodes non définies
// MAIS AU MOINS UNE METHODE NON DEFINIE
}

Avec cette classe:

- on peut écrire : Forme f ;// declaration d’une reference de type forme
- par contre on ne peut écrire : f = new Forme ( );// INTERDIT

140
 Généralités

Maintenant si on se retrouve dans la situation suivante:

class Rectangle extends Forme

{
// ici on redefinit TOUTES les méthodes héritiées de
// Forme

}
Alors on peut instancier un objet de type Rectangle et placer sa
référence dans une variable de type Forme (polymorphisme):

Forme f = new Rectangle ( );// OK car polymorphisme

141
 Exemple

abstract class Forme

{ public abstract double perimetre( ) ; }// fin de Forme
class Circle extends Forme {private double r; //…constructeur à definir
public double perimetre ( ) { return 2 * [Link] * r ; }
}//fin de Circle
class Rectangle extends Forme { private double long, larg; //constructeur à définir
public double perimetre( ) { return 2 * (long + larg); }
}//fin de Rectangle
/* dans le main d une classe de test */
Forme [ ] formes = {new Circle(2), new Rectangle(2,3), new Circle(5)};
double somme_des_perimetres = 0;
for ( int i=0; i< [Link]; i++)
somme_des_perimetres += formes[i].perimetre ( );
142
 Quelques remarques importantes

- Une classe abstraite est une classe ayant au moins une méthode abstraite.
- Une méthode abstraite ne possède pas de définition.
- Une classe abstraite ne peut pas être instanciée (new).
- Une classe dérivée d'une classe abstraite ne redéfinissant pas toutes les méthodes
abstraites est elle-même abstraite.
- Une méthode abstraite ne doit pas être déclarée final, puisque sa vocation
est d’être redéfinie. De même une classe abstraite ne doit pas être final.
- Une méthode abstraite ne doit jamais pas déclarée private.
- Une méthode abstraite ne doit jamais pas être déclarée static.

143
 Les interfaces(1)
• Ce sont des classes abstraites dont l‟instanciation serait
sans intérêt. Elles ne peuvent donc être instanciées.
• Elles peuvent hériter d‟autres interfaces(héritage
simple).
• Elles ne peuvent contenir que des attributs statiques
constants (static final) et des méthodes publiques non
implémentées.
• Elles doivent être implémentées par une ou plusieurs
classes.
• Une classe peut implémenter une ou plusieurs
interfaces.
• Lorsqu‟une classe implémente une interface, elle doit
implémenter toutes les méthodes définies dans
l‟interface

144
 Les interfaces(2)
public interface FormeGeometrique{
public double perimetre();
public double surface();
}
public class Rectangle implements FormeGeometrique{
public double larg, long;
public Rectangle(double long, double larg){
[Link]=long; [Link]=larg;
}
public double perimetre(){ return 2*(larg+long);}
public double surface() {return larg*long;}
}

145
 Les interfaces(3)
public class Carre implements FormeGeometrique {
public double cote;
public Carre(double cote){[Link]=cote;}
public double perimetre(){return 4*cote;}
public double surface(){return cote*cote;}
}
public class Cercle implements FormeGeometrique{
public final static double PI=3.1416;
public double rayon;
public Cercle(double rayon){[Link]=rayon;}
public double perimetre() {return 2*PI*rayon;}
public double surface() {return PI*rayon*rayon;}
public void afficher() {
[Link](„‟cercle de rayon‟‟+rayon);}
}
146
 Les interfaces(4)
Exemple d‟utilisation:
public class Figures {
public static void main(String[]args) {
FormeGeometrque[]formes;
formes=new FormeGeometrque[3];
formes[0]=new Cercle(10);
formes[1]=new Carre(4);
formes[2]=new Rectangle(5,8);
for(int i=0;i<[Link];i++){
[Link](„‟surface de la
forme‟‟+i+‟‟:‟‟);
[Link](formes[i].surface());
}
}
}
147
 Diverses situations avec les interfaces
Le fait de pouvoir
implémenter plusieurs
On dispose de deux interfaces : interfaces peut résoudre le problème
de la dérivation multiple
interface I1 {…} connue dans les autres
langages objets comme
interface I2 {…} (C++)

Vous pouvez avoir:

interface I3 extends I1 { …..} //derivation dune interface

class A implements I2 { …}//implementer une seule interface

class B implements I1, I2, I3 { ….} //implementer plusieurs interfaces

class C extends A implements I3 {….} // derivation d une classe et

// implementation d une interface148
Les packages

149
 Les packages (1)

• Un package est un ensemble de classes et d'autres

packages regroupés sous un nom.
• C'est l'adaptation du concept de librairie ou de
bibliothèque.

• Lors de la définition d'un fichier source Java, on peut

préciser son appartenance à un package en utilisant le
mot-clé package:
package mon_package;

• Toutes les classes définies dans ce fichier font ainsi

partie du package mon_package.
exemple: package formesGeo;
150
 Les packages (2)

• Pour pouvoir utiliser une classe d'un package dans un

autre fichier, il faut l'importer:
import nom_du_package.nom_classe;

• On peut importer toutes les classes d'un package en

même temps:
import nom_du_package.*;
import [Link].*;

• Le package [Link] qui gère les types de données et

les éléments de base du langage est automatiquement
importé. 151
 Les packages prédéfinis (1)

•Les API Java sont organisées en deux parties :

• Java Core API : API de base implantée dans tout

interpréteur Java. Ces classes appartiennent au package
“java”.

• Java Standard Extension API : extensions normalisées

par Sun au travers d‟interfaces et implantées par les
éditeurs.
Ces classes appartiennent au package “javax”.

•Documentation sur les toutes classes Java disponible sur le

152
site officiel de Java : [Link]
 Les packages prédéfinis (2)

Les classes sont regroupées par thèmes dans des packages :

• [Link] : types de données et éléments de base du langage

(classes Object, String, Boolean, Integer, Float, Math, System
(fonctions système), Runtime (mémoire, processus), etc.)
• [Link]: structures de données et utilitaires (Dates, Collections,
etc.)
• [Link]: bibliothèque des entrées / sorties, fichiers.
• [Link]: bibliothèque réseau
• [Link]: librairie graphique
• [Link]: librairie des applets.
• [Link]: sécurité (contrôle d‟accès, etc.)
• [Link]: applications distribuées.
• [Link]: accèes aux BD (JDBC) 153
 Les packages: exécution

• Pour compiler une classe contenant l‟instruction

suivante, il faut indiquer le chemin au
compilateur.
import [Link]
• Soit : Option –classpath de javac
javac –classpath chemin_du_fichier
[Link] MaClass
• Soit : Variable d’environnement CLASSPATH
doit contenir le chemin d‟accès au répertoire
racine du package.
154
 Les packages:exécution

Pour exécuter la commande java

[Link]:
• Soit : se placer dans le répertoire
contenant le répertoire monPackage
• Soit : Utiliser l‟option –classpath de la
commande java
• Soit : Variable d’environnement
CLASSPATH
doit contenir le chemin d‟accès au
répertoire monPackage 155
Les tableaux

156
 Les tableaux (1)
• Les tableaux permettent de stocker plusieurs valeurs de
même type dans une variable.
– Les valeurs contenues dans la variable sont repérées
par un indice
– En langage java, les tableaux sont des objets
• Déclaration
– int tab [ ];
String chaines[ ];
• Création d'un tableau
• b = new int [20]; // tableau de 20 int
• chaines = new String [100]; // tableau de 100 chaines
157
 Les tableaux (2)
• Le nombre d'éléments du tableau est
mémorisé. Java peut ainsi détecter à
l'exécution le dépassement d'indice et
générer une exception. Mot clé length
– Il est récupérable par [Link]
int taille = [Link]; //taille vaut 20
• Comme en C/C++, les indices d‟un
tableau commencent à „ 0 ‟. Donc un
tableau de taille 100 aura ses indices qui
iront de 0 à 99. 158
 Les tableaux (3)

• Initialisation
tab[0]=1;
tab[1]=2; //etc.
noms[0] = new String( "Boule");
noms[1] = new String( "Bill");//etc
• Création et initialisation simultanées
String noms [ ] = {"Boule","Bill"};
Point pts[ ] = { new Point (0, 0), new Point (10, -
1)}; 159
 Les tableaux (4)
[Link]
public class Tab1
{
public static void main (String args[])
{
Pour déclarer une variable tableau
int tab[ ] ;
on indique le type des éléments du
tab = new int[4];
tableau et le nom de la variable tableau
tab[0]=5;
suivi de [ ]
tab[1]=3;
tab[2]=7;
tab[3]=tab[0]+tab[1]; on utilise new <type> [taille];
} pour initialiser le tableau
}
On peut ensuite affecter
des valeurs au différentes
Les indices vont toujours cases du tableau :
de 0 à (taille-1) <nom_tableau>[indice]
160
 Les tableaux (5)
[Link] Mémoire
public class Tab1
{
public static void main (String args[])
{
int tab[ ] ; 0x0000
0x258
tab = new int[4];
tab[0]=5; 0
tab[1]=3; 0
tab[2]=7; 0
tab[3]=tab[0]+tab[1]; 0
}
}

161
 Les tableaux (6)
[Link]
Mémoire
public class Tab1
{
public static void main (String args[])
{ 0x258
int tab[ ] ;
tab = new int[4];
tab[0]=5; 5
0
tab[1]=3; 0
3
tab[2]=7; 0
7
tab[3]=tab[0]+tab[1]; 0
8
}
}

162
 Les tableaux (7)
[Link] Mémoire
public class Tab2
{
0x0258
public static void main (String args[])
{
String tab[ ] ; 0x0106
tab = new String[4]; 0x0116
tab[0]=new String("Pierre"); 0x0126
tab[1]=new String("Paul"); 0x0136
tab[2]=new String("Jacques");
tab[3]=new String("Philippe");
}
"Pierre"
}
"Paul"
"Jacques"
"Philippe"

163
 Tableaux à deux dimensions

Déclaration

Pour déclarer un tableau à deux dimensions, on peut utiliser l‟une de ces

Trois déclarations qui sont équivalentes :
int t [ ] [ ] ; // tableau d‟entiers à deux dimensions
int [ ] t [ ] ; //idem
int [ ] [ ]t ; //idem
Elles déclarent que t est une référence à un tableau, dans lequel chaque
élément est lui-même une référence à un tableau d‟entiers .
Pour l‟instant, aucun tableau de cette sorte n‟existe encore .

164
 Tableaux à deux dimensions

Création

Considérons l‟instruction :
int [ ] [ ] t = { new int [3], new int[2] } ;
L‟initialiseur de t comporte deux éléments dont l‟évaluation crée un tableau de 3 entiers
et un tableau de 2 entiers . On aboutit à cette situation (les éléments des tableaux sont
comme d‟habitude, initialisés à 0) :

0
0
0
0
t 0 165
 Tableaux à deux dimensions

Dans ces conditions, on voit que :

la notation t [0] désigne la référence au premier tableau de 3 entiers

 la notation t[0][1] désigne le deuxième élément de ce tableau
 la notation t[1] désigne la référence au second tableau de 2 entiers
 la notation t[1][i-1] désigne le ième élément de ce tableau .
 l‟expression [Link] vaut 2
 l‟expression t[0].length vaut 2
 l‟expression t[1].length vaut 3

166
 Tableaux à deux dimensions

Second exemple :
On peut aboutir à une situation très proche de la précédente en procédant
ainsi : Int t [ ][ ] ;
t = new int [2][ 3] ; // creation d‟un tableau de deux tableaux d‟entiers
int [ ] t1 = new int [3] ; // t1 = reference à un tableau de 3 entiers
int [ ] t2 = new int [2] ; // t2 = reference à un tableau de 2 entiers
t[0] = t1 ; t[1] = t2 ; // on range ces deux references dans t
La situation peut être illustrée ainsi :
t1 0
0
0
t
t2 0
167
0
 Matrices

• Instanciation
TypeDesElements[ ] NomDuTableau =
new TypeDesElements[TailleDuTableau];
Exemple
int[ ] Tab_entiers = new int[15];
String[ ] Chaines = new String[3];

• Matrices
TypeDesElements[ ][ ] NomDuTableau;
TypeDesElements NomDuTableau[ ][ ];
Exemple
int [ ][ ] matrice
ou int matrice [ ][ ];
 Saisie tableau

Exemple de saisie d‟un tableau:

public static void main(String[] args) {

int[] t = new int[5];

BufferedReader e = new BufferedReader

(new InputStreamReader([Link]));

for (int i=0; i<5; i++)

t[i] = [Link]([Link]());
}
 Les chaînes de caractères: La
classe String (1)
• En Java, les chaînes de caractères sont gérées à
l‟aide de la classe String fournie en standard dans le
paquetage [Link].
• la chaîne de caractères d‟un objet de type String ne
peut pas être modifié
• En cas de modification, les méthodes fournissent un
nouvel objet à partir de la chaîne de l‟objet courant et
répondant aux caractéristiques de la méthode
• Une même chaîne de caractères (String) peut être
référencée plusieurs fois puisqu‟on est sûr qu‟elle ne
peut pas être modifiée.
• La classe StringBuffer par contre permet la création
et la modification d‟une chaîne de caractères.
170
 Les chaînes de caractères: La
classe String (2)
• Constructeurs:
– String () : crée une chaîne vide
– String (String) : crée une chaîne à partir d‟une
autre chaîne
– String (StringBuffer) : crée une chaîne à partir
d‟une autre chaîne de type String-Buffer
• Remarque : String s = "Monsieur" ; est
accepté par le compilateur et est équivalent à
String s = new String ("Monsieur") ;
171
 Les chaînes de caractères: La
classe String (3)
Quelques méthodes:
• char charAt (int n) : fournit le caractère à la position n de la chaîne de l‟objet
courant.
• int compareTo (String s) : compare la chaîne de l‟objet et la chaîne s ; fournit 0
si =, <0 si inférieur, > 0 sinon.
• String concat (String s) : concatène la chaîne de l‟objet et la chaîne s (crée un
nouvel objet).
• boolean equals (Object s) : compare la chaîne de l‟objet et la chaîne s.
• boolean equalsIgnoreCase (String s) : compare la chaîne de l‟objet et la chaîne s
(sans tenir compte de la casse).
• int length () : longueur de la chaîne.
• String toLowerCase () : fournit une nouvelle chaîne (nouvel objet) convertie en
minuscules.
• String toUpperCase () : fournit une nouvelle chaîne (nouvel objet) convertie en
majuscules.

172
Les méthodes indexOf() fournissent l‟indice dans la chaîne de
l‟objet courant d‟un caractère ou d‟une sous-chaîne en partant
du premier caractère (par défaut) ou d‟un indice donné. Les
méthodes lastIndex() fournissent l‟indice du dernier caractère
ou de la dernière sous-chaîne recherchés dans la chaîne de
l‟objet référencé.
•int indexOf (char c) : indice du caractère c dans la chaîne ; -1
s‟il n‟existe pas.
•int indexOf (char, int) : indice d‟un caractère de la chaîne en
partant d‟un indice donné.
•int indexOf (String s) : indice de la sous-chaîne s.
•int indexOf (String, int) : indice de la sous-chaîne en partant
d‟un indice.
•int lastIndexOf (char c) : indice du dernier caractère c.
•int lastIndexOf (char, int) : indice du dernier caractère en
partant de la fin et d‟un indice.
•int lastIndexOf (String) : indice de la dernière sous-chaîne.
•int lastIndexOf (String, int) : indice de la dernière sous-chaîne
en partant d‟un indice.
173
• String replace (char c1, char c2) : crée une nouvelle
chaîne en remplaçant le caractère c1 par c2.
• boolean startsWith (String s) : teste si la chaîne de
l‟objet commence par s.
• boolean startsWith (String s, int n) : teste si la
chaîne de l‟objet commence par s en partant de
l‟indice n.
• boolean endsWith (String s) : teste si la chaîne de
l‟objet se termine par s.
• String substring (int d) : fournit la sous-chaîne de
l‟objet commençant à l‟indice d.
• String substring (int d, int f) : fournit la sous-chaîne
de l‟objet entre les indices d (inclus) et f (exclu).
• String trim () : enlève les espaces en début et fin de
chaîne.

174
 Les chaînes de caractères: La
classe String (4)
• La classe String possède une méthode statique valueOf
surdéfinie avec un argument de chaque type primitif qui
permet de convertir n‟importe quel type primitif en chaîne de
caractères.
int n = 541;
double d = 120.56;
String intCh = [Link] ( n); //intCh contient la chaine "
541"
String doubleCh = [Link] ( d); //doubleCh contient la
chaine " 120.56 "
L‟écriture intCh = [Link] ( n); est équivalent à celle-ci:
intCh = " " +n;//on utilise une chaine vide pour
recourir à
// l‟ operateur + qui convertit n en String

175
 Conversions chaînes et types
primitifs
Il est possible de convertir une chaine dans un type primitif en
recourant aux classes enveloppes définies pour chaque type primitif.

String ch = " 3521 " ;

int n = [Link] (ch);// n contient la valeur entiere 3521
On dispose aussi des méthodes:

[Link]
[Link]
[Link]
[Link]
[Link]
[Link]

176
 La classe StringBuffer
• Un objet de type StringBuffer représente une chaîne de caractères modifiable.
• On peut construire un objet de type StringBuffer contenant 0 caractère avec une
capacité par défaut de 16 ou définie à l‟aide d‟un paramètre entier.
• On peut aussi construire un objet de type StringBuffer à partir d‟un objet de type
String
• Les principales méthodes sont présentées succinctement ci-après.
– StringBuffer () : construit un tampon ayant 0 caractère mais d‟une capacité de
16 caractères.
– StringBuffer (int n) : construit un tampon de capacité n caractères.
– StringBuffer (String) : construit un objet de type StringBuffer à partir d‟un objet
de type String.
/*pour optimiser la creation precedente de la chaine "note 01234 " */
String ch = "note";
StringBuffer sb = new StringBuffer (ch) ;// on transmit ici un objet String
for ( int i =0; i < 5;i++)
[Link] (i); //on rajoute a la fin du StringBuffer vide
ch = [Link] ( ); // on convertit le StringBuffer en String
[Link] (ch);

177
 La classe StringBuffer
• Les méthodes de type StringBuffer append () concatènent
au tampon de l’objet courant la représentation sous forme
de caractères de leur argument (boolean, int, etc.).
• StringBuffer append (boolean);
• StringBuffer append (char);
• Les méthodes de type StringBuffer insert () insèrent dans
le tampon de l’objet, à partir de l‟indice du paramètre 1, la
représentation sous forme de caractères de leur argument.
– StringBuffer insert (int, boolean) ;
– StringBuffer insert (int, char) ;
– StringBuffer insert (int, char[]) ;
– StringBuffer insert (int, double) ;

178
 La classe StringBuffer
• D‟autres méthodes fournissent la capacité de l‟objet de type StringBuffer, l‟accès à un
caractère à partir de son indice, la longueur de la chaîne, la chaîne inverse, ou l‟objet
de type String équivalent.
– int capacity () : fournit la capacité de cet objet (nombre maximum de
caractères)
– char charAt (int n) : fournit le caractère d‟indice n ;
– int length () : fournit la longueur (nombre de caractères) ;
– StringBuffer reverse () : inverse les caractères de l‟objet (gauche-droite devient
droite-gauche) ;
– String toString () : convertit en un objet de type String ;
– ensureCapacity (int n) : la capacité de l‟objet est au moins n sinon un nouveau
tampon est alloué ;
– void setCharAt (int index, char ch) : le caractère index reçoit ch (0 <= index <
longueur).

179
 La classe StringTokenizer

• Cette classe n‟ a aucun lien direct avec la classe String, elle se

trouve d‟ailleurs dans le paquetage [Link] . Elle apporte un rôle
dans la manipulation des chaînes en facilitant la division de chaînes
en sous- chaînes selon un nombre de « délimiteurs ».
• Cette méthode divise une chaîne en différents éléments
appelés tokens.
String s = "Java est un langage interessant";
StringTokenizer st = new StringTokenizer (s, " " );
while ([Link] ( ))//tant qu‟il y a des tokens
{ [Link]( ) ; // renvoie le premier element et se positionne sur le
suivant
// cette méthode renvoie un objet String.
}

180
On trouve 5 tockens : Java est un langage interessant
EXCEPTIONS

181
 Les exceptions
• Une exception est une erreur se produisant dans un
programme qui conduit le plus souvent à l'arrêt de
celui-ci.
• Il vous est sûrement déjà arrivé d'obtenir un gros
message en rouge dans la console: cela a été généré
par une exception qui n'a pas été capturée.
• Le fait de gérer les exceptions s'appelle aussi la
capture d'exception
• Le principe consiste:
– à repérer un morceau de code (par exemple, une division
par zéro) qui pourrait générer une exception
– de capturer l'exception correspondante
– de traiter celle-ci, c'est-à-dire d'afficher un message
personnalisé
– et de continuer l'exécution.
 Hiérarchie des exceptions
• Principe : Toutes les exceptions en Java
héritent de la classe Throwable.
Throwable

Error Exception

IOException RuntimeException

IndexOutOfBoundsException ArtithmeticException

FileNotFoundException IllegalArgumentException

NumberFormatException
 Hiérarchie des exceptions
• Les exceptions sont des instances de
sous classes des classes
– [Link] (pour les erreurs graves qui
devront généralement conduire à l‟arrêt du
programme)
– [Link] (pour des événements
inattendus, qui seront souvent traités de sorte
qu‟elle ne provoque pas l‟arrêt du programme.
 Les exceptions

• Java contient une classe nommée Exception dans

laquelle sont répertoriés différents cas d'erreurs
• La division par zéro dont je vous parlais plus haut
en fait partie
int j = 20, i = 0;
[Link](j/i);
[Link]("coucou toi !");
• Vous verrez apparaître un message d'erreur Java
(en rouge) comme celui:
Exception in thread “main”
[Link]: / by zero at
[Link] ([Link]:IO)
 Les exceptions

• lorsque l'exception a été levée, le

programme s'est arrêté
• le nom de l'exception qui a été déclenchée
est ArithmeticException.
• Nous allons pouvoir la capturer, avec un
bloc try{...}catch{...}, puis réaliser un
traitement en conséquence.
 Les exceptions

• Un bloc d'instructions try permet de regrouper une ou plusieurs

instructions de programme (appel de méthode, instructions de
contrôle, etc.) où des exceptions peuvent se produire et être traitées.

• Un bloc try est suivi d'instructions catch et finally.

• catch spécifie le traitement associé aux exceptions, i.e ce que l'on

fait si une exception se produit (afficher un message d'erreur par
exemple).

• finally est exécuté inconditionnellement, quelque soit la façon dont

on sort du bloc try (pour fermer par exemple un fichier ouvert dans le
bloc try).
 Les exceptions

try {
// bloc d'instructions à protéger
}

catch ( Exception e) {
// traitement de l'exception
}

finally {
// à exécuter quelque soit la façon dont on sort du try
}
 Les exceptions

• Reécriture de la classe Test

public static void main(String[] args) {
int j = 20, i = 0;
try {
[Link](j/i);
} catch (ArithmeticException e) {
[Link]("Division par zéro !");
}
[Link]("coucou toi !");
}
 Les exceptions
• Nous isolons le code susceptible de lever une exception :
[Link](j/i);
• Une exception de type ArithmeticException est levée lorsque
le programme atteint cette ligne.
• Notre bloc catch contient justement un objet de type
ArithmeticException en paramètre. Nous l'avons appelé e.
• L'exception étant capturée, l'instruction du bloc catch
s'exécute !
• Notre message d'erreur personnalisé s'ache alors à l'écran.
l'objet ici, e peut servir à préciser notre message grâce à
l'appel de la méthode getMessage(). Faites à nouveau ce
test, en remplaçant l'instruction du catch par celle-ci :
[Link]("Division par zéro !" + [Link]());
• la fonction getMessage() de notre objet ArithmeticException
nous précise la nature de l'erreur.
 Les exceptions personnalisées

• Mise en oeuvre d‟une exception permettant

d'interdire l'instanciation d'un objet Ville ou
Capitale présentant un nombre négatif
d'habitants.
• En effet, nous devons :
– créer une classe héritant de la classe Exception :
NombreHabitantException
– renvoyer l'exception levée à notre classe
NombreHabitantException
– ensuite, gérer celle-ci dans notre classe
NombreHabitantException.
 Les exceptions personnalisées

Pour cela, deux mots clés sont à retenir

• throws : ce mot clé permet de signaler à la
JVM qu'un morceau de code, une méthode,
une classe, est potentiellement dangereux et
qu'il faut utiliser un bloc try{...}catch{...}. Il est
suivi du nom de la classe qui va gérer
l'exception.
• throw : celui-ci permet tout simplement de
lever une exception manuellement en
instanciant un objet de type Exception (ou un
objet hérité).
 Les exceptions personnalisées

• Le constructeur de la classe Ville peut se présenter comme

suit:
public Ville(String pNom, int pNbre, String pPays)
throws NombreHabitantException{
if(pNbre < 0)
throw new NombreHabitantException();
else
{
nomVille = pNom;
nomPays = pPays;
nbreHabitant = pNbre;
[Link]();
}
}
 Les exceptions personnalisées

• throws NombreHabitantException nous

indique que si une erreur est capturée, celle-
ci sera traitée en tant qu'objet de la classe
NombreHabitantException,
• Si la condition if(nbre < 0) est remplie, throw
new NombreHabitantException(); instancie la
classe NombreHabitantException.
• Par conséquent, si un nombre d'habitants est
négatif, l'exception est levée
 Les exceptions personnalisées

• La classe qui va gérer nos exceptions se

présente comme suit:
class NombreHabitantException extends
Exception{
public NombreHabitantException(){
[Link]("Vous essayez d'instancier
une classe Ville avec un nombre d'habitants
négatif !");
}
}
 Les exceptions personnalisées
Chaque méthode susceptible de générer une exception qui
lui est propre doit la déclarer dans son en-tête. On utilise
l‟instruction throws pour cela:
Public class Pile{
final int taille_max=100;
private int sommet;
private int[ ] elements;
public void empiler(int x) throws ErreurPilePleine{
if (sommet==taille_max)
throw new ErreurPilePleine
else elements[++sommet] =x;
}
}
class ErreurPilePleine extends [Link]{
ErreurPilePleine() ([Link](„‟Pile Pleine‟‟);
196
}
FIN du cours Java 1

197