Programmation Orientée Objet

Java

Karin DESMARETS 1
 Table des matières
I. Présentation
II. Les types primitifs de Java
III. Les opérateurs
IV. Les instructions de contrôle
1) L'instruction "if"
2) L'instruction "switch"
3) L'instruction "do… while"
4) L'instruction "while"
5) L'instruction "for"
6) L'instruction "break"

2
V. Les fonctions
1) Fonctions qui ne renvoient pas de valeur
2) Fonctions qui renvoient un résultat

VI. Les classes et les objets

3) Notions d'Orienté Objet
4) Les classes
5) Les attributs et variables locales
6) Les constructeurs
7) Les accesseurs et les modificateurs
8) Affectation et comparaison d'objets
9) Variables et méthodes de classe
10) La surcharge
11) Les packages

3
VII. Les tableaux
1) Déclaration
2) Déclaration avec initialisation
3) Utilisation
4) La taille d'un tableau
5) La classe Arrays
6) Passage des arguments
7) Les tableaux d'objets
8) L'outil Javadoc

4
VIII.L'héritage
1) Généralisation – Spécialisation
2) Héritage et constructeur
3) Les modificateurs de visibilité
4) Redéfinition et surcharge
5) Polymorphisme
6) Classes et méthodes finales
7) Classes abstraites
8) Interfaces
9) La classe Object

5
IX. Les chaînes de caractères
1) La classe String
• Déclaration
• Comparaison
• Concaténation
• Extraction de sous-chaîne
• Longueur
• Extraction d'un caractère
• Conversions
2) La classe StringBuffer
3) Exercices

6
X. Les exceptions standard
XI. Les exceptions non standard
XII. La classe ArrayList
XIII. Les interfaces graphiques
1) Fenêtre
2) Gestion de clic
3) Ajout de composant
4) Evénement sur les composants
5) Boîtes de dialogue
6) BorderLayout
7) Jpanel
8) Quelques composants graphiques
XIV. NetBeans

7
 I. Présentation

§ Qu'est-ce que Java ?

§ Java est un langage de programmation.
§ Java est aussi une plateforme.
§ La plateforme java, uniquement software, est exécutée sur la
plateforme du système d’exploitation.
§ Elle est constituée de :
§ La "Java Virtual Machine" (JVM)
§ Des interfaces de programmation d’application (API)

Cours 1 8
 Atouts de Java
• Langage de programmation simple ;
• Orienté objet ;

• Comporte un grand nombre d’objets prédéfinis pour

l’utilisateur ;

• Neutre architecturalement ( = portabilité ) ;

• Distribué gratuitement !!!

9
 Neutralité architecturale
Un programme Java est compilé puis interprété.

10
 Historique du langage
• 1991 : développement de OAK

– Langage simple, portable et orienté objets

– Pour la programmation de petits appareils électro-

ménagers

– Emprunte la portabilité du Pascal (VM) et la

syntaxe du C++

11
• 1995 : intégration de la JVM dans Netscape
– OAK étant un nom déposé, le projet s’appellera
JAVA
– Apparition des Applets qui ont fait le succès de
Java (remplacés par Flash puis Javascript)

• 1998 : SUN annonce une nouvelle dénomination

pour ses produits Java : Plate-forme Java 2

• 2009 : ORACLE rachète SUN

12
• Version actuelle : J2SE 8 et J2EE 7

• J2SE ou Java SE signifie Standard Edition

• J2EE ou Java EE signifie Enterprise Edition

• Chaque plate-forme (Standard ou Enterprise)

comprend :
• un JDK ou SDK (Java ou Software Development Kit)
• un JRE (Java Runtime Environment) = JVM

13
• Pourquoi Java ?

14
 Premier programme Java
public class PremProg
{
public static void main (String args[])
{
[Link]("Premier programme Java");
}
}

15
II. Les types primitifs de Java

16
Les types entiers

17
Les types flottants

18
 Le type caractère
char 2 octets code universel Unicode

Le type booléen
boolean valeur logique true ou false

19
 Initialisation des variables

• int n = 5 ;
• int n ; n = 5 ;
• int duo = 2 * n ;
• En Java, une variable doit être initialisée avant d'être
utilisée (sinon erreur de compilation).

20
 Les constantes

• final int N = 20 ;

• final int N ;
N = [Link] () ; // Première affectation : OK
N = N + 1 ; // 2ème affectation : erreur de compilation

21
III. Les opérateurs

22
 Opérateurs arithmétiques

+ addition
- soustraction
* multiplication
/ division
% modulo, reste de la division entière

23
 Priorité des opérateurs (en ordre décroissant)

Pour changer la priorité : insérer des parenthèses...

24
 Opérateurs relationnels

< inférieur
<= inférieur ou égal
> supérieur
>= supérieur ou égal
== égal
!= différent

25
 Opérateurs logiques

! négation
& et
^ ou exclusif
| ou inclusif
&& et avec court-circuit
|| ou inclusif avec court-circuit

26
Fonctionnement des opérateurs avec
court-circuit (&& et ||)

La 2ème condition n’est évaluée que si c’est

indispensable pour évaluer la condition
complète …

27
 Opérateurs d'incrémentation

++ pré ou post-incrémentation
-- pré ou post-décrémentation

ü Opérateur à gauche de son opérande : on

incrémente ou décrémente d'abord ;

ü Opérateur à droite de son opérande, on

incrémente ou décrémente après ;

28
Exemples

a = ++ i ; // i=i+1; a=i;
a = i ++ ; // a=i; i=i+1;
tab[i++] = [Link]() ;
// garnit tab[i] puis incrémente i
i ++ ;
++ i ; // sont 2 instructions équivalentes…

29
 Opérateurs d'affectation élargie

Java permet de condenser les affectations.

Exemples :
a=a+b; devient a += b ;
n=n*v; devient n *= v ;

30
 Conversions entre différents types

• Dans certains cas, il y a conversion implicite dans

l'évaluation des expressions arithmétiques ;

• Elle tient compte de la priorité des opérateurs ;

• Elle peut se faire à condition de ne pas dénaturer la

valeur initiale :

byte  short  int  long  float  double

31
Exemple
n * p + x (avec n int, p long et x float)

32
 L'opérateur de CAST

Si a et b sont de type float, et n de type entier :

n=a/b;

donne une erreur de compilation…

"possible loss of precision - found float - required int"

33
Pour forcer la conversion de l'expression en entier,
on utilise un opérateur nommé cast.

n = (int) (a / b) ;

Que pensez-vous de ceci ?

n = (int) a / b ;

 Nouvelle erreur de compilation…

34
Remarque :

le cast (çàd la conversion) est possible

également vers les autres types de données
numériques…

35
 Exercice Instructions valides ?

int a = 1 , b = 2 ;
float f = 5.5f ;
double d = 8.4 ;

f=a+b;
a = b * 2.5 ;
a = (int) d + f ;
d=a*f;
f = a + (int) d ;

36
 Exercice Instructions valides ?

int a = 1 , b = 2 ;
float f = 5.5f ;
double d = 8.4 ;

f=a+b; // oui
a = b * 2.5 ; // non (expression : double)
a = (int) d + f ; // non (expression : float)
d=a*f; // oui
f = a + (int) d ; // oui

37
 IV. Les instructions de contrôle

1. L'instruction "if"

if (condition)
{ instr1 ; instr2 ; … }
else
{ instr3 ; instr4 ; … }

38
 Références pour les logiciels

• [Link] pour jGrasp

• [Link] pour le JDK (kit de développement Java)

• Démonstration : utilisation de l'aide Java de SUN

39
2. L'instruction "switch"

switch (expression)
{
case const-1 : instr1 ; instr2 ; … ; break ;
case const-2 : instr3 ; instr4 ; … ; break ;
…
default : instr5 ; instr6 ; … ;
}

Cours 2 40
Exemple 1
int categorie = [Link]( ) ;
switch (categorie)
{ case 1 : [Link] ("Junior") ;
break ;
case 2 : [Link] ("Adulte") ;
break ;
case 3 : [Link] ("Senior") ;
break ;
default : [Link] ("Non défini") ;
}

41
Exemple 2
switch (mois)
{ case 1 :
case 2 :
case 3:
case 4 :
case 5 :
case 6 : [Link] ("Premier semestre") ; break ;
case 7 :
case 8 : [Link] ("Vacances") ; break ;
default : [Link] ("Fin d'année") ;
}

42
3. L'instruction "do … while"

do
{
série d'instructions ;
}
while (condition) ;

On exécute 1 fois la série d'instructions avant

de vérifier la condition !!!

43
Exemple : Que fait ce programme ?
int som = 0, nb ;
do
{
[Link]("Entrez un nombre") ;
nb = [Link]() ;
som += nb ;
}
while(nb != 0) ;

44
4. L'instruction "while"

while (condition)
{
série d'instructions ;
}

On vérifie la condition avant d'entrer dans la

répétitive !!!

45
Exemple : Que fait ce programme ?
int nb ;
while ( nb > 0 )
{
[Link](nb) ;
nb-- ;
}

46
Erreur de compilation : Il faut initialiser nb avant
de l'utiliser…
Que se passe-t-il maintenant ?
int nb = 10 ;
while ( nb > 0 )
{
[Link](nb) ;
nb-- ;
}

47
5. L'instruction "for"

for ( initialisations ; condition ; incrémentations )

{
série-d'instructions ;
}
§ Les initialisations ont lieu avant d’entrer dans la
répétitive.
§ La condition d’arrêt est testée avant chaque entrée dans
la répétitive.
§ Les incrémentations ont lieu en fin de boucle.
48
Exemple 1 : Que fait ce programme ?

int i ;
for ( i = 1 ; i < 4 ; i++ )
[Link] ( "I vaut " + i) ;
[Link]( "I vaut " + i ) ;

49
Exemple 2 : Que fait ce programme ?

int i ;
for ( i = 6 ; i > 0 ; i = i-2 )
{
[Link] ( "I vaut " ) ;
[Link] ( i ) ;
}

50
 Exercices

Afficher les années bissextiles d'aujourd'hui

jusqu'en 2500.

Remarque : une année est bissextile si elle est

multiple de 4 mais pas multiple de 100.

Résoudre cet exercice 1) avec while ;

2) avec do… while ;
3) avec for
51
6. L’instruction break

- break permet de sortir prématurément d’une

répétitive ;

- Exemple : Calculer la somme de maximum 10

nombres entrés au clavier ou s'arrêter avant si
on entre 0…

52
Solution
int i, som ;
for ( i=1, som=0 ; i <= 10 ; i++ )
{
int n = [Link]() ;
if ( n == 0) break ; // Ce break nous branche
som += n ;
}
[Link]( "Somme des " + (i-1) + " nb = " + som) ; // ici…

53
 Consignes pour le laboratoire

Stocker la classe Clavier dans un répertoire puis sélectionner

Settings / Classpath / Workspace.

54
 Consignes pour le laboratoire
Dans l'onglet CLASSPATH, cliquez sur New et
mentionner le chemin du dossier de la classe Clavier.

55
 V. Les fonctions

Une fonction est un sous-programme qui effectue un

ensemble d’instructions, par simple appel à partir du
programme principal.

On distingue les fonctions qui renvoient une valeur

et celles qui ne renvoient rien.

56
1) Fonctions qui ne renvoient pas de valeur
Déclaration

private static void nom-fonction ( liste d'arguments )

{
instructions ;
}

Appel à partir du "main" de la même classe

nom-fonction ( arg1, arg2,… ) ;

57
Exemple 1 :
Fonction qui affiche "Bienvenue au cours de Java"

public class Exemple1

{

Déclaration
private static void bienvenue( )
{
[Link]("Bienvenue au cours de Java") ;
}

public static void main (String args[])

{
bienvenue( ) ; Appel
}
}

58
Exemple 2 :
Fonction qui affiche "Tu as (n) ans" à partir d'une année de
naissance.

public class Exemple2

{
private static void afficheAge(int anaiss)

Déclaration
{
int age = 2017 - anaiss ;
[Link]("Tu as " + age + " ans") ;
}
public static void main (String args[])
{
afficheAge(1983) ; Appel
}
}
59
2) Fonctions qui renvoient un résultat
Déclaration
private static type nom-fonction ( liste d'arguments )
{
instructions ;
return … ;
}
Le résultat est soit stocké dans une
Appel
variable, soit affiché directement…

variable = nom-fonction (arg 1, arg2,… ) ;

ou [Link](nom-fonction(arg1, arg2,…)) ;

60
Exemple

Fonction qui calcule la somme de 2 entiers reçus en arguments

public class Exemple3

{
private static int somme ( int a, int b )
{
return a + b ;
}
public static void main (String args[])
{
int s = somme (22, 8) ;
...
}
}

61
 VI. Les classes et les objets

1. Notions fondamentales d'Orienté Objet

Cours 3 62
a) Notion d'objet

Un objet = unité autonome avec ses propres données et un

ensemble de procédures pour agir sur ces données .

Exemple : un compte bancaire.

v les données : numéro, solde,… ATTRIBUTS de l'objet

Chaque objet aura ses propres attributs.

v les comportements : consulter(), créditer(montant),…

METHODES de l'objet

63
b) L'encapsulation des données

Pour protéger les données d'un objet (ses attributs), il faut les
"enfermer" dans l'objet = l'encapsulation.

64
c) Notion de classe
Une classe décrit la manière donc va fonctionner un objet.
Elle va permettre de créer plusieurs objets.

- numéro Une classe

- solde
…
instanciation
(= création)
instanciation
instanciation

- 000-00011… - 056-02255… - 063-05346…

- 1817 € - 1315 € - 2450 €
… … …

Plusieurs objets 65
2. Les classes

Exemple :
Soit une classe Point, destinée à manipuler les points d'un plan.

66
Un objet de type Point sera représenté par 2
coordonnées entières : x et y.

6
x

Ce sont les attributs de l'objet (càd les données qui

le caractérisent).

67
Il disposera aussi des 3 méthodes suivantes :

- initialise() : attribue les valeurs de départ

aux coordonnées du point ;
- deplace() : modifie les coordonnées du point ;
- affiche() : affiche les coordonnées du point ;

Remarque :
Une méthode est une fonction qui fait partie d'une classe. Elle permet
d'effectuer des traitements sur (ou avec) les attributs d'un objet.

68
En notation UML, le diagramme de classe se
présente comme ceci :
Nom de la
classe
Point
- x : integer Attributs
- y : integer
+ void initialise (integer, integer)
+ void deplace (integer, integer) Méthodes

+ void affiche ( )

69
 Code Java :
public class Point
{ private int x ; // attributs
private int y ;
public void initialise (int abs, int ord) // méthodes
{ x = abs ;
y = ord ; }
public void deplace (int dx, int dy)
{ x += dx ;
y += dy ; }
public void affiche ()
{ [Link] ("Mes coordonnées : "+ x +" "+ y) ; }
}

70
- Cette classe Point sert à instancier (= créer)
des objets de type Point et à leur appliquer à
volonté les méthodes disponibles ;

- Pour faire appel à une méthode de la classe :

objet.méthode( )

- Nous pouvons utiliser la classe Point depuis

la méthode main d'une autre classe ;

71
public class TstPoint
{ public static void main (String args[])
{ Point a ; // déclaration d'un point
a = new Point() ; // instanciation (=création)
[Link](3, 5) ;
[Link]() ;
[Link](2, 1) ;
[Link]() ;
Point b = new Point() ; // déclaration et instanciation
[Link](6, 8) ;
[Link]() ;
}
} 72
L'exécution de la classe TstPoint donne :

Mes coordonnées : 3 5
Mes coordonnées : 5 6
Mes coordonnées : 6 8

73
3. Attributs et variables locales

• Un attribut est connu dans toutes les méthodes de la classe.

• Une variable locale n'est connue que dans la méthode où elle

est déclarée.

• Un argument de méthode n'est connu que dans la méthode

qui le reçoit.

74
public class Point
{ private int x ;
private int y ;
public void initialise (int abs, int ord)
{ x = abs ;
y = ord ; } § Attributs
public void deplace (int dx, int dy) § Variables locales
{ x += dx ;
§ Arguments
y += dy ; }
public void affiche ()
{ String coord = "Coordonnées : "+ x + " " + y ;
[Link] (coord) ; }
}
75
§ Les attributs d'un objet sont initialisés par défaut :

une booléenne à false

une donnée numérique à 0
un char à vide

§ Une variable locale n'est pas initialisée par défaut.

§ Un argument est initialisé au moment de l'appel de la

méthode.

76
 4. Les constructeurs

• Dans la classe Point, il faut toujours commencer par la méthode

'initialise' ;

• Peu pratique, risque d'oubli ;

• Un constructeur automatise ce mécanisme d'initialisation ;

• Il est automatiquement appelé lorsqu'on instancie un objet de la

classe ;

77
Constructeur qui remplace la méthode 'initialise'

public Point (int abs, int ord)

{
x = abs ;
y = ord ;
}

Remarque : Le constructeur porte le même nom que la classe.

78
 Changements dans la classe TstPoint

La commande suivante ne convient plus :

Point a = new Point( ) ;

Erreur de compilation : la création d'un objet fait

appel au constructeur qui requiert 2 arguments.

La commande devient :

Point a = new Point (3, 5) ;

79
 Autre changement

Il n'est plus nécessaire de faire appel à la méthode

initialise()…

On obtient donc :

80
public class TstPoint
{
public static void main (String args[])
{ Point a = new Point(3, 5) ;
// Commande qui fait appel au constructeur...

[Link]( ) ;
[Link](2, 1) ;
[Link]( ) ;

Point b = new Point(6, 8) ;

[Link]( ) ;
}
}
81
 Règles concernant les constructeurs

§ Un constructeur ne renvoie aucune valeur, aucun type ne

doit figurer devant son nom, pas même void ;

§ Un constructeur doit être déclaré 'public' ;

§ Lorsqu'une classe ne comporte pas de constructeur, Java

considère un constructeur vide sans arguments :
public Point ( )
{ }

82
La création d'un objet ( = commande 'new' ) s'effectue en 3
phases :

1°) attribution de l'espace mémoire

2°) appel du constructeur

3°) renvoi de la référence de l'objet créé

83
Ce code contient une erreur, laquelle ?

public class Essai

{
private int a ;
public Essai(int b)
{a=b;}
}
public class TestEssai
{ public static void main (String args[])
{ Essai monObjet = new Essai () ; }
}

84
Exercice

Ecrire le code d'une classe Nombre qui prévoit :

- Un constructeur pour initialiser l'attribut 'nb' ;
- la méthode 'estMultipleDe(int)' qui renvoie true si le nombre
est un multiple de celui passé en argument ou false sinon ;
- la méthode 'afficheCarre( )' qui affiche le carré de l'attribut
'nb' ;
Ecrire ensuite le code d'une méthode main qui instanciera 2
objets de type Nombre et les manipulera avec les méthodes
disponibles ;

85
5. Accesseurs et modificateurs

§ Java permet plusieurs types d'accès pour les

attributs, méthodes et constructeurs d'une classe :
private : accessible uniquement ds la classe
courante ;
public : accessible dans toutes les classes ;
(néant) : accessible par les classes du même
package ;

Cours 4 86
Protection des attributs d'un objet
§ Autant que possible, les attributs doivent être déclarés 'private'.
§ Soit une classe 'Annee' qui contient un attribut 'an'.
§ Comment faire pour lire cet attribut 'private' de l'extérieur ?

e t An()
+ int g

Solution : Créer une méthode 'public' qui va

- int an renvoyer la valeur de l'attribut.
Ce type de méthode s'appelle un accesseur ou
getter.
Par convention son nom commence par 'get' suivi
du nom de l'attribut qu'on veut lire, ici getAn()

87
§ Accesseur pour l'attribut 'an' :

public class Annee

{
private int an;
public Annee (int newAn)
{
an = newAn;
}

public int getAn () // Accesseur

{
return an;
}
}

88
§ Lecture de la valeur de l'attribut 'an' depuis une classe 'main' :

public class TestAnnee

{
public static void main (String args[])
{ Erreur car 'an'
Annee a = new Annee(1987) ; est private

[Link] ("An : " + [Link]);

[Link] ("An : " + [Link]() );

}
} OK car 'getAn()'
est public

89
§ Comment faire pour modifier un attribut 'private' depuis une
autre classe ?

t)
in
n(
etA
s
oid
v
+
Solution : Créer une méthode 'public' qui va
modifier la valeur de l'attribut avec une valeur
- int an reçue en argument.
Ce type de méthode s'appelle un modificateur ou
setter.
Par convention son nom commence par 'set' suivi
du nom de l'attribut qu'on veut modifier, ici
setAn(…)

90
§ Le modificateur ou setter pourra en plus vérifier la validité de la
nouvelle valeur.
Exemple : N'accepter la nouvelle valeur pour l'attribut 'an' que
si elle est comprise de 1900 à 1999.

public class Annee

{
private int an;
public Annee (int newAn)
{
an = newAn;
}
public void setAn (int newAn) // setter
{
if (newAn >= 1900 && newAn <= 1999)
an = newAn;
}
public int getAn ()
{
return an;
}
}

91
OU public class Annee
{
private int an;

public Annee (int an)

{
[Link] = an;
}
public void setAn (int an)
{
if (an>= 1900 && an<= 1999)
[Link] = an;
}
public int getAn ()
{
return an;
}
}

92
Modification de la valeur de l'attribut 'an' depuis une classe 'main' :

public class TestAnnee

{
public static void main (String args[])
{
Annee a = new Annee(1987) ;
[Link](1990) ;
[Link](2004) ;
[Link]("An vaut : " + [Link]() ;
}
}

Que donne l'exécution de ce programme ?

93
6. Affectation et comparaison d'objets

§ Comme vu précédemment, les variables de

type classe contiennent des références sur
des objets ;

§ Lorsqu'on compare des variables de type

classe, ce sont les références qui sont
comparées !!!

94
Soit la classe Point qui possède un constructeur à 2 arguments.

Point a, b ;
a = new Point (3, 5) ;
b = new Point (2, 0) ;

On obtient en mémoire :
x 3

a y 5

x 2
b
y 0

95
§ On veut tester si ces points sont égaux :
if ( a == b ) …
ne convient pas car on teste les adresses-mémoire
des objets !

§ Il faut comparer tous les attributs :

if ( [Link]() == [Link]() && [Link]() == [Link]() )
…
(ceci suppose qu'on aie prévu les accesseurs)

96
§ Si on exécute l'instruction :
a=b;
c'est la référence de a qui devient la référence de b

On obtient en mémoire : x 3
X
y 5
a

x 2

y 0
b

a et b désignent donc le même objet et il n'y a plus

aucune référence vers le premier objet !!!
97
§ Il n'existe pas d'instruction qui permet de
libérer l'espace inutilisable car Java dispose
d'un mécanisme de gestion automatique de
la mémoire :

le GARBAGE COLLECTOR

98
§ Le garbage collector est une tâche de la
JVM qui :
– travaille en arrière-plan ;
– libère la place occupée par les instances non
référencées ;
– compacte la mémoire occupée ;

Il intervient :
- quand le système a besoin de mémoire;
- ou, de temps en temps avec une priorité faible ;

99
7. Variables et méthodes de classe

a) Les attributs existent dans chacune des

instances de la classe.

On les appelle des variables d'instance.

100
public class Point public class TestPoint
{ {
private int x, y ;
public static void main(String args[])
public Point( ) {
{ Point p1 = new Point( ) ;
x=0; Point p2 = new Point( ) ;
y=0; }
} }
}

On obtient en mémoire :
x 0
p1
y 0
x et y existent dans
chaque instance
=
x 0
Variables d'instances
p2
y 0
101
§ Java permet de définir des variables de classe,
elles n'existeront qu'en un seul exemplaire, quel
que soit le nombre d'objets instances de la classe ;

§ Il suffit de les déclarer 'static' ;

§ Exemple : classe avec un attribut statique destiné

à contenir le nombre d'objets déjà créés ;

102
public class Point
{
private static int nb = 0 ;
private int x, y ;
public Point()
{
nb++ ;
[Link] ("Il y a " + nb + " point(s)") ;
}
}
public class TstPoint
{
public static void main (String args[ ])
{ Point a = new Point( ) ;
Point b = new Point( ) ;
Point c = new Point( ) ;
}
} Qu'affiche ce programme ?

103
b) De manière analogue, certaines méthodes
peuvent avoir un rôle indépendant d'un
quelconque objet ;

Une telle méthode est dite méthode de classe ;

Elle ne pourra agir que sur des variables de

classe, puisque par nature elle n'est liée à aucun
objet en particulier ;

104
public class Point
{
private static int nb = 0 ;
public Point( )
{
nb++ ;
}
// Méthode de classe : statique
public static int getNb ( )
{
return nb ;
}
}

105
public class TstPoint
{
public static void main (String args[])
{ Point a = new Point() ;
Point b = new Point() ;
Point c = new Point() ;
[Link] ("Nbre d'objets = " + [Link]( ) ) ;

/* Pour faire appel à la méthode getNb(), on ne

mentionne pas un nom d'objet particulier car la
méthode est statique...
on l'appelle avec [Link]() !!! */
}
}
106
Pour faire appel à une variable de classe ou à une
méthode de classe, il n'est pas nécessaire
d'instancier un objet de la classe concernée, il suffit
de mentionner :

[Link]

ou

NomDeClasse.méthodeDeClasse( )

107
En notation UML, le diagramme de la classe
Point se présente comme suit :

Point

- $ int nb = 0
+ Point ( )
+ $ int getNb( )

108
- Vous avez déjà, au cours des labos
précédents, manipulé des variables et des
méthodes statiques sans vous en rendre
compte…

- Avez-vous une idée desquelles ?

109
 Exercices

Dans la classe Peugeot 208, versions identiques, distinguez

les attributs statiques et les attributs non statiques :

• couleur
• vitesse maximale
• nombre de vitesses
• âge
• prix catalogue

110
Corriger le code suivant :
public class Essai
{ private String nom ;
public Essai (String nom)
{ nom = [Link] ; }
public static int getNom()
{ return nom ;
}
}
public class TestEssai
{ public static void main (String args[])
{ Essai a = new Essai("Test 1") ;
}
}

111
8. La surcharge

• On parle de surcharge lorsque plusieurs méthodes

ou constructeurs portent le même nom.

• Dans ce cas, c'est la signature de la méthode qui

permet au compilateur de faire la différence
(= nombre et type d'arguments).

Cours 5 112
Exemple 1 : Surcharge de constructeur de la classe Point.
public class Point
{ private int x, y ;
public Point (int abs, int ord) // Constructeur
{ x = abs ;
y = ord ;
}
public Point () // Surcharge du constructeur
{ x=0;
y=0;
}
}
113
Lors de l'instanciation :

Point a = new Point ( ) ;

// Fait appel au 2ème constructeur…

Point b = new Point (4, 6) ;

// Fait appel au 1er constructeur…

114
Exemple 2 : Surcharge de la méthode "deplace" de
la classe Point.

public void deplace ( int dx, int dy ) // deplace (int, int)

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

public void deplace ( int dx ) // deplace (int)

{ x += dx ;
}

115
Lors de l'exécution :

Point a = new Point ( ) ;

[Link](5) ;

// Appelle deplace(int)…

[Link](2, 2) ;

// Appelle deplace(int, int)…

116
Nous avons déjà rencontré la surcharge dans
la classe Math…

[Link]

117
9. Les packages

§ Un package permet de regrouper plusieurs classes

ayant un lien logique entre elles ;

§ La notion de package est proche de la notion de

bibliothèque ou de librairie rencontrée dans
d'autres langages ;

118
§ Quand un programme fait référence à une classe, le
compilateur la recherche :

Ø dans le répertoire courant

Ø dans les répertoires spécifiés dans la variable

d'environnement CLASSPATH

Ø dans le package [Link] qui contient des classes

standards (Math, System, Integer, Float,…)

119
§ Pour utiliser une classe appartenant à un autre
package, il faut ajouter une instruction 'import' :
import [Link] ;
ou
import nomPackage.* ;
Exemple :
import [Link] ; ou import [Link].* ;
public class TestArrayList
{
public static void main(String args[])
{ ArrayList a = new ArrayList() ; …
}
}
120
§ En important tout un package dont certaines classes
sont inutilisées, on ne se pénalise ni en temps de
compilation, ni en taille des byte-codes ;

import [Link] ;

aussi efficace que

import [Link].* ;

121
§ L'environnement Java définit une API (Application
Programmer's Interface) très riche au travers de
nombreux packages ;

§ Programmer en Java nécessite une bonne

connaissance de ces packages ;

§ Rappel : [Link] (Java Doc)

§ Entraide programmeurs : [Link]

122
 VII. Les tableaux

• En Java, ce sont des objets ;

• On pourra utiliser des méthodes pour y accéder ;

• Le 1er élément a pour indice 0 ;

123
1. Déclaration

• type nom-du-tableau [ ] ; // Pas de dimension !!!

type [ ] nom-du-tableau ;

Les éléments d'un tableau peuvent être de type primitif

ou de type objet ;

Exemples : int tab[ ] ;

Point tabPoints[ ] ;

124
On crée un tableau comme on crée un objet : avec
l'opérateur "new"…

• int tab[] ;
tab = new int [4] ; /* référence à un
tableau de 4 entiers… */

On peut exécuter les 2 instructions en 1 fois :

int tab[ ] = new int [4] ;

125
2. Déclaration avec initialisation

Pour initialiser un tableau, il faut travailler élément par

élément :
int tab[ ] = new int[4] ;
tab[0] = 13 ;
tab[1] = 15 ;
tab[2] = 22 ;
tab[3] = 8 ;

==> Pas pratique !

126
Il y existe une autre façon de procéder :

• int tab1[] = {1, 8, 5, 6} ; // tableau de 4 entiers

• char tab3[] = {'a', 'b', 'c'} ; // tableau de 3 char

• int tab2[] = {n, n+2} ; // initialisation à partir d'une variable n

La notation {…} ne peut être utilisée que lors de la

déclaration, par la suite il faut initialiser les éléments
un par un…

127
3. Utilisation d'un tableau

• tab[0] = 15 ; // range 15 dans le 1er élément

• tab[2]++ ; // incrémente le 3ème élément

• int i = 3 ;
[Link] (tab[i]) ; // affiche le 4ème élément

Remarque : Si la valeur de l'indice est incorrecte, on

obtient une erreur d'exécution ;

128
4. La taille d'un tableau
La variable 'length' retourne le nombre d'éléments d'un tableau ;

Exemple : Parcours d'un tableau

for (i = 0 ; i < [Link] ; i++) { … }

Remarque : on écrit [Link] sans parenthèses car length

est un attribut public de l'objet tableau et non une méthode…

129
5. Manipulation de tableaux : la classe Arrays
La classe Arrays propose différentes méthodes qui permettent
manipuler aisément les tableaux.
Exemple : on a 2 tableaux d’entiers et on voudrait vérifier s’ils ont
des contenus identiques. La méthode equals permet de le faire…

130
import [Link].* ;
//car la classe Arrays appartient au package [Link]

public class TestArrays

{
public static void main(String args[])
{
int t1[ ] = { … } ;
int t2[ ] = { … } ;

if([Link](t1, t2))
{
[Link]("Tableaux identiques") ;
}
}
}

131
 Remarques sur le passage des arguments
a) Lorsqu'on transmet une variable de type primitif en argument, on
envoie en fait une copie de la valeur de la variable (=passage par
valeur) :
public class TransmPrimitif
{ public static void main(String[] args)
{ int i = 5 ;
modifVariable(i) ;
[Link]("Après la procédure : " + i) ;
}
static void modifVariable(int k)
{ [Link]("Avant la modif : " + k) ;
k = 10 ;
[Link]("Après la modif : " + k) ;
}
}

Cours 6 132
 L’affichage donnera :

Avant la modif : 5 (k garnie avec valeur reçue en argument)

Après la modif : 10 (on a modifié le contenu de la variable

locale k qui est détruite en sortant de la
procédure)

Après la procédure : 5
(la variable d’origine n’a pas bougé)

133
b) Lorsqu'on transmet un tableau en argument, on envoie
la référence du tableau (= son adresse), la méthode agit
alors directement sur le tableau concerné et non sur une
copie (=passage par référence) …

public class TransmReference

{ public static void main(String[] args)
{
int t[] = {4,8} ;
modifTab(t); // On envoie l'adresse du tableau...
[Link](t[0]) ;
}
static void modifTab (int tab[])
{ tab[0] = 3 ;
[Link](tab[0]) ;
}
}
134
 5. Exercices
Que donne l'exécution du code suivant ?

public class Affectation

{ public static void main (String args[])
{
int i ;
int t1[] = {1, 2, 3} ;
int t2[] = new int[5] ;
for (i=0 ; i<5 ; i++ ) t2[i] = 2*i ;
t2 = t1 ;
for (i=0 ; i<[Link] ; i++) [Link] (t2[i]) ;
}
}

135
Quelles sont les erreurs commises ici ?

public class Erreurs

{
public static void main (String args[])
{
final int N= 10 ;
int t1[] = { 1, 3, 5 } ;
int t2[] ;
t2 = { 5, 8, 3 };
float t3[] = { 2, 3.5, 4 } ;
double t4[] = { 2, 3.5 , 4, N++ } ;
}
}
136
 Les tableaux d'objets

Rappel : un tableau est un objet…

Il faut l'instancier avec la commande 'new'…

Lorsque l'on crée un tableau de type primitif, il suffit donc

d'instancier le tableau (çàd initialiser la référence vers le
tableau).

Lorsqu'on crée un tableau d'objets, il faut non seulement

instancier le tableau, mais aussi chacun de ses éléments qui
sont en réalités des pointeurs !!!

137
Exemple

Soit un tableau de 5 objets de type Point. Il faut instancier le

tableau et chacun de ses éléments.

Point p[ ] = new Point[5] ; // référence vers le tableau

for(int i=0 ; i < [Link] ; i++)
{
p[i] = new Point( ) ; // références vers chacun des élts
}

On a donc 6 références…

138
 L'outil Javadoc

Javadoc est un outil fourni avec le JDK.

Il analyse le code source Java et en extrait des

infos pour générer une documentation au format
HTML.

La documentation générée a le même format que

la documentation du JDK (elle aussi générée via
l'outil Javadoc).

139
 L'outil Javadoc

Hors d'un package, seul les champs publics sont

accessibles, Javadoc ne présentera donc que les
méthodes ou attributs publics.

Comme Javadoc génère du code HTML, on peut y

insérer des tags HTML.

Exemples : <B> … </B> Gras

<I> … </I> Italique
<U> … </U> Souligné

140
 L'outil Javadoc

Pour lancer l'outil Javadoc, cliquer sur l'icône qui

représente un livre

141
 Exemple : la classe Personne du dernier cours…

public class Personne

{
private String nom ;

private int age ;

public Personne (String nom, int age)

{ [Link] = nom ;
[Link] = age ; }

public String getNom()

{ return nom ; }

public int getAge()

{ return age ; }
}
142
 Exemple : la classe Personne du dernier cours…
/** 1 - Classe qui permet de gérer le nom et l'âge d'une personne */
public class Personne
{ /** 2 - Attribut qui mémorise le nom de la personne */
private String nom ;
/** 3- Attribut qui mémorise l'âge de la personne */
private int age ;
/** 4 - Constructeur qui initialise le nom et l'âge de la personne */
public Personne (String nom, int age)
{ [Link] = nom ;
[Link] = age ; }
/** 5 - Accesseur pour le nom */
public String getNom()
{ return nom ; }
/** 6 - Accesseur pour l'âge */
public int getAge()
{ return age ; }
}
143
Remarques

- un commentaire de Javadoc est entouré de /** … */ ;

- chaque commentaire précède immédiatement la classe ou la

méthode qu'il décrit ;

Démonstration…

144
 VIII. L'héritage

• L'héritage est une technique qui permet de créer une

nouvelle classe à partir d'une classe existante. La sous-
classe hérite des caractéristiques de la classe de base.

• Intérêt : pouvoir définir de nouveaux attributs et

méthodes pour la sous-classe, qui viennent s'ajouter à
ceux et celles hérités.

• Pas d'héritage multiple en Java : une classe peut hériter

d'une seule autre.

Cours 7 145
 1) Généralisation - spécialisation
• Le mot-clé extends indique la classe-mère :

class Voiture extends Vehicule { … }

class Velo extends Vehicule { … }
class VTT extends Velo { … }

• On dit qu’une classe-fille (ou sous-classe) spécialise sa classe

-mère (ou super-classe) ;

• Tandis qu’une classe-mère généralise sa classe-fille ;

146
Que peut faire une sous-classe ?

• La classe qui hérite peut :

• Ajouter des méthodes, des variables et des

constructeurs ;

• Surcharger des méthodes ;

• Redéfinir des méthodes ;

147
Exemple : la classe Point
- Imaginons que nous ayons
class Point besoin d'une classe
{ Pointcol, destinée à
private int x, y ; manipuler des points
colorés d'un plan ;
public void initialise (int a, int b)
{ x=a;y=b; } - Elle disposera des mêmes
fonctionnalités que Point et
public void deplace (int dx, int dy)
une méthode "colore"
{ x += dx ; y += dy ; } chargée de définir la couleur
public void affiche () ;
{ [Link] ("Je suis en " + x
+ " " + y) ; } - Elle héritera donc de Point ;
}

148
Exemple : la classe Point

class Point class Pointcol extends Point

{ {
private int x, y ;
private byte couleur ;
public void initialise (int a, int b) public void colore (byte
{ x=a;y=b; } couleur)
{
public void deplace (int dx, int dy)
{ x += dx ; y += dy ; }
[Link] = couleur ;
}
public void affiche () }
{ [Link] ("Je suis en " + x
+ " " + y) ; }
}

149
Nous pouvons maintenant déclarer des variables de type Pointcol :

public class TestPointcol // Classe utilisant Pointcol…

{
public static void main (String args[])
{
Pointcol pc = new Pointcol() ;
[Link] (3, 5) ; // Méthode de la classe de base
[Link] ((byte)3) ; // Méthode de la sous-classe
[Link] (2, -1) ;
[Link]() ;
}
}
150
Remarque

Si on veut une méthode qui affiche à la fois les coordonnées du point

et sa couleur, ceci ne sera pas permis :

public void afficheCoordCouleur ()

{
[Link] ("Je suis en " + x + " " + y) ;
[Link] ("Ma couleur est " + couleur) ;
}

151
§ En effet, les attributs x et y sont encapsulés dans la super
classe et donc non accessibles dans la sous-classe.

§ Pour écrire la méthode afficheCoordCouleur(), on peut

s'appuyer sur la méthode affiche() de Point :

public void afficheCoordCouleur ()

{
affiche() ;
[Link] ("Ma couleur est " + couleur) ;
}

152
Exercices
1) On dispose d’une classe :
class Point
{ public void initialise (int x, int y)
{ this.x = x ; this.y = y ; }
public void deplace (int dx, int dy) { x += dx ; y += dy ; }
public int getX() { return x ; }
public int getY() { return y ; }
private int x, y ;
}

Ecrire la classe PointA, dérivée de Point disposant d'une

méthode affiche pour afficher les coordonnées d'un point.

153
2) On dispose de la classe :
class Point
{ public void setPoint (int x, int y) { this.x = x ; this.y = y ; }
public void deplace (int dx, int dy) { x += dx ; y += dy ; }
public void affCoord ()
{ [Link] ("Coordonnees : " + x + " " + y) ; }
private int x, y ;
}
Ecrire la classe PointNom, dérivée de Point permettant d'ajouter
un attribut 'nom' de type char. On y ajoute les méthodes :
§ setPointNom pour réinitialiser les coordonnées et le nom
d'un objet de type PointNom ;
§ affCoordNom pour afficher les coordonnées et le nom d'un
objet de type PointNom ;

154
2) Héritage et constructeurs

• Si un constructeur d'une classe dérivée n'appelle

pas le constructeur de sa classe de base, c'est le
constructeur sans argument de celle-ci qui sera
d'abord exécuté, puis celui de la classe dérivée ;

155
Exemple
class Mere
{ public Mere()
{ [Link] ("Constructeur mère") ; }
}
class Fille extends Mere
{
public Fille() // Pas d'appel explicite : appel par défaut
{ [Link] ("Constructeur fille") ; }
}
public class TestFille
{
public static void main (String args[])
{ Fille a = new Fille() ; }
}

156
• Si un constructeur d'une classe dérivée appelle un
constructeur de sa 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 ;

157
Exemple 1
class Mere
{ private String prenom ;
public Mere(String prenom)
{ [Link] = prenom ; }
}
class Fille extends Mere
{
public Fille(String nom)
{ super (nom) ; // Appel explicite du constructeur…
[Link] ("Constructeur fille") ; }
}
public class TestFille
{
public static void main (String args[])
{ Fille a = new Fille("Céline") ; }
}

Que donne ce programme à l'exécution ?

158
Exemple 2
class Point
{
public Point (int x, int y) { this.x = x ; this.y = y ; }
public void affCoord()
{ [Link] ("Coordonnees : " + x + " " + y) ; }
private int x, y ;
}

Ecrire le code de la classe PointNom, dérivée de

Point, qui dispose d'un constructeur qui initialise les
attributs, d'un attribut nom et d'une méthode qui
affiche la valeur des attributs. (solution dia suivante)

159
Solution
class PointNom extends Point
{
public PointNom (int x, int y, char nom)
{
super (x, y) ;
[Link] = nom ;
}
public void affCoordNom()
{
[Link] ("Point de nom " + nom + " ") ;
affCoord() ;
}
private char nom ;
}

160
3) Modificateurs de visibilité

• Rappel

Une classe possède 2 degrés de visibilité :

- public : accessible partout ;

- (néant) : accessible par les classes du

package ;

161
• Un attribut ou une méthode possèdent 4 degrés de
visibilité :

– public : accessible partout ;

– (néant) : accessible par les classes du package ;

– protected : accessible par les classes du

package et les classes dérivées ;

– private : accessible uniquement dans sa propre

classe ;

162
 4) Redéfinition et surcharge

• Surcharge = plusieurs méthodes qui portent le

même nom mais qui ont une signature
différente ;

• Elles peuvent se trouver dans la même classe ou

dans une classe et ses descendantes ;

163
 public class A
{ public void methodeX(int i)
{ … }
}

Surcharge

public class B extends A

{ public void methodeX(double i)
{ … }
}

B possède 2 méthodes

164
• Redéfinition = possibilité de redéfinir dans une
sous-classe une méthode qui existe déjà dans la
super-classe (même signature) ;

• L'interpréteur cherche la méthode invoquée à

partir de la classe concernée et remonte jusqu'à la
première rencontrée ;

165
 public class A
{ public void methodeX(int i)
{ … }
}

Surcharge Redéfinition

public class B extends A public class C extends A

{ public void methodeX(double i) { public void methodeX(int k)
{ … } { … }
} }

B possède 2 méthodes C possède 1 seule méthode

166
Exemple

• On considère 2 classes liées par héritage :

• class Employe { … }
• class Representant extends Employe { … }

• La classe représentant redéfinit la méthode

calculSalaire déjà décrite pour un employé ;

167
class Employe class Representant extends Employe
{ {
private String nom ; private float chAff ;
protected float salaire ;
public Representant ( String nom,
public Employe (String nom, float salaire,
float salaire) float chAff )
{
{ super (nom, salaire) ;
[Link] = nom ; [Link] = chAff ;
[Link] = salaire ; }
}
public float calculSalaire () { // Redéfinition de la méthode calculSalaire
float sal = salaire * 0.85f ; public float calculSalaire ()
{
return sal ;
return salaire * 0.85f + (chAff * 0.1f) ;
}
}
}
}

168
 Pour tester les 2 classes précédentes :

public class RepresentantEmploye

{
public static void main(String args[])
{
Employe moi = new Employe ("Desmarets", 1000) ;
Representant toi = new Representant ("Dubois", 1000, 3000) ;
[Link] ("Je gagne " + [Link]() + " comme employe") ;
[Link] ("Tu gagnes " + [Link]() + " comme representant")
;
}
}

169
 5) Polymorphisme

• Vient du grec et signifie : qui peut prendre

plusieurs formes.

• En POO : aptitude d'un même message à

déclencher des opérations différentes, selon
l'objet auquel il est destiné ;

Cours 8 170
Exemple :

int type ;
float salaire ;
Employe e ;
[Link] ("Type ? (1:Employe - 2:Representant) ") ;
type = [Link]() ;
if (type == 1)
{ e = new Employe("Dupond", 1000) ;
}
else
{ e = new Representant("Dupond",1000, 3000) ;
}
[Link] ("Salaire : " + [Link]() + " euros") ;

POLYMORPHISME
171
A l'exécution du programme, le code de la méthode calculSalaire
à lancer est déterminé suivant la classe de l'objet au moment de
l'instanciation (=new) !!!

Pour utiliser le polymorphisme, il faut réunir les conditions

suivantes :

• Avoir une arborescence d'héritage ;

• L'utiliser par une référence d'objet de la classe de

base ;

• Avoir 2 méthodes de même signature définies l'une

dans la classe de base, l'autre dans la classe dérivée ;

172
Remarque

• Et si, pour un représentant, on veut faire ensuite appel à une

méthode propre à la sous-classe ?
[Link]() ; // Erreur de compilation

• Solution : cast vers un objet de la sous-classe

if(e instanceof Representant) {

((Representant)e).methPropreRepr() ; // OK

173
A retenir

• A la compilation, Java tient compte de la manière dont

un objet est déclaré

• A l’exécution, Java tient compte de la nature réelle de

l’objet, çàd de la manière dont il a été instancié

174
6) Classes et méthodes finales

• Le mot-clé 'final', appliqué à une variable, empêche sa

modification après une première initialisation ;

• Une méthode déclarée 'final' ne peut être redéfinie dans

une classe dérivée ;

• Une classe déclarée 'final' ne peut être dérivée ;

175
7) Les classes abstraites

§ Une classe abstraite est une classe incomplète ;

§ Certaines de ses méthodes ne contiennent pas

d'instructions ;

§ Comme elle est incomplète, elle ne peut être instanciée

et doit être héritée ;

176
§ Intérêt ?

§ On peut placer dans une classe abstraite toutes les

fonctionnalités dont on veut disposer dans ses
descendantes :

– Les méthodes et les champs communs seront

implémentés complètement ;

– Les méthodes qui doivent exister mais de manière

différente selon le cas seront déclarées abstraites ;

177
 Exemple
abstract class Employe
{
public void engager( )
{ [Link]("Pot d’accueil");
}
public abstract void licencier( ) ; // pas d'instruction, juste ' ; '
}
class Ouvrier extends Employe
{
public void licencier()
{ [Link]("Dehors !") ; }
}
class Patron extends Employe
{
public void licencier()
{ [Link]("Vous comprendrez que dans la conjoncture actuelle ... ") ;
}
}

178
8) Les interfaces

§ Nous venons de voir qu'une classe abstraite permet de

définir dans une classe de base des fonctionnalités
communes à toutes ses descendantes, tout en leur
imposant de redéfinir certaines méthodes ;

§ Si l'on considère une classe abstraite n'implémentant

aucune méthode et aucun champs, on aboutit à la
notion d'interface ;

179
§ La notion d'interface est cependant plus riche qu'un cas
particulier de classe abstraite :

– une classe ne peut hériter que d'une seule autre ;

– une classe peut implémenter plusieurs interfaces ;

180
 Définition d'une interface

public interface MonInterface

{
public abstract void f(int n) ;
public abstract void g() ;
}

Uniquement des méthodes abstraites et le mot-clé

interface remplace class…

181
 Implémentation d'une interface

public class A implements MonInterface

{
// A doit définir les méthodes f et g de l'interface I…
}

Remarque : on hérite (extends) d'une classe mais on

implémente (implements) une interface !!!

182
 Implémentation d'une interface

Une même classe peut implémenter plusieurs interfaces :

public interface I1
{
void f() ; // public et abstract facultatifs…
}
public interface I2
{
void h() ;
}
class B implements I1, I2
{
// B doit obligatoirement définir les méthodes de I1 et de I2
}

183
 9) La classe Object

• En Java, toutes les classes héritent de la classe

[Link] ;

– elle ne contient aucune variable d'instance ni variable de classe ;

– elle fournit plusieurs méthodes qui sont donc disponibles pour

toutes les classes ;

184
• toString() : renvoie une description de l'objet
sous forme de chaîne (type & adresse –
exemple : Point@fd7a8b04)

• clone() : crée et renvoie une copie de l'objet

(méthode protected !)

• equals(objet) : indique si un autre objet est égal à celui-ci

185
 IX. Les chaînes de caractères

• En Java, une chaîne de caractères est un objet ;

• Java propose plusieurs classes apparentées aux chaînes de

caractères :

– la classe String = chaînes de caractères non modifiables ;

– la classe StringBuffer = chaînes de caractères modifiables
à volonté ;

186
1. La classe String

• Déclaration :

• String prénom = new String ("Céline") ;

ou

• String prénom = "Céline" ;

187
• Comparaison :

String prénom = new String ("Hugo") ;

String autrePrénom = new String ("Hugo") ;
if (prénom == autrePrénom)
[Link] ("Vrai") ;
else
[Link] ("Faux") ;

Bien que les 2 chaînes aient un contenu identique, cette séquence

d'instructions affiche Faux car ce sont les références des objets qui sont
comparées !

188
• Pour vérifier l'égalité entre 2 chaînes :

if (pré[Link](autrePrénom))
[Link] ("Prénoms identiques") ;
else
[Link] ("Prénoms différents") ;

189
• Remarque :

Impossible d'utiliser les opérateurs

< <=
> >=
pour comparer des
chaînes de caractères :
Erreur
de compilation…

190
• La méthode "compareTo( )" renvoie
• 0 si les 2 chaînes sont égales ;
• Une valeur strictement négative si la 1ère est inférieure à la 2ème ;
• Une valeur strictement positive si la 1ère est supérieure à la 2ème ;

if ([Link](autreNom) == 0)
{ [Link]("Noms identiques");
}
else
{ if([Link](autreNom) < 0)
{ [Link](nom + " inférieur à " + autreNom) ;
}
else
{ [Link] (nom + " supérieur à " + autreNom) ;

191
• Concaténation :

• String identité = pré[Link](nom) ;

ou

• String nom = " Julien " + " Decroix" ;

192
• Un objet de type String ne peut être modifié…

• Si on écrit :
String msg = "Bonjour" ;
msg = "Nouveau message" ;

• L'ancienne chaîne "Bonjour" ne sera plus référencée et un

nouvel objet String est créé ;

193
• Extraction de sous-chaîne :
String msg = "Bienvenue ici" ;

String extrait = [Link](4, 8) ;

envoie la chaîne "venu" dans extrait ;

• Une surcharge de cette méthode permet également

d'extraire des caractères à partir de … jusqu'au bout de la
chaîne :

String fin = [Link] (4) ;

envoie la chaîne "venue ici" dans fin ;

194
• Longueur d'une chaîne :
String msg = "Bienvenue" ;

[Link] ([Link]() + " caractères") ;

affiche "9 caractères"…

• Extraction d'un caractère :

char lettre ; String msg = "Bravo" ;

lettre = [Link](3) ;

envoie dans lettre le 4ème caractère de msg (ici "v") ;

195
• Méthodes de conversions :

– toLowerCase() : convertit une chaîne en

minuscules ;

– toUpperCase() : convertit en majuscules ;

– trim() : crée une nouvelle chaîne en supprimant

les espaces au début et à la fin ;

– replace(oldChar, newChar) : remplace toutes les

occurrences de oldChar par newChar ;

– replaceAll(oldString, newString) : remplace les

occurrences de oldString par newString ;

196
• Rappel :

– Ces méthodes de conversion provoquent la création

d'une nouvelle chaîne puisque les objets de la classe
String ne peuvent être modifiés…

197
2. La classe StringBuffer

• Un StringBuffer peut être utilisé partout où un

String l'est ;

• Il est plus flexible puisqu'il peut être modifié ;

198
2. La classe StringBuffer

• Voici quelques-unes de ses méthodes :

• append . capacity
• charAt . delete
• insert . length
• replace . reverse
• setCharAt . substring

• Vous trouverez tous les détails dans l'aide Java ;

199
• Déclaration :
• StringBuffer a = new StringBuffer () ;

chaîne vide d'une capacité initiale de 16 caractères

• StringBuffer b = new StringBuffer(10) ;

chaîne vide de 10 caractères

• StringBuffer c = new StringBuffer("Titre") ;

chaîne de 16 caractères + la longueur de la chaîne reçue en

paramètre

200
• Utilisation :
StringBuffer strBuff = new StringBuffer () ;
[Link] ("Cours") ;
[Link] (" de Java") ;
[Link] (9, "HTML et ") ;

• Un StringBuffer évolue dynamiquement : si on augmente la

longueur de son contenu, l'espace mémoire alloué
augmente automatiquement.

201
– capacity() : retourne le nombre de caractères qu'un
StringBuffer peut recevoir ;

– length() : retourne le nombre de caractères

effectivement placés dans le StringBuffer ;

– setLength(int) : lui attribue une longueur ; si elle est plus

courte que son contenu, la fin sera tronquée ; si elle est
plus longue, son contenu est complété par des
caractères nuls ('\u000') ;

202
Exercices
1) Programme qui lit une chaîne au clavier et qui en affiche :
1) un caractère sur 2 (le premier étant affiché) ;
2) le premier et le dernier caractère ;

2) Programme qui lit un entier au clavier et qui l'affiche

verticalement...

Remarque : La méthode valueOf de la classe String permet de

convertir un entier en String…

203
 X. Les exceptions standard

• Tout programme comporte des erreurs.

• Les erreurs de syntaxe sont interceptées lors de la

compilation.

• Il y a aussi des erreurs possibles à l’exécution. En

Java, on les appelle Exceptions.

Cours 9 204
 Exemple

public class DémoException

{ public static void main (String args[])

{ int t[] ;
[Link] ("Taille ? ") ;
int n = [Link]() ;
t = new int[n] ;
…
}
}

205
• Si l’utilisateur entre une taille de tableau négative,
le programme s'interrompt. Pourquoi ?

• Lors d'une erreur d'exécution, Java lance un objet

de type Exception, si rien n'est prévu pour le
réceptionner, le programme se termine.

• Pour l'éviter, Java propose un mécanisme appelé

gestionnaire d'Exception.

206
Principe de gestion des exceptions

• Les instructions susceptibles de générer une

erreur sont regroupées dans un bloc try qui
surveille les instructions.

• Lors de l'apparition de l'erreur, un objet de type

Exception est lancé à un bloc catch (le
gestionnaire de l'exception).

• Le traitement peut ensuite continuer…

207
 try
{ … // Code susceptible de lever une exception…
}
catch (TypeErreur obj)
{ … // Traitement de l'exception…
}
… suite du programme…

– Pour connaitre le type d’erreur généré, il suffit

de déclencher l’erreur, le compilateur nous
donne la classe de l'objet correspondant (une
classe qui hérite de la classe Exception).

208
Dans notre exemple, il s'agit d'un objet de la classe
NegativeArraySizeException, donc le code devient :

int t[ ] ;
try
{ [Link] ("Taille ? ") ;
int n = [Link]() ;
t = new int[n] ;
}
catch (NegativeArraySizeException e)
{
[Link](" Taille doit être positive !!!");
}
[Link]("Suite du programme") ;

209
Exercice

Calculer et afficher la moyenne d'une série de

nombres entrés au clavier (dernier = 99)…

Gérer la division par 0 si l’utilisateur entre 99 dès le

début.

210
Remarque

La méthode getMessage( ) de la classe

Exception retourne le message associé à
l'instance de l'exception levée…

211
 XI. Les exceptions non standard

• Il s'agit d'exceptions non reconnues comme telles par

Java.

• Exemple : une note qui doit être comprise entre 0 et

20, dans le cas contraire elle doit être reconnue
comme une exception.

212
Commençons par écrire la classe du nouveau type d'exception :

Contrainte : elle doit hériter

de la classe Exception

public class NoteInvalideException extends Exception

{
public NoteInvalideException(int note)
{
[Link](note+" non comprise entre 0 et 20 !") ;
}
}

213
public class Eleve
{
private String nom ;
private int note ; On indique que la
méthode est susceptible
public Eleve(String nom) de lever une exception
{ (throws)
[Link] = nom ;
}
public void encodeNote(int note) throws NoteInvalideException
{
if(note<0 || note>20)
throw new NoteInvalideException(note) ;
else
[Link] = note ;
On lance l'objet exception
} (throw) si la note est incorrecte
}
214
public class TestEleve
{
public static void main(String args[])
{
Eleve moi = new Eleve("Tom") ;
try L'instruction susceptible de
{ déclencher l'erreur est incorporée
[Link](23) ; dans un bloc try… catch( )
}
catch(NoteInvalideException erreur)
{
// on pourrait ici mettre une boucle qui demande d'entrer une note jusqu'à
// ce qu'elle soit comprise de 0 à 20 et l'affecter à l'attribut correspondant
}
… suite du programme …
}
}
215
 XII. La classe ArrayList

• La classe ArrayList implémente une collection

d’objets qu’on peut agrandir ou rétrécir à
volonté (tableau dynamique).

• Ceci évite de devoir gérer sa taille.

• Déclaration :
ArrayList<Personne> lesPersonnes = new ArrayList<Personne>() ;

216
Quelques méthodes de la classe ArrayList :

• add(Element) : ajout d'un élément en fin de liste

• get(int index) : retourne l'élément à l'index

demandé

• remove(int index) : efface l'entrée à l'indice

demandé

• size() : renvoie le nombre d'éléments de la liste

217
• Pas besoin de spécifier de taille, un objet
ArrayList est dynamique (il peut s’agrandir à
volonté en fonction des besoins).

• Exemple :

218
import [Link];
public class TestArrayList
{ public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
[Link]("Paul");
[Link]("Virginie");
[Link]("Louis") ;
for(int i = 0; i < [Link](); i++)
{ [Link]("Elt " + i + " = " + [Link](i));
}
}
}
219
• isEmpty() : renvoie true si l'objet est vide
• clear() : efface tout le contenu de l'objet
• contains(Object element) : retourne true si
l'élément passé en paramètre fait partie de
l'objet
• etc…

A consulter dans l’aide Java de Sun…

220
On peut parcourir un ArrayList avec une boucle for
classique :

ArrayList<Point> liste = new ArrayList<Point>() ;

for(int i=0 ; i<[Link]() ; i++)
{
… [Link](i)…
}

221
Autre méthode plus simple :

ArrayList<Point> liste = new ArrayList<Point>() ;

for (Point p : liste)
{
…p… (la variable locale p référencera les
Points successifs de l'ArrayList)
}

222
 XIII. Interface graphique

• Programme à interface console : le programme

dirige l'utilisateur.

• Programme à interface graphique : l'utilisateur

dirige le programme par ses actions.

Cours 10 223
• On parle de programmation événementielle :
le code à exécuter est déterminé en fonction
de l'événement déclenché par l'utilisateur.

• Nous allons travailler avec le package

[Link] (import nécessaire).

224
1. Première fenêtre

• Voir la classe JFrame …

• Créons notre propre classe dérivée de

JFrame…

225
import [Link].* ;

class MaFenetre extends JFrame

{
public MaFenetre()

{
setTitle("Labo JAVA") ; // Titre de la fenêtre...
setSize(400,300) ; // Taille...
setVisible(true) ; // Rend la fenêtre visible...
}
}

public class InterfaceGraphique1

{
public static void main(String args[])
{
JFrame fen = new MaFenetre() ;
// Création d'un objet du nouveau type...
}
}

226
 2. Gestion d'un clic

• En Java, tout événement possède une source ;

• On associe à la source un objet appelé écouteur

d'événement ; ici un écouteur de souris (objet
d'une classe qui implémente MouseListener) ;

• L'interface MouseListener comporte 5 méthodes :

mousePressed, mouseReleased, mouseEntered,
mouseExited et mouseClicked ;

227
• Pour traiter un clic dans la fenêtre, il suffit
d'associer un objet de ce type à notre fenêtre ;

• On utilisera la méthode addMouseListener qui

figure dans toutes les classes susceptibles de
générer des événements de souris (JFrame en fait
partie) ;

• Forme de l'instruction :

addMouseListener (objetEcouteur) ;

228
class MaFenetre extends JFrame implements MouseListener
{
public MaFenetre() // Constructeur
{
setTitle ("Gestion de clic") ;
setBounds (300, 300, 250, 200) ; // Position + taille
setVisible (true) ;
addMouseListener (this) ; /* La fenêtre sera son propre
écouteur d'événement souris */
}
public void mouseClicked (MouseEvent ev)
{ [Link] ("Clic dans la fenetre") ; }
public void mousePressed (MouseEvent ev) {}
public void mouseReleased (MouseEvent ev) {}
public void mouseEntered (MouseEvent ev) {}
public void mouseExited (MouseEvent ev) {}
}

229
N'oublions pas les imports :

import [Link].* ; // pour JFrame

import [Link].* ; // pour MouseEvent etMouseListener

Exemple de main

public class Clic

{
public static void main (String args[])
{
MaFenetre fenClic = new MaFenetre() ;
}
}

230
• L'argument transmis à la méthode mouseClicked
est un objet de type MouseEvent (objet automa-
tiquement créé par Java lors du clic et transmis à
l'écouteur voulu) ...

• Il contient, entre autres, les coordonnées du

curseur de souris au moment du clic, elles sont
accessibles par les méthodes getX() et getY()…

• Remarque : les coordonnées du clic sont relatives

au composant concerné (ici la fenêtre) et non à
l'écran…

231
 3. Ajout d'un composant

Pour ajouter un composant à une fenêtre, il faut :

1) récupérer une référence vers le conteneur de la fenêtre

(méthode getContentPane() ) ;

2) ajouter le composant à ce conteneur (méthode

add(component) ) ;

232
// Fenêtre avec un bouton
import [Link].* ; // Pour JFrame et JButton
import [Link].* ; // Pour Container
class Fenetre1bouton extends JFrame
{
public Fenetre1bouton(String titre)
{
setTitle(titre) ;
setBounds(300,300,600,200) ;
// Instanciation d'un objet JButton :
JButton monBouton1 = new JButton("Bouton 1") ;
// Référence vers le Container de la fenêtre :
Container cont = [Link]( ) ;
// Ajout du bouton au Container obtenu...
[Link](monBouton1) ;
setVisible(true) ;
}
}
233
• Contrairement à une fenêtre, un bouton est visible
par défaut ;

• Notons que le bouton occupe toute la fenêtre…

• La disposition des composants dans une fenêtre est

gérée par un Layout Manager (gestionnaire de mise-
en-forme) ;

• Par défaut, Java utilise un gestionnaire de la classe

BorderLayout (maximum 5 composants) ;

234
• Gestionnaire + intéressant : le FlowLayout qui
dispose les composants au fur et à mesure de gauche
à droite.

• Si l'utilisateur change la taille de la fenêtre, les

éléments se déplacent pour remplir au mieux
l'espace alloué.

• Choix d'un gestionnaire : méthode setLayout().

235
 Fenêtre avec un bouton et un gestionnaire de mise-en-forme

import [Link].* ; // Pour JFrame et JButton

import [Link].* ; // Pour Container
class Fenetre1bouton extends JFrame
{
public Fenetre1bouton(String titre)
{
setTitle(titre) ;
setBounds(300,300,600,200) ;
JButton monBouton = new JButton("Bouton essai") ;
Container cont = [Link]() ;
// Choix du FlowLayout : disposition ligne par ligne...
[Link](new FlowLayout()) ;
[Link](monBouton) ;
setVisible(true) ;
}
}
236
a) Fenêtre avec un bouton et gestion d'événement
clavier ou souris sur celui-ci…

Dans cet exercice, nous allons prendre en compte les

événements de souris et les actions clavier (touche
espace alors que le bouton a le focus)

 ActionListener

237
import [Link].* ; import [Link].* ; import [Link].* ;
class Fen1Bouton extends JFrame implements ActionListener
{
public Fen1Bouton()
{
setTitle("Un bouton avec événement clavier ou souris") ;
setSize(700,100) ;
Container c = [Link]() ;
[Link](new FlowLayout()) ;
JButton monBouton = new JButton("Essai") ;
[Link](monBouton);
[Link](this) ; // La fenêtre écoute monBouton
setVisible(true) ;
}
public void actionPerformed(ActionEvent e)
{
[Link]("Clic ou action clavier sur le bouton") ;
}
}
238
b) Fenêtre avec 2 boutons - action identique…
class Fen2Boutons extends JFrame implements ActionListener
{ public Fen2Boutons()
{
setTitle ("Avec 2 boutons") ;
setSize (400, 200) ;
JButton b1 = new JButton ("Bouton A") ;
JButton b2 = new JButton ("Bouton B") ;
Container contenu = getContentPane() ;
[Link] (new FlowLayout()) ;
[Link](b1) ;
[Link](b2) ;
[Link](this) ; // La fenêtre écoute le bouton 1
[Link](this) ; // La fenêtre écoute le bouton 2
setVisible(true);
}
// Gestion commune des 2 boutons !!!
public void actionPerformed (ActionEvent ev)
{ [Link] ("Action sur un des boutons") ;
}
} 239
c) Fenêtre avec 2 boutons - actions différentes
class Fen2Boutons extends JFrame implements ActionListener
{
private JButton b1, b2 ; // Déclaration globale (attributs)
public Fen2Boutons()
{ setTitle ("Avec 2 boutons") ; setSize (400, 200) ;
b1 = new JButton ("Bouton A") ;
b2 = new JButton ("Bouton B") ;
Container contenu = getContentPane() ;
[Link] (new FlowLayout()) ;
[Link](b1) ; [Link](b2) ;
[Link](this) ; [Link](this) ;
setVisible(true) ;
}
public void actionPerformed (ActionEvent ev)
// Test du composant qui est source de l’événement action
{ if([Link]() == b1)
[Link] ("Action sur le 1er bouton") ;
else
[Link] ("Action sur le 2ème bouton") ;
}
}
240
 5. Les boîtes de dialogue

a) Boîtes de message

Fenêtres qui restent affichées jusqu’au clic sur le bouton OK.

Méthode statique showMessageDialog de la classe

JOptionPane (package [Link]).

241
Exemple 1 : Pour afficher la boîte de message suivante :

[Link](fen, "Hello") ;
(avec fen qui est un objet de type JFrame ou dérivé)

Remarque : le premier argument représente la fenêtre parent

de la boîte de message… Si on veut une boîte sans fenêtre
graphique associée : null…

242
Exemple 2 : Pour choisir le titre et l'icône :

[Link](fen, "Mauvais choix",

"Avertissement", JOptionPane.ERROR_MESSAGE);

Constantes entières pour le type d'icône : ERROR, INFORMATION,

WARNING, QUESTION et PLAIN suivis de "_MESSAGE"…

243
b) Boîtes de confirmation

Fenêtres qui offrent un choix de type oui/non.

Méthode statique showConfirmDialog de la classe JOptionPane

(package [Link]).

Elle renvoie un entier correspondant au bouton sur lequel on a

cliqué…

244
Exemple 1

int rep = [Link](null, "voulez-vous

continuer") ;
if (rep == JOptionPane.YES_OPTION)
{ [Link] ("Clic sur oui") ; }
…

RAPPEL : null indique que la boîte est affichée indépendamment

d'une fenêtre…

245
Exemple 2 : Pour choisir le titre et les boutons…

int a = [Link](null, "Continuer ?",

"Incident majeur", JOptionPane.YES_NO_OPTION) ;
if (a==JOptionPane.YES_OPTION) …

246
c) Boîtes de saisie

Boîtes qui permettent à l'utilisateur d'entrer une réponse

sous forme de chaîne de caractères…

Méthode statique showInputDialog de la classe

JOptionPane (package [Link]) ;

Elle renvoie un String correspondant à la réponse entrée

par l'utilisateur…

247
Exemple 1

String txt = [Link] (null,

"donnez un texte") ;
if (txt == null) // si clic sur Annuler
[Link] ("Annulation") ;
else
[Link] ("texte saisi : " + txt) ;

248
Exemple 2 : Pour choisir le titre et l'icône…

String txt = [Link](null, "Entrez votre nom",

"CONTROLE D'IDENTITE", JOptionPane.WARNING_MESSAGE) ;

249
d) Boîtes d'option

Boîtes qui permettent un choix parmi une liste…

Surcharge de la méthode showInputDialog…

Elle renvoie un Object correspondant à la réponse choisie

par l'utilisateur…

250
Exemple

String[] couleurs = {"rouge", "vert", "bleu", "jaune", "orange", "blanc"} ;

String txt = (String)[Link] (null,"choisissez une
couleur", "BOITE D'OPTIONS", JOptionPane.QUESTION_MESSAGE,
null, couleurs, couleurs[4]) ;
if (txt == null) // si clic sur Annuler
[Link] ("Pas de choix effectue") ;
else
[Link] ("Votre choix de couleur : " + txt) ;
251
6. Mise en forme d'une interface : BorderLayout
Gestionnaire par défaut qui permet d'ajouter maximum 5
composants dans la fenêtre…
La fenêtre se compose de 5 parties :

Exemple de code qui permet de placer 5 boutons dans

chacune des 5 zones respectives…

252
import [Link].* ;
import [Link].* ;
class Fenetre extends JFrame
{ public Fenetre()
{ setTitle("Test Border Layout") ;
setSize(500,300) ;
Container c = getContentPane() ;
[Link](new BorderLayout()); // Layout choisi par défaut (facultatif)
[Link](new JButton("Centre")) ; // Par défaut, ajout au centre
[Link](new JButton("Nord"), [Link]) ;
[Link](new JButton("Sud"), [Link]) ;
[Link](new JButton("Est"), [Link]) ;
[Link](new JButton("Ouest"), [Link]) ;
setVisible(true) ;
}
}
public class TestBorderLayout
{ public static void main(String args[])
{ Fenetre f = new Fenetre() ;
}
} 253
7. Création d'un panneau (JPanel)

La fenêtre est un conteneur, çàd un objet susceptible de

contenir d'autres composants.

Les boutons sont des composants qui ne peuvent pas en

contenir d'autres…

Il existe des composants intermédiaires : ils peuvent être

contenus dans un conteneur, tout en contenant eux-
mêmes d'autres composants. C’est le cas des panneaux…

254
Un panneau est une sous-fenêtre sans titre ni bordure.
Il ne peut exister de façon autonome, il doit être associé
par la méthode add à un autre conteneur (généralement
une fenêtre)…

class MaFenetre extends JFrame

{
public MaFenetre()
{ …
JPanel panneau = new JPanel() ;
getContentPane().add(panneau) ;
}
}

255
8.1 Cases à cocher (JCheckBox)

JCheckBox case = new JCheckBox("Légende") ;

// "Légende": libellé affiché à côté de la case…
getContentPane().add(case) ;
// ajout au contenu de la fenêtre
Par défaut, la case sera décochée. Une surcharge du
constructeur permet de choisir son état :
JCheckBox case = new JCheckBox("Légende", true) ;
// la case sera cochée…

Cours 12 256
Remarque : chaque action sur une case à cocher génère un
événement Action…

a) Pour réagir immédiatement à une action : lui associer un

écouteur approprié ;

b) Connaître son état :

if ([Link]( )) …

a) Changer l'état, sans intervention de l’utilisateur :

[Link](true) ;

257
Exemple

( voir Cases1 pour démo)

On obtient la fenêtre suivante :

258
8.2 Boutons radio (JRadioButton)

Idem : choix oui/non mais font partie d'un groupe dans

lequel un seul est sélectionné : le choix de l'un désactive
automatiquement l'autre.

JRadioButton bRouge = new JRadioButton("Rouge") ;

JRadioButton bVert = new JRadioButton("Vert") ;

259
Désactivation automatique : créer un objet de type
ButtonGroup…

ButtonGroup groupe = new ButtonGroup() ;

puis associer les boutons au groupe…

[Link](bRouge) ;
[Link](bVert) ;

260
Nb : Une action sur un bouton radio génère un
événement Action et un événement Item pour le
bouton actionné ;

Elle génère aussi un événement de type Item

pour le bouton sélectionné auparavant…

Etat d'un bouton radio :

if ([Link]( )) …

Changement d'état :
[Link](true) ;

261
Exemple

Exemple qui crée un groupe de 3 boutons radio, le premier

est sélectionné au départ.

( voir Radios1 pour démo)

262
8.3 Etiquettes (JLabel)

Permet d'afficher du texte non modifiable par l'utilisateur,

par contre le programme peut le changer.

JLabel texte = new JLabel("Texte initial") ; // Création

[Link]("Nouveau texte") ; // Modification

263
8.4 Champ de texte (JTextField)

Permet à l'utilisateur d'entrer un texte.

Le constructeur doit obligatoirement indiquer la taille.

JTextField entree1, entree2 ;

entree1 = new JTextField(20) ; // Champ vide de 20 caractères

entree2 = new JTextField("Texte initial",15) ;

// Champ de taille 15 contenant "Texte initial" au départ

264
Lecture du contenu
String ch = [Link]() ;

Interdire temporairement la modification

[Link](false) ;

(un champ de texte est modifiable par défaut)

265