Vous êtes sur la page 1sur 126

Cours JAVA

Prof: S.KRIT
______________________________________________________________________________
Filières: SMI, IGE, GL

SOMMAIRE

Chapitre 1 GENERALITES SUR LE LANGAGE


JAVA

Chapitre 2 OUTILS ELEMENTAIRES POUR LA


PROGRAMMATION JAVA

Chapitre 3 HERITAGE ET INTERFACES EN JAVA


Chapitre 4 LES APPLETS
Chapitre 5 LES INTERFACES GRAPHIQUES
Chapitre 6 LES EXCEPTIONS

GL_IGE_SMI

1
Chapitre 1 GENERALITES SUR LE LANGAGE JAVA

1- CARACTERISTIQUES DE BASES DE LA P.O.O


2- NAISSANCE ET DEVELOPPEMENT DE JAVA
3- ENVIRONNEMENT DE JAVA
4- LES PAQUETAGES (les packages)
5- LES CLASSES EN JAVA
6- UTILISATION DES OBJETS
7- LES CONSTRUCTEURS
8- UTILISATION DES ARGUMENTS DE MAIN

GL_IGE_SMI

Chapitre 1 INTRODUCTION A JAVA

1- CARACTERISTIQUES DE BASES DE LA P.O.O

1 - 1 Notion de classe et d’objet

Objet = Données + Traitements

La classe : Abstraction d’un ensemble d’objets qui ont les mêmes caractéristiques
( attributs) et les mêmes comportements ( méthodes)

objet est une instance d’une classe.

Exemple :
Une classe de nom Individu
Attributs : numeroCin, nom, prenom, dateNaissance, adresse
Méthodes : changeAdresse(), calculSalaire(),dateRetraite()..
Objets : Mohammed, Nadia, …
GL_IGE_SMI

2
1 – 2 L’encapsulation des données :
- Les données sont protégées à l’intérieur de chaque objet.
- Les données (publiques ,secrètes)

1- 3 L’Héritage

Une classe dérivée hérite des propriétés d’une classe


de base.
- Economie de code
- Amélioration de la fiabilité
- Amélioration de la lisibilité
Exemple : Un rectangle peut hériter d’un polygone

1- 4 Le Polymorphisme
Le polymorphisme permet la redéfinition d’une méthode

1 - 5 Le Multithreading
THREADS : processus qui s’exécutent simultanément à l’intérieur d’un
unique programme
GL_IGE_SMI

2-NAISSANCE ET DEVELOPPEMENT DE JAVA

2- 1 Caractéristiques de JAVA

- JAVA est un langage de programmation orientée objets


proche de C++.

- JAVA fonctionne comme une machine virtuelle


( indépendant de toute plate forme)

- JAVA est simple (pas de pointeur, pas d’héritage multiple)

- JAVA autorise le multitâche (multithreading)-

GL_IGE_SMI

3
2- NAISSANCE ET DEVELOPPEMENT DE JAVA

2- 1 Caractéristiques de JAVA

- JAVA peut être utilisé sur INTERNET

- JAVA est gratuit

-JAVA contient une très riche bibliothèque de classes


(Packages) qui permettent de :

- Créer des interfaces graphiques


- Utiliser les données multimédia
- Communiquer à travers les réseaux

GL_IGE_SMI

2- NAISSANCE ET DEVELOPPEMENT DE JAVA

2- 2 Historique de JAVA

-Projet de recherche en 1991 chez Sun Microsystems


(langage de pilotage des appareils électroniques) a aboutit
à la création du l.o.o OAK

- En 1994 conversion du langage Oak pour l’adapter aux


technologies des réseaux informatiques tels que
INTERNET. C’est la naissance de JAVA

GL_IGE_SMI

4
2- NAISSANCE ET DEVELOPPEMENT DE JAVA
2- 2 Historique de JAVA

Des éditeurs de grande réputation ont rapidement conclu


des accords de licence pour diffuser JAVA
- Netscape Communications ( 23 mai 1995)
- Oracle (30 octobre 1995)
- Borland (8 novembre 1995)
- IBM ( 6 décembre 1995)
- Adobe Systems ( 6 décembre 1995)
- Symantec (13 decembre 1995)
- Microsoft (12 mars 1996)
- Novell ( 21 mars 1996)

GL_IGE_SMI

3- ENVIRONNEMENT DE JAVA

3- 1 Java Developer’s Kit (JDK)


Sun fourni gratuitement un ensemble d'outils et d'API
pour permettre le développement de programmes avec
Java. Ce kit, nommé JDK, est librement téléchargeable
sur le site web de Sun http://java.sun.com
Le kit java contient :
* le compilateur (javac),
* l’interpréteur (java),
* l’appletviewer ou inspecteur d’applet
- Le JDK contient par ailleurs l’API de java (Application
Programmers Interface) qui correspond à la bibliothèque
de java
- Le kit JDK ne comporte pas d’éditeur.

GL_IGE_SMI

5
3- ENVIRONNEMENT DE JAVA
3- 2 Versions de Java
Java évolue au fil des années. En plus de faire évoluer les
numéros de versions, le nom complet de chaque version a parfois été
changé. Les principaux événements de la vie de Java sont les
suivants :
Année Evénements
1995 mai : premier lancement commercial
1996 janvier : JDK 1.0.1
1997 février : JDK 1.1
1998 décembre : lancement de J2SE 1.2
1999 décembre : lancement J2EE
2000 mai : J2SE 1.3
2002 février : J2SE 1.4
2004 septembre : J2SE 5.0
mai : Java EE 5
2006
décembre : Java SE 6.0

GL_IGE_SMI

3- ENVIRONNEMENT DE JAVA
3- 2 Versions de Java
Depuis sa version 1.2, Java a été renommé Java 2. Les
numéros de version 1.2 et 2 désignent donc la même version. Le JDK
a été renommé J2SDK (Java 2 Software Development Kit) mais la
dénomination JDK reste encore largement utilisée, à tel point que la
dénomination JDK est reprise dans la version 5.0.
En outre, Java 2 désigne les versions de J2SE 1.2 à J2SE 1.4
La version actuelle est Java SE 6 alors que la version Java SE 7 est
en cours de développement.

Compatibilité de version
Java assure une compatibilité binaire ascendante (les programmes
compilés avec une ancienne version peuvent s'exécuter avec une
plate-forme plus récente).

GL_IGE_SMI

6
3- ENVIRONNEMENT DE JAVA

3-3 Editions de la plate-forme Java


La plate-forme Java 2 est disponible dans plusieurs éditions utilisées à
des fins diverses.
Java 2 Standard Edition (J2SE), Contient les classes qui forment le
cœur du langage Java

Java 2 Entreprise Edition (J2EE) pour le développement


d’applications d’entreprise . Elle contient les classes J2SE plus d’autres
classes pour le développement d’applications d’entreprise.
Java 2 Micro Edition (J2ME). pour les produits
d’électronique grand public (téléphones portables,..) dans ce cas
seule une petite partie du langage est utilisée.
Chaque édition contient un kit de développement Java 2 (SDK) pour
développer des applications et un environnement d’exécution Java 2 (JRE)
pour les exécuter.

GL_IGE_SMI

3- 4 Le code source
- Une application java est généralement composée de
plusieurs fichiers source. Les fichiers source de java ont
l’extension .java.
- Un fichier .java peut contenir plusieurs classes.
- Le nom du fichier source java doit être le même que celui
de la classe publique que ce fichier renferme (Un fichier java ne
peut pas contenir plus d’une classe publique)
3- 5La compilation
* Le byte code
- La compilation va transformer le code source en J-code ou byte-
code Java indépendant de toute plate forme
- La commande qui permet la compilation est la suivante :
Javac nom_fich.java
Création d’un ou plusieurs fichiers .class.

GL_IGE_SMI

7
3- 2- 3 La machine virtuelle java
- Le code java comprend des instructions écrites pour une certaine
machine virtuelle java (JVM : Java virtuel Machine)
- un programme java est exécutée sur tout ordinateur pour lequel une
machine virtuelle est disponible.
- Une application sera exécutée par l’interpréteur de java

Java nom_fich

3- 2- 4 Quelques environnements d’utilisation de java


- PCGRASP , JGRASP
- JBUILDER
- ECLIPSE
- NETBEANS
-….
GL_IGE_SMI

- Les fichiers jar

Les fichiers .jar sont des fichiers java compressés comme les
fichiers .zip selon un algorithme particulier devenu un standard de fait
dans le monde des PC.
Ils sont parfois appelés fichiers d'archives ou, plus simplement,
archives.
Ces fichiers sont produits par des outils comme jar.exe. ( qui fait
partie du jdk) .
Les fichiers .jar peuvent contenir une multitude de fichiers
compressés avec l'indication de leur chemin d'accès.
Un fichier .jar peut ainsi être exécuté directement dans tout
environnement possédant une machine virtuelle

GL_IGE_SMI

8
4- LES PAQUETAGES (les packages)
* Organisation hiérarchique des classes en packages
* Regrouper plusieurs classes qui collaborent entre elles dans une
application
* Définir un certain niveau de protection
4- 1 Construction de package
- Pour ranger une classe dans un package, il faut insérer la ligne suivante
au début du fichier source:
package nomDuPaquetage ;
- Un paquetage qui doit contenir des classes et donc des fichiers est un
répertoire. le paquetage a le même nom que le répertoire qui le contient.

4- 2 Utilisation des classes d’un paquetage


On peut importer les packages de deux manières différentes :
1 - import nomDuPackage.* ;
2 - import nomDuPackage.nomDeLaclasse;
Exemple import liste.* ; // importer toutes les classes du package liste
import liste.A ; // importer la classe A du package liste
GL_IGE_SMI

4- 3 API de JAVA

- java.lang : contient les classes fondamentales du langage.


Il contient la classe Object qui est la super classe primitive de toutes
les classes.

- importé par défaut.

Exemples :
Java.lang.Math
Java.lang.System
Java.lang.String

- java.awt : (awt pour Abstract Window Toolkit) contient les


classes pour fabriquer des interfaces graphiques
Exemples :
java.awt.Graphics
java.awt.Color
GL_IGE_SMI

9
19

4- 3 API de JAVA

- Javax.swing contient les classes pour les interfaces graphiques


évolués

- java.applet : utile pour faire des applets qui sont des applications
utilisables à travers le web

- java.io: contient les classes nécessaires aux E/S

- java.net : accés aux réseaux

- java.util : classes d’utilitaires (Random, Date, ...)

GL_IGE_SMI

5 - LES CLASSES JAVA

Une classe définit des attributs et des


méthodes

5 - 1 Architecture d'une classe JAVA

Une classe se compose de deux parties :

* l’en-tête

* le corps

GL_IGE_SMI

10
5- LES CLASSES JAVA

5 - 1 Architecture d'une classe JAVA

Entête d’une classe

[modificateur] class <NomClasse> [extends <superclass>]


[implements <Interface>]
[ ] : optionnel
< > : obligatoire
gras : mot clé

Corps d’une classe


Le corps de la classe donne sa définition. Il contient
les déclarations des attributs et des méthodes.
GL_IGE_SMI

5 - 2 Les modificateurs de classe

Modificateur Définition
public La classe est accessible par toutes les autres
classes des autres packages. Elle est visible
partout
private La classe n’est accessible qu’à partir du
fichier où elle est définie
final Les classes finales ne peuvent pas être
héritables
friendly l'accès est garanti à toute classe dans le
package.
abstract Aucun objet ne peut instancier cette classe.
Seules les classes abstraites peuvent
déclarer des méthodes abstraites. Cette
classe sert pour l’héritage

GL_IGE_SMI

11
5 - 3 Conventions d’écriture en JAVA

Type Convention Exemple

Nom d’une class Polygone


classe Débute par une majuscule

Nom d’un Débute par une minuscule premierObjet


objet Peut s’étaler sur plusieurs mots Chaque
mot commence par une majuscule sauf le
premier

Nom de Débute par une minuscule void ecrire()


méthode Sauf pour le constructeur

Constante S’écrit en majuscules A_CONSTANT

GL_IGE_SMI

5- 4 Un premier exemple
public class Premier
{
public static void main (String[ ] arg)
{
System.out.println( ‘‘bravo’’) ;
}
}
public : visible de partout , y compris des autres paquetages

static : méthode de classe

System.out.println : La méthode println écrit sur l’écran la


chaine de caractères passée en paramètres à cette méthode

GL_IGE_SMI

12
5- 4 Un premier exemple

- Cette classe doit se trouver dans le fichier Premier.java

- Il est compilé par la commande javac Premier.java

- La compilation crée un fichier Premier.class

- Le fichier est exécuté par la commande java Premier

- On obtient à l’exécution : bravo

GL_IGE_SMI

6- UTILISATION DES CLASSES


Pour utiliser une classe, elle doit être instanciée . Il y aura alors création d’un objet.
Mais avant de créer un objet , il faut le déclarer

6 - 1 Déclaration d’un objet

NomClasse objet ;

Cette instruction déclare un objet de la classe NomClasse mais ne le crée pas.

6- 2 Création d’un objet

Objet = new NomClasse( ) ;

La déclaration et la création d’un objet peuvent être regroupées :


NomClasse objet = new NomClasse( )

On accéde aux méthodes et aux attributs de la classe comme suit :


NomObjet.méthode(arguments de la méthodes)
NomObjet.attribut
GL_IGE_SMI

13
6- 3 Exemple d’utilisation d’objet
Il s’agit d’écrire une application en java qui permet de calculer le
salaire hebdomadaire d’un employé en fonction du taux horaire et du
nombre d’heures

public class Employe


{
String nom; // le nom de l'employé
static float taux_h=50; // le taux horaire en dirhams
int nb_h;

float salaireh () // nb_h : nombre d’heures


{ float s;
s=(taux_h*nb_h);
return s;
}
GL_IGE_SMI

public static void main(String[] arg)


{ float s1,s2; // les salaires de 2 employés
Employe emp1,emp2; // 2 objets modélisant 2 employés
emp1=new Employe();
emp2=new Employe();
emp1.nom= " Mohammed"; // le nom de l’employé 1
emp1.nb_h= 35; // le nombre d’heures de l’employé 1
emp2.nom="Nadia"; // le nom de l’employé 2
emp2.nb_h=38 ; // le nombre d’heures de l’employé 2
s1=emp1.salaireh();
s2=emp2.salaireh();
System.out.println("Le salaire de "+ emp1.nom+" est"+s1+" dh");
System.out.println("Le salaire de "+ emp2.nom+" est"+s2+" dh");
} // fin de main
} // fin de la classe
A l’éxecution , on aura :
Le salaire de Mohammed est 1750.0 dh
Le salaire de Nadia est 1900.0 dh
GL_IGE_SMI

14
7- LES CONSTRUCTEURS 29

7 - 1 Définition

- Le constructeur est une méthode qui est effectuée au moment de la


création d’un objet. Il sert à initialiser les variables contenues dans les objets.

- Le constructeur porte le même nom que sa classe. Il ne retourne pas de


valeur et ne mentionne pas void au début de sa déclaration

- Toute classe possède au moins un constructeur. Si une classe ne déclare


pas de constructeur, un constructeur vide est crée automatiquement par défaut

Un constructeur est une fonction qui est appelée par le biais de


l’opérateur new

monObjet = new Constructeur(arguments) ;

GL_IGE_SMI

Exemple d’utilisation de constructeur

public class Employe_Constructeur


{
String nom;
static float taux_h=50;
int nb_h;

Employe_Constructeur(String identite) // Constructeur


{
nom=identite;
}

float salaireh () // nb_h : nombre d’heures


{ float s;
s=(taux_h*nb_h);
return s;
}
GL_IGE_SMI

15
Exemple d’utilisation de constructeur

public static void main(String[] arg)


{ float s1,s2;
Employe_Constructeur emp1,emp2;
emp1=new Employe_Constructeur (" Mohammed");
emp2=new Employe_Constructeur ("Nadia");
/* Dès la création d’un objet on doit spécifier la valeur du nom*/
emp1.nb_h= 35; // le nombre d’heures de l’employé 1
emp2.nb_h=38 ; // le nombre d’heures de l’employé 2
s1=emp1.salaireh();
s2=emp2.salaireh();
System.out.println("Le salaire de "+ emp1.nom+" est"+s1+" dh");
System.out.println("Le salaire de "+ emp2.nom+" est"+s2+" dh");
} // fin de main
} // fin de la classe
GL_IGE_SMI

7 – 2 La variable this
La variable this sert à référencer dans une méthode
l’instance de l’objet en cours d’utilisation. Son emploi peut
s’avérer utile dans les constructeurs avec des paramètres lorsque
les variables de la classe et celles du constructeur portent
exactement le même nom .
public class Employe_this
{ String nom;
static float taux_h=50;
int nb_h;

Employe_this(String nom)
{
this.nom=nom; // variable globale de la classe = variable locale
}

GL_IGE_SMI

16
7 – 2 La variable this
float salaireh ()
{ float s;
s=(taux_h*nb_h);
return s;
}
public static void main(String[] arg)
{ float s1,s2;
Employe_this emp1,emp2;
emp1=new Employe_this (" Mohammed");
emp2=new Employe_this ("Nadia");
emp1.nb_h= 35; // le nombre d’heures de l’employé 1
emp2.nb_h=38 ; // le nombre d’heures de l’employé 2
s1=emp1.salaireh();
s2=emp2.salaireh();
System.out.println("Le salaire de "+ emp1.nom+" est"+s1+" dh");
System.out.println("Le salaire de "+ emp2.nom+" est"+s2+" dh");
} // fin de main
} // fin de la classe
GL_IGE_SMI

Chapitre 2 LES OUTILS ELEMENTAIRES


POUR LA PROGRAMMATION JAVA

1- COMMENTAIRES EN JAVA
2- TYPES ELEMENTAIRES EN JAVA
3- LES PROPRIETES DES ATTRIBUTS
4- LES STRUCTURES DE CONTROLES
5- LES PROPRIETES DES METHODES
6- LES TABLEAUX
7- LA SAISIE AU CLAVIER
8- LES CHAINES DE CARACTERES
9– LES OPERATIONS SUR LES OBJETS

GL_IGE_SMI

17
Chapitre 2 TECHNIQUES DE BASE DE
LA PROGRAMMATION JAVA

11 - Commentaires en java

En java, il existe deux types de commentaires :

// commentaire simple sur une ligne

/* */ commentaire de plusieurs lignes

GL_IGE_SMI

Chapitre 2 TECHNIQUES DE BASE DE


LA PROGRAMMATION JAVA

2– Types élémentaires en java


JAVA dispose des 8 types élémentaires suivants, ces types
sont appelés primitives en java :

boolean Destiné à une valeur logique (true, false)


byte Octet signé 8 bits (-128 et 127)
short Entier court signé 16 bits (-32768 – 32767)
char Caractère 16 bits

GL_IGE_SMI

18
Chapitre 2 TECHNIQUES DE BASE DE
LA PROGRAMMATION JAVA

2– Types élémentaires en java

int Entier signé 32 bits


float Virgule flottante 32 bits
double Double précision 64 bits
long Entier long 64 bits

GL_IGE_SMI

Java dispose également des classes suivantes pour gérer ces primitives :

Classe Primitive
______________________________
Character char
Byte byte
Short short
Integer int
Long long
Float float
Double double
Boolean boolean

GL_IGE_SMI

19
3- LES PROPRIETES DES ATTRIBUTS

3 - 1 Déclaration

Un attribut correspond à une variable ou une constante pouvant


prendre une valeur différente pour chaque objet instance de la classe.

Tous les objets d’une même classe ont les mêmes attributs,
mais chaque objet associe à ces attributs des valeurs qui lui sont
propres.
Avant d’utiliser un attribut, il doit être déclarée comme suit :

<modificateur> type_elementaire identificateur

GL_IGE_SMI

3- LES PROPRIETES DES ATTRIBUTS

3 - 1 Déclaration

Modificateur Définition

final - Un attribut constant.


private - Un attribut privée ne peut être utilisée que
dans les méthodes de la même classe
public - Attribut visible par toutes les autres
méthodes
static - Attribut de classe indépendant des objets

GL_IGE_SMI

20
33-2 Identificateurs
A Chaque objet , classe, programme ou variable est associé un identificateur. Les
identificateurs Java sont formés d'un nombre quelconque de caractères. Ils doivent
respecter les règles suivantes :
- Les majuscules et les minuscules sont distinguées.
- Le premier caractère ne doit pas être un chiffre
- L’ identificateur ne doit pas être un mot clé de Java.
En plus des règles ci-dessus, il est conseillé de respecter les directives
suivantes :
_ - Evitez les caractères accentués dans les noms de classes.
- - Evitez de donner le même nom à des identificateurs d'éléments différents

GL_IGE_SMI

3-3 Mots clé de java

Les mots suivants sont les mots clé de java :

abstract assert boolean break byte


case catch char class continue
default do double else enum
extends false final finally float
for if implements import instanceof
int interface long native new
null package private protected public
return short static super switch
synchronized this throw throws transient
true try void volatile while

enum Jours{Lun, Mardi, Mer, Jeudi, Vend, Sam, Dim};


GL_IGE_SMI

21
3 - 4 Les attributs statiques

Ce sont les attributs qui ont le modificateur static. Un attribut


statique ( ou de classe) appartient à une classe et non à ses instances.
Il est indépendant des objets
- Un attribut statique existe dès que sa classe est chargée en
mémoire alors qu’un attribut d’instance existe lors de l’instanciation de
la classe
Pour utiliser un attribut ou une méthode statique, on écrit :
NomClasse.nomAttributStatique
Cependant JAVA permet également d’utiliser :
nomObjet.nomAttributStatique où nomObjet est une
instanciation de la classe qui contient l’attribut ou la méthode statique

GL_IGE_SMI

Exemple1 : attribut statique


class Statique
{
int nons;
static int s;
}
public class UtiliseStatic
{
public static void main (String[] arg)
{
Statique.s=10;
Statique obj1= new Statique();
obj1.nons=20;
Statique obj2= new Statique();
obj2.nons=30;
obj2.s=15;//Pour tous ,les objets s=15
System.out.println(Statique.s); //15
System.out.println(obj1.s); //15
System.out.println(obj1.nons); //20
System.out.println(obj2.nons); //30
}
}
GL_IGE_SMI

22
Exemple2 : Calcul des moyennes des élèves ainsi que la
moyenne de la classe

class Moyenne
{ static int nb_eleves ; // nombre d’élèves
float note1,note2,note3; // notes des élèves
int num; // numéro de l'élève
String nom; // nom de l'élève
static float moyenne_classe;

Moyenne(int n, String nam) //constructeur


{ num=n;
nom=nam ;
}

float moyenne_eleve()
{ float som;
Som= (note1+note2+note3) /3;
return (som); } }
GL_IGE_SMI

Exemple2 :Calcul des moyennes des élèves ainsi que la moyenne de la classe

public static void main(String[] arg) {


Moyenne.nb_eleves=2;
Moyenne eleve1= new Moyenne(1,"Adnane");
Moyenne eleve2= new Moyenne(2,"Amal");
eleve1.note1=15;
eleve1.note2=11;
eleve1.note3=17;
float moy1=eleve1.moyenne_eleve();
eleve2.note1=12;
eleve2.note2=18;
eleve2.note3=16;
float moy2=eleve2.moyenne_eleve();

GL_IGE_SMI

23
System.out.println("Eleve : numéro : "+eleve1.num);
System.out.println("Nom : "+eleve1.nom+" Moyenne : "+moy1);
System.out.println("Eleve : numéro : "+eleve2.num);
System.out.println("Nom : "+eleve2.nom+" Moyenne : "+moy2);
Moyenne.moyenne_classe=(moy1+moy2)/ Moyenne.nb_eleves;
System.out.println("La moyenne de la classe est "+
Moyenne.moyenne_classe);
}
}
A l'exécution on aura :
Eleve 1 Nom : Adnane Moyenne : 14.3333
Eleve 2 Nom : Amal Moyenne : 15.3333
La moyenne de la classe est : 14.833

GL_IGE_SMI

-3-5 Les opérateurs de java

* Multiplication
/ division
% modulo
+ addition
- soustraction
= affectation
== identité
!= différent de
&& et logique
|| ou logique
++ incrémentation
+= - = *= /=

GL_IGE_SMI

24
3-6 – Les initialiseurs

Les initialiseurs d’attributs permettent d’affecter à


un attribut une valeur initiale. Si on déclare un attribut non
static dans une méthode, cet attribut n’a pas de valeur.
Toute tentative d’y faire référence produit une erreur de
compilation.

En revanche , s’il s’agit d’une variable globale, càd


si cette déclaration se trouve en dehors de toute méthode,
JAVA l’initialise automatiquement avec une valeur par
défaut .

GL_IGE_SMI

Exemple :
class Initialiseur
{
int a1; static int a2;
void m1()
{ int a3;
System.out.println(a3) ; //erreur car a3 non initialisée
}
public static void main(String[] arg)
{ System.out.println("a2="+a2);
Initialiseur obj= new Initialiseur();
System.out.println("obj.a1="+obj.a1);
obj.m1();
}
}

GL_IGE_SMI

25
Pour des initialisations plus complexes, on peut utiliser un
bloc placé à l’extérieur de toute méthode ou constructeur
Par exemple, float e
{
if (b != 0 )
{ e = (float) a /b ; }
}

GL_IGE_SMI

3-7 Les attributs constants

- Une constante est un attribut qui ne peut plus être


modifié une fois qu’il a été initialisé.
- Une constante est initialisée une seule fois soit au
moment de sa déclaration, soit dans le constructeur de la
classe
- Pour déclarer un attribut constant , on le muni du
modificateur final
Si on déclare un attribut par final static int MAX = 10
MAX est une constante de la classe qui vaut toujours 10 pour
toutes les instances de la classe.
Par contre si on déclare un attribut final dans le
constructeur . Il y en aura un exemplaire par instance créée.
GL_IGE_SMI

26
Exemple de définition et d’utilisation de constantes

class Constantes
{
final int C ; /* déclare une constante d’instance qui peut être
initialisée dans le constructeur */

final static int D= 100 ; /* déclare une constante de classe


qui doit être initialisée au moment de sa définition */

Constantes (int i ) // Constructeur de la classe Constantes


{
C = i ; // initialisation de la constante d’instance C
// C= D ; interdit car C doit être définit une seule fois
// D = 10 ; interdit car D est une constante de classe
}
}
GL_IGE_SMI

public class EssaiConstantes


{
public static void main (String[] arg)
{
System.out.println ( ( new Constantes (2)).C ) ;
System.out.println (Constantes.D ) ;
}
}

On obtient à l’exécution :
2
100

GL_IGE_SMI

27
4- Les structures de contrôle

Les structures de contrôle de java sont similaires à celles de C

Les instructions conditionnelles

a – L’instruction if
if (expression)
InstructionSiVrai ;
else
InstructionSiFaux

b- L’opérateur ?
condition ? siVrai : siFaux

Exemple : int a, b ;
int min = a<b ? a : b

GL_IGE_SMI

c- L’instruction switch
switch (variable)
{ case cas1 : instruc11 ;
instruc12 ;
.
break ;
case cas2 : instruc21 ;
instruc22 ;
.
break ;
.
default : instrDefault ;
}

GL_IGE_SMI

28
Les instructions de répétition
a – L’instruction while
while (condition)
instruction ;
b – L’instruction do
do
instr ;
while (condition)

c – L’instruction for
for ( initialisation, ; test ; incrementation)

La boucle for en java autorise plusieurs expressions séparées par


une virgule à apparaître dans la partie initialisation et
incrémentation mais pas dans la partie test

Exemple : for (i=1, j=10; (k<15);i++,j--)

GL_IGE_SMI

5- Les propriétés des méthodes

5 - 1 Signature d’une méthode

les méthodes sont les fonctions qu’on peut appliquer aux objets.
Elles permettent de changer l’état des objets ou de calculer des valeurs
Plusieurs méthodes d’une même classe peuvent avoir le même
nom, mais des paramètres différents ( surcharge) .
Le nom et le type des paramètres constituent la signature de la
méthode. Une méthode peut elle aussi posséder des modificateurs.

GL_IGE_SMI

29
Modificateur Définition

abstract Prototype de méthode


Une méthode qui ne peut pas être redéfinie.
final
Méthode ne peut être invoquée que par des
sous classes.
protected
une méthode privée ne peut être utilisée que
dans les méthodes de la même classe
private
méthode visible par toutes les autres
méthodes
public
Méthode de classe indépendant des objets
static
GL_IGE_SMI

5 -2 Les méthodes statiques

Comme pour les attributs statiques , les méthodes statiques


ont le modificateur static et sont indépendantes des instances
- Une méthode statique ne peut pas être redéfinie. Elle est
automatiquement finale
Pour utiliser une méthode statique, on écrit :

NomClasse.nomMethodeStatique(arguments)

Cependant JAVA permet également d’utiliser :

nomObjet.nomMethodeStatique(arguments)

nomObjet étant une instanciation de la classe qui


contient l’attribut ou la méthode statique

GL_IGE_SMI

30
5-3 – La surcharge

Si plusieurs méthodes possèdent le même nom mais


différent par l’ensemble des types de leurs arguments, ou par
l’ordre des types de leurs arguments, on dit qu’il y a
surcharge. Lorsqu’une méthode surchargée est invoquée , la
bonne méthode est choisie pour qu’il y ait correspondance
sur les paramètres de l’appel et les arguments de la méthode

GL_IGE_SMI

EXEMPLE
class Surcharge
{ int n ;
double x ;
Surcharge( )
{
n=1;
x = 3.5 ;}
Surcharge(int n, double x)
{
this.n = n ;
this.x = x ;
}
int operation(int p)
{ return 10*p +n ;}
double operation (double y , int p)
{ return x*p + y ; }
double operation(int p, double y )
{ return (double) n/p + y ; }
}
GL_IGE_SMI

31
public class EssaiSurcharge
{
public static void main (String[] arg)
{
Surcharge surcharge ;
surcharge = new Surcharge( ) ;
System.out.println (surcharge.operation (2)) ;
System.out.println (surcharge.operation (1.5 , 4)) ;
System.out.println (surcharge.operation (4 , 1.5)) ;
surcharge = new Surcharge(7 , 2.0) ;
System.out.println (surcharge.operation (2)) ;
}
}

GL_IGE_SMI

remarque :
si on ajoute l’instruction : (surcharge.operation (4 , 5)) ; il
y’aura erreur de compilation car ambiguité .Par contre s’il
n’y avait pas de surcharge (une seule méthode double
operation (double y , int p) ) cette même instruction ne
génerera pas d’erreur car transtypage automatique

GL_IGE_SMI

32
6 – Les tableaux 65
Les tableaux en java sont des structures pouvant contenir un nombre fixe d ’éléments de
même nature. Chaque élément est accessible grâce à un indice correspondant à sa position dans
le tableau.

6-1 Déclaration d ’un tableau

Les tableaux doivent être déclarés comme tous les objets. Java dispose de deux syntaxes
équivalentes pour la déclaration des tableaux,

type_elements[ ] tableau;
ou
type_elements tableau[ ] ;

Exemple : int [] tab1


int tab2[]
6-2 Création d’un tableau

Comme tout objet java un tableau doit être crée après sa déclaration. Les tableaux java sont
de taille fixe.La création doit indiquer leur taille. La syntaxe à utiliser est la suivante :
x = new type[ dimension];
dimension est le nombre d'éléments que le tableau pourra contenir.
GL_IGE_SMI

Exemple :
class TableauA
{ public static void main(String[] arg)
{
int[] tableau ;
tableau = new int[2];
tableau[0]=-5;
tableau[1]= 8
for(int i=0 ;i<2 ;i++)
System.out.println(tableau[i]);
}
}
Autre façon de définir un tableau : On peut définir un tableau avec un
tableau littéral au moment de sa déclaration.

Exemple: boolean tableau[ ] = {true,false,true}; int t[ ]={0, 5, 9, -45}


GL_IGE_SMI

33
6- 3 Longueur d’un tableau

On peut connaître la longueur d ’un tableau en utilisant


l ’attribut length.
Tableau.length est la longueur du tableau Tableau.

class TableauB
{public static void main(String[ ] argv)
{ int tableau[ ]=new int[3];
System.out.println(‘’Taille du tableau : ‘’+ tableau.length) ;
} // affichera 3
}

Remarque : Pour parcourir un tableau, il ne faut pas dépasser sa


longueur (Tableau.length) sinon il y’aura une erreur à l’exécution.
Exemple : for (int i= 0 ; i <= Tableau.length; i++)générera une erreur
GL_IGE_SMI

6- 4 Tableau d’objets

Avec java, on peut aussi manipuler des tableaux d’objets


Exemple:

class TableauD
{
public static void main(String[] argv)
{ Integer tableau[] = new Integer[4] ; //un tableau de 4 objets
int somme = 0 ;
for (int i=0 ; i<tableau.length ; i++)
tableau[i]= new Integer(i) ;
for (int i=0 ; i<tableau.length ; i++)
somme+=tableau[i].intValue() ; //intValue retourne l’attribut i
System.out.println(‘’ La somme des entiers est ‘’+somme) ;
}
}
GL_IGE_SMI

34
6-5 Tableau multidimensionnel :

Les tableaux de java peuvent comporter plusieurs dimensions. Pour


déclarer un tableau multidimensionnel, on doit utiliser la syntaxe suivante :
type [ ] [ ] [] tableau

Exemple : int[ ] [ ] tableau; // 2 dimensions


La création du tableau peut être effectuée à l'aide de
- L'opérateur new : int [][] x = new int[2][4]; ou
- de tableaux littéraux : int [ ][ ] tableau = {{1, 2, 3, 4},{5, 6, 7, 8}};

Pour accéder à tous les éléments du tableau, on utilise des boucles


imbriquées Exemple : int [ ][ ] x = new int[2][4];
for (int i = 0; i < x.length; i++) // x.length : longueur de la 1ère imension

for (int j = 0; j < x[i].length; j++) //x[i].length : longueur de la 2dimension

GL_IGE_SMI

7- La saisie au clavier
- En java, le clavier est un fichier représenté par un
objet particulier de La classe java.io.BufferedReader qui
admet le constructeur :
BufferedReader (InputStreamReader objet) ou
Scanner sc=new Scanner(System.in);
Int a,
a = sc.nextInt();
Pour représenter le clavier, on doit instancier la classe
BufferedReader comme suit :
BufferedReader (new InputStreamReader(System.in))
La méthode readLine de BufferedReader permet de
lire une ligne
GL_IGE_SMI

35
Exemple : Ecrire une fonction de prototype int puissance(int a, int b) qui
calcule ab, a et b sont des entiers.

import java.util.Scanner;

public class apuissanceb {

public static void main(String[] args) {


Scanner sc=new Scanner(System.in);
int a, b;
double res;

System.out.println("donner la valeur de a: ");


a = sc.nextInt();
System.out.println("donner la valeur de b: ");
b = sc.nextInt();
res = Math.pow(a,b); // Math.pow: calcul de a puissance b

System.out.println("\n A Puiss B = "+res);


}
GL_IGE_SMI
}

8- LES CHAINES DE CARACTERES


En Java, les chaînes de caractères sont des objets
de la classe java.lang.String ou java.lang.StringBuffer

8-1 Les chaînes de caractères de type String


- La classe java.lang.String est une classes dont les
objets sont immuables (ils ne peuvent pas changer de
valeur)

- La JVM crée un objet de type String à la rencontre


d’une série de caractères entre doubles apostrophes.

- Les chaînes de caractères (String) peuvent se


concaténer à l’aide de l’opérateur +.

GL_IGE_SMI

36
- Les Conversions

String toLowerCase() Retourne une chaîne égale à la chaîne


convertie en minuscules.
String toLowerCase(Locale Retourne une chaîne égale à la chaîne
locale) convertie en minuscules.
String toString() Retourne une chaîne égale à la chaîne
String toUpperCase() Retourne une chaîne égale à la chaîne
convertie en majuscules.
String toUpperCase(Locale Retourne une chaîne égale à la chaîne
locale) convertie en majuscules.
String trim() Retourne une chaîne égale à la chaîne sans
les espaces de début et de fin.
String replace(char ac, char Retourne une chaîne ou tous les ac ont été
nc) remplacé par des nc. S’il n’y a pas de
remplacement, la chaîne elle-même est
retournée.

GL_IGE_SMI

Exemple :
public class Chaine1
{ String ch1="langage" ;
String ch2= " java" ;
String ch3=ch1+ch2;
void affiche_longueur()
{ System.out.println(ch1+" a pour longueur " + ch1.length());
System.out.println(ch2+" a pour longueur " + ch2.length());
System.out.println(ch3+" a pour longueur " + ch3.length());
}
void affiche_caractere(String ch)
{ for(int i = 0;i<ch.length();i++)
System.out.println(ch+" à l'indice "+i+" = "+ch.charAt(i));
}
public static void main(String[] arg)
{ Chaine1 obj = new Chaine1();
obj.affiche_longueur();
obj.affiche_caractere(obj.ch3);
}
}
GL_IGE_SMI

37
8-2 Les chaînes de caractères de type StringBuffer

Pour une utilisation plus évoluée d’une chaîne de


caractères on peut utiliser des objets de la classe
java.lang.StringBuffer qui contient des méthodes qui ne
sont pas définies dans la classe String
(append,.setLength,…)
Les objets de cette classe contiennent des chaînes de
caractères variables, ce qui permet de les agrandir ou de
les réduire.
La classe StringBuffer dispose de nombreuses
méthodes qui permettent de modifier le contenu de la
chaîne de caractère

GL_IGE_SMI

- Les Constructeurs de la classe StringBuffer

StringBuffer() Construit une chaîne vide de capacité initiale de 16


caractères.

StringBuffer (int l) Construit une chaîne vide de capacité initiale de l


caractères.

StringBuffer (String s) Construit une chaîne de caractères à partir de la chaîne s

int capacity() la capacité de la chaîne de caractères : longueur max


int length() la longueur de la chaîne de caractères
void setLength (int n) la longueur de la chaîne est n ; les caractères
éventuellement ajoutés ont une valeur indéterminée.

GL_IGE_SMI

38
- Caractère et sous-chaîne.

char charAt(int i) Retourne le caractère à l’indice


spécifié en paramètre.
String substring(int i) Sous chaîne depuis i jusqu’à la
fin
String substring(int i, int l) Sous chaîne depuis i et de
longueur l.

- Conversion
String toString() Retourne une chaîne égale à la chaîne

- Modifications

StringBuffer delete(int start, int end) Enlève tous les caractères compris entre start et
end.
StringBuffer deleteCharAt(int index) Enlève le caractère à l’indice index

GL_IGE_SMI

8-2 Les chaînes de caractères de type StringBuffer


Exemple : utilisation de la longueur et de la capacité
public class Chaine2
{static StringBuffer stb1,stb2;
public static void main(String[ ] arg)
{ stb1=new StringBuffer();
stb2=new StringBuffer(10);
System.out.println("stb1 a pour longueur "+stb1.length()); //0
System.out.println("stb1 a pour capacité "+stb1.capacity()); //16
System.out.println("stb2 a pour longueur "+stb2.length()); //0
System.out.println("stb2 a pour capacité "+stb2.capacity()); //10
stb1=new StringBuffer("Chaine");
System.out.println("stb1 a pour longueur "+stb1.length()); //6
System.out.println(stb1+ " pour capacité "+stb1.capacity()); //22=16+6
stb1.append(" StringBuffer");
System.out.println(stb1+" a pour longueur "+stb1.length());//19
System.out.println(stb1+" a pour capacité"+stb1.capacity()); //22
stb1.setLength(3);
System.out.println(stb1+" a pour longueur "+stb1.length()); //3
System.out.println(stb1+" a pour capacité"+stb1.capacity());//22
} }
GL_IGE_SMI

39
9 – OPERATIONS SUR LES OBJETS

9 – 1 L’affectation =
ObjetA = ObjetB ObjetA désigne le même objet que ObjetB, c’est la copie de référence
Toute modification effectué sur l’objet référencée par objetA sera répercuté sur l’objet
référencée par objetB et vice versa.

Exemple :
class Copie
{
public static void main(String[] argv)
{
int[ ] tableau = {1,2};
int[ ] table ;
table = tableau;
table[0] =7;
System.out.println(‘‘tableau contient :’’ + tableau[0] +tableau [1]);
/* tableau[0]=7 et tableau[1]=2 */
}
}
GL_IGE_SMI

9 –2 Egalité entre objets

Si obj1 et obj2 sont deux références d’objets de la même classe.


(obj1== obj2) est vraie si ces deux références obj1 et obj2 désignent
le même objet
Exemple :
class C1
{ }
public class Egalite
{
public static void main( String[] arg)
{ C1 obj1,obj2,obj3;
obj1=new C1();
obj2=new C1();
obj3=obj1;
System.out.println(obj1==obj2); // false
System.out.println(obj1==obj3); //true
}
}
GL_IGE_SMI

40
9– 3 L’objet null
L’objet null n’appartient pas à une classe, mais il peut être utilisé en lieu et place
d’un objet de toute classe,
public class Case
{ int val ;
Case (int val ) // Constructeur de la classe Case
{ this.val=val ; }
boolean estEgal (Case c)
/* Méthode estEgal avec un paramètre objet de type Case */
{ return val = = c.val ; }
}
public class DemoNull
{ public static void main (String[] arg)
{
Case c1 = new Case (10) ;
Case c2 = new Case (15) ;
Case c3 = null ;
System.out.println (‘‘ c1 = =c2 :’’+c1.estEgal(c2)) ;
System.out.println (‘‘ c1= =c3 :’’+ c1.estEgal(c3)) ;
System.out.println (‘‘c1= =null:’’+c1.estEgal(null));
}
}
/* Le programme se compile correctement, en revanche son exécution est interrompue
à la ligne c1.estEgal(c3) puisque c3 = null et on ne peut pas accéder à c3.val (dans la
méthode
GL_IGE_SMIestEgal ) */

Chapitre 3 HERITAGE ET INTERFACES EN JAVA

1 – GENERALITES SUR L’HERITAGE EN JAVA

2 – LA CLASSE java.lang.Object

3 – MASQUAGE DES ATTRIBUTS ET


REDEFINITION DES METHODES
4 – CASTING OU TRANSTYPAGE

5 – LES INTERFACES

6 – LES CLASSES ABSTRAITES

GL_IGE_SMI

41
Chapitre 3 HERITAGE ET INTERFACES EN JAVA

1 – GENERALITES SUR L’HERITAGE EN JAVA

1 – 1 Définition de l’héritage

L’héritage est l’un des aspects les plus utiles de la


programmation orientée objet. Il permet à une classe de
transmettre ses attributs et ses méthodes à des sous classes.
Ainsi, si une classe B hérite d’une classe A, alors la classe B
contient implicitement l’ensemble des attributs non privés de A et
peut invoquer toutes les méthodes non privées de la classe A.

GL_IGE_SMI

1- 2 – Déclaration de l’héritage

En java, pour déclarer l’héritage, on utilise le mot clé extends

Syntaxe : class B extends A :


B hérite de A
B est dérivée de A
B est une sous classe de A
A est la super classe de B

GL_IGE_SMI

42
1-3 – Propriétés de l’héritage

-En java, l’héritage est simple, toute classe ne peut hériter que
d’une et une seule classe. Si une classe n’hérite d’aucune autre
classe, elle hérite par défaut de la super classe Object définie dans
la package java.lang

-Une référence à une classe de base peut être affectée d’une


référence à une classe dérivée, l’inverse doit faire l’objet d’une
opération de conversion de type ou cast :
class A {}
class B extends A {}
Soient les instructions : A a= new A();
B b= new B();
a=b; // possible
b= a; // faux
b= (B) a; // peut être possible
GL_IGE_SMI

1-3 – Propriétés de l’héritage


-Exemple :
class Pere
{ final String nom_famille; // nom de famille est constant par objet Pere
Pere (String nom_famille) // constructeur
{ this.nom_famille=nom_famille; } }
class Fils extends Pere
{String prenom;
Fils(String nom) // Constructeur
{super(nom);} // Appel du constructeur de la super classe (Pere)
public static void main(String[] arg)
{ Pere sonPere= new Pere("SEDRATI");
Fils monFils = new Fils(sonPere.nom_famille); // monFils est de type Pere
System.out.println(" Nom de famille de mon fils " + monFils.nom_famille);
monFils.prenom="Anass";
System.out.println(" Prénom de mon fils "+monFils.prenom);
// sonPere.prenom="Driss"; Faux
sonPere= monFils; // est possible car monFils est de même type que son père
monFils=sonPere; est faux ( la réciproque) }
}
GL_IGE_SMI

43
1-3 – Propriétés de l’héritage

-Si la déclaration d’une classe est précédée de final, alors cette


classe ne peut pas être une super classe

final class Mere


{}
class Fille extends Mere { }
// erreur de compilation car la classe Mere ne peut avoir d’enfants

- Si le constructeur par défaut d’une classe dérivée est défini mais


ne commence pas par un appel de constructeur de la classe mère,
Java insère un appel du constructeur par défaut de la classe mère.

GL_IGE_SMI

1-4- Opérateurs : super et instanceof

- L’opérateur super :
Pour faire référence à la classe parente (super
classe) , il suffit d’utiliser le mot clé super. Ce mot permet
d’invoquer un attribut ou une méthode de la super classe
On utilise super(arguments) pour invoquer le
constructeur de la super classe ayant les arguments
correspondants

- L’opérateur instanceof :
L’opérateur instanceof permet de savoir à quelle
classe appartient une instance :

GL_IGE_SMI

44
1-4- Opérateurs : super et instanceof
class A
{ }
class B extends A
{ }
public class C
{ public static void main(String[] arg)
{ A a= new A();
B b = new B();
C c = new C();
System.out.println( a instanceof A ); // true
System.out.println( a instanceof B );//false
System.out.println( b instanceof A );//true
System.out.println( b instanceof B );//true
a=b;
System.out.println( a instanceof A );//true
System.out.println( a instanceof B );//true
//System.out.println( c instanceof A ); :erreur de compilation
//(c et A ne sont pas de même type)
} }
GL_IGE_SMI

1-5- Un exemple de l’héritage

Prenons la hiérarchie suivante :

Personne

Fonctionnaires Profession_liberale Eleve


Chomeur

….

Avocat Commerçant Primaire


MedecinPublic Enseigantt

Les classes Fonctionnaire, Profession_liberale, Eleve et


Chomeur sont dérivés de la classe Personne

GL_IGE_SMI

45
1-5- Exemple
class Personne // la super classe
{
final String nom;
final int annee_naissance;
String adresse; // sauf pour les SDF!!
Personne(String nom,int annee_naissance)
{this.nom=nom;
this.annee_naissance= annee_naissance;}
String getNom()
{ return nom;}
int getNaissance()
{ return annee_naissance;}
public String toString()
{
return("Je suis "+getNom()+" et je suis" +
getClass().getNam());}
}
GL_IGE_SMI

1-5- Exemple
class Fonctionnaire extends Personne
{int numeroSomme;
double salaire;
String fonction;
Fonctionnaire(String nom,int annee_naissance,int numeroSomme)
{super(nom,annee_naissance);
this.numeroSomme=numeroSomme;
}
double getSalaire()
{ return salaire;}
}

class MedecinPublic extends Fonctionnaire


{ String specialite;
MedecinPublic(String nom,int annee_naissance,int numeroSomme,
String specialite)
{
super(nom,annee_naissance,numeroSomme);
this.specialite=specialite; }
}
GL_IGE_SMI

46
1-5- Exemple
class Profession_liberale extends Personne
{int numeroCNSS;
double salaire;
String fonction;
double patente; // impot
Profession_liberale(String nom,int annee_naissance,
int numeroCNSS)
{super(nom,annee_naissance);
this.numeroCNSS=numeroCNSS; }
}
class Chomeur extends Personne
{String diplome;
Chomeur(String nom,int annee_naissance)
{super(nom,annee_naissance);}
}
GL_IGE_SMI

1-5- Exemple
class Eleve extends Personne
{String classe;
int numeroEleve;
Eleve(String nom,int annee_naissance,String classe,
int numeroEleve)
{super(nom,annee_naissance);
this.numeroEleve=numeroEleve;
this.classe=classe; }
}

public class Heritage


{
public static void main(String[] arg)
{ Personne[] desPersonnes= new Personne[4];
desPersonnes[0]= new Fonctionnaire("F",1980,10);
desPersonnes[1]= new MedecinPublic("M",1970,100," cardiologue");
desPersonnes[2]= new Eleve("E",1990,"INE1",20);
desPersonnes[3]= new Chomeur("C",1980);
GL_IGE_SMI

47
1-5- Exemple

for(int i=0;i<desPersonnes.length;i++)
System.out.println(desPersonnes[i]);
}
}

- A l’exécution :
Je suis F et je suis Fonctionnaire
Je suis M et je suis MedecinPublic
Je suis E et je suis Eleve
Je suis C et je suis Chomeur

GL_IGE_SMI

2- LA CLASSE java.lang.Object
La classe d’entête public class Object est la super classe de
toutes les classes Java : toutes ses méthodes sont donc héritées par
toutes les classes.

Voici quelques méthodes élémentaires de la classe Object

2.1. La méthode public final Class getClass()


La méthode getClass() renvoie un objet de la classe Class qui représente
la classe de l'objet.

Le code suivant permet de connaitre le nom de la classe de l'objet

Exemple : String nomClasse = monObject.getClass().getName();

GL_IGE_SMI

48
2- LA CLASSE java.lang.Object
2-2 La méthode public String toString()
La méthode toString() permet d'obtenir la représentation d'un
objet quelconque par une chaîne de caractères. Ainsi lorsque une
référence r vers un objet de classe quelconque est dans une expression
en lieu et place d'une chaîne de caractères c'est en fait la chaîne
retournée par le message r.toString() qui est utilisée dans l'expression.
La méthode toString de la classe Object retourne une chaîne
correspondant au nom de la classe de l'objet suivi de @ suivi de
l'adresse mémoire de la structure de données définissant les
caractéristiques de l'objet (cette adresse est la valeur contenue dans la
variable référencant l'objet).
La méthode toString() est souvent redéfinie
GL_IGE_SMI

2- LA CLASSE java.lang.Object
Soit la classe Livre définie comme suit
public class Livre
{ double prix;
String titre;
String auteur;
public Livre(double p, String t, String a)
{ prix=p;
titre = t;
auteur = a;
}
public static void main(String[] arg)
{ Livre monLivre= new Livre(50.00,"Programmation en langage
Java", "SIL_S4");
System.out.println(monLivre);
// La classe Livre ne redéfinissant pas la méthode toSTring
// c'est celle héritée de la classe Object qui est invoquée.
}
}
// A l'exécution, on aura : Livre@ba34f2
GL_IGE_SMI

49
2- LA CLASSE java.lang.Object
Exemple 2 : Utilisation de la méthode toString() redéfinie

public class Livre2


{ String titre;
String auteur;
public Livre2(double p, String t, String a)
{ prix=p;
titre = t;
auteur = a;
}

public String toString()


{ return ("Titre : " +titre +"\n"+"Auteur : " +
auteur + "\n" + "Prix : " + prix);
}

GL_IGE_SMI

2- LA CLASSE java.lang.Object
Exemple 2 : Utilisation de la méthode toString() redéfinie
public static void main(String[] arg)
{ Livre2 monLivre= new Livre2(50.00,"Programmation en langage
Java",« Smestre_S4");
System.out.println(monLivre);
// La classe Livre redéfinit la méthode toSTring
// c'est celle redéfinie qui est invoquée.
}
}
- A l'exécution, on aura :
Titre : Programmation en langage Java
Auteur : Semestre_S4
Prix : 50.0
GL_IGE_SMI

50
2- LA CLASSE java.lang.Object

2-3. La méthode public boolean equals(Object obj)


La méthode equals() implémente une comparaison par défaut.
Sa définition dans Object compare les références : donc
obj1.equals(obj2) ne renverra true que si obj1 et obj2 désignent le
même objet. Dans une sous classe de Object, pour laquelle on a
besoin de pouvoir dire que deux objets distincts peuvent être égaux,
il faut redéfinir la méthode equals héritée de Object.
- Dans la classe Object cette méthode est définie comme suit :
public boolean equals(Object obj)
{ return (this == obj); }

GL_IGE_SMI

2- LA CLASSE java.lang.Object

2-3. La méthode public boolean equals(Object obj)


Exemple 1 : Utilisation de la méthode equals héritée
public class LivreCompare
{ double prix;
String titre;
String auteur;
public LivreCompare(double p, String t, String a)
{ prix=p;
titre = t;
auteur = a;
}
GL_IGE_SMI

51
2- LA CLASSE java.lang.Object
2-3. La méthode public boolean equals(Object obj)
Exemple 1 : Utilisation de la méthode equals héritée
public static void main(String[] arg)
{ LivreCompare l1 = new LivreCompare(500.00,"Programmation
en langage Java",« SIL_S4");
LivreCompare l2 = new LivreCompare(50.00,"Programmation en
langage Java", "SIL_S4");
System.out.print("Les livres référencés par l1 et l2 sont ");
if (l1.equals(l2))
/* ici équivalent à l1 == l2 puisque la méthode equals n'est pas
redéfinie. On compare le contenu des deux références l1 et l2 (c'est à
dire les adresses mémoire des deux Livres */
System.out.println("identiques");
else
System.out.println("différents"); }
}
- A l’exécution : les livres référencés par l1 et l2 sont différents
Remarque : Pour avoir un comportement plus conforme à ce que l'on attend
pour la méthode equals il faudrait redéfinir celle-ci
GL_IGE_SMI

2- LA CLASSE java.lang.Object
2-3. La méthode public boolean equals(Object obj)
Exemple 2 : Utilisation de la méthode equals redéfinie
public class LivreCompare2
{
double prix;
String titre;
String auteur;
public LivreCompare2(double p, String t, String a)
{ prix=p;
titre = t;
auteur = a; }
public boolean equals(LivreCompare2 l)
{ return (this.titre.equals(l.titre) && this.auteur.equals(l.auteur)
&& this.prix == l.prix); }
GL_IGE_SMI

52
2- LA CLASSE java.lang.Object
2-3. La méthode public boolean equals(Object obj)
Exemple 2 : Utilisation de la méthode equals redéfinie
public static void main(String[] arg)
{ LivreCompare2 l1 = new LivreCompare2 (50.00,
"Programmation en langage Java",« SIL_S4");
LivreCompare2 l2 = new LivreCompare2 (50.00,
"Programmation en langage Java",« SIL_S4");
System.out.print("Les livres référencés par l1 et l2 sont ");
if (l1.equals(l2)) // ici on compare les attributs de l1 et l2
System.out.println("identiques");
else
System.out.println("différents");
}
- A l’exécution : les livres référencés par l1 et l2 sont identiques
GL_IGE_SMI

3- Masquage des attributs et redéfinition des méthodes

- On dit qu’un attribut d’une classe masque un attribut


d’une super classe s’il a le même nom qu’un attribut de la super
classe
- On dit qu’une classe redéfinit une méthode d’une super
classe si elle définie une méthode ayant même nom, même suite
de types d’arguments et même valeur de retour qu’une méthode
de la super classe

Il y’a une différence dans la façon dont le masquage d’attributs et


la redéfinition des méthodes sont traitées en java

GL_IGE_SMI

53
3- Masquage des attributs et redéfinition des méthodes

Supposons qu’une classe A possède un attribut attr et une méthode


meth et qu’une classe B étendant A définisse un attribut de même nom attr et
redéfinisse la méthode meth.
Considérons alors les déclarations suivantes :
A a // déclaration d’ un objet a de la classe A
B b = new B() ; // declaration et creation d’un objet b de la classe B
a = b ; // Tout objet de B est objet de A
Alors :
b.attr est l’attribut attr de la classe B
a.attr est l’attribut attr de la classe A
Par contre :
b.meth est la méthode redéfinie dans B
a.meth est la méthode redéfinie dans B

GL_IGE_SMI

class A
{ int attr=10;
void meth()
{ System.out.println("Je suis la méthode de A"); }
}
class B extends A
{
int attr=20;
void meth()
{ System.out.println("Je suis la méthode de B"); }
}
public class Masque
{ public static void main(String[] argv)
{Aa;
B b = new B();
System.out.println("b.attr= "+b.attr);
System.out.println("a.attr= "+a.attr);
b.meth();
a.meth(); }
}
GL_IGE_SMI

54
A l'exécution , on aura :
b.attr= 20
a.attr= 10
Je suis la méthode de B
Je suis la méthode de A */

GL_IGE_SMI

4- casting ou transtypage

Le casting (mot anglais qui signifie moulage ), également appelé transtypage,


consiste à effectuer une conversion d’un type vers un autre type. Le casting peut être
effectué dans deux conditions différentes :

· Vers un type plus général. On parle alors de sur-casting.

· Vers un type plus particulier. On parle alors de sous- casting.

- Dans le cas des primitives, le sur-casting consiste à convertir vers un type


dont la précision est supérieure. C'est le cas, par exemple, de la conversion d'un
byte en short, d'un int en long ou d'un float en double. On parlera en revanche de
sous-casting lors de la conversion d'un type vers un autre de précision inférieure,
par exemple de double en float, de long en int ou de short en byte.

GL_IGE_SMI

55
Casting des objets

Il est possible d’utiliser le casting d’objets. Cela nécessite une


conversion de classe.
Exemple :

class Animal
{}

class Chien extends Animal


{ int taille = 80; }

class Conversion
{ public static void main (String[] argv)
{
Chien chien; // déclaration d’un objet de type Chien
Animal animal = new Chien ();
chien = (Chien)animal;
System.out.println(" Ce chien mesure : "+ chien.taille +" cm");
GL_IGE_SMI

Casting des objets

animal = new Animal(); // création d’un objet de type Animal


// chien = (Chien)animal; //erreur d’execution
System.out.println(" Tout animal ne peut pas être converti en
chien");
}
}

A l’exécution :
Ce chien mesure : 80 cm
Tout animal ne peut pas être converti en chien

GL_IGE_SMI

56
5 - LES INTERFACES

5-1 – Définition d’une interface

Une interface est un type purement abstrait au sens où il ne définit


aucune implémentation et ne comporte pas de constructeur : une
interface déclare uniquement des méthodes publiques
Une interface ne contient que des prototypes de méthodes et des
constantes ayant les modificateurs static et final
Une interface sert à regrouper des constantes et à traiter des
objets qui ne sont pas tous nécessairement de la même classe mais
qui ont en commun une partie . Cette partie sera gérée par l’interface
Les interfaces portent souvent des noms se terminant en able. Par
exemple (Comparable ,Runnable, …)

GL_IGE_SMI

Remarques :

- Une interface peut avoir le modificateur public .

- Une interface est toujours abstract sans qu’il soit nécessaire de


l’indiquer

- Elle peut être attribuée à un package . Si elle ne l’est pas, elle fera
partie du package par défaut

- Une interface peut dériver de plusieurs autres interfaces ( héritage


multiple pour les interfaces et non pas pour les classes)

interface I1
{}

abstract interface I2 //abstract n’est âs nécessaire


{}

public interface I3 extends I1,I2 //héritage multiple


{}
GL_IGE_SMI

57
Corps d’une interface

Le corps d’une interface contient une liste de constantes et de


prototypes de méthodes.

La syntaxe d’une déclaration d’une interface est la suivante :


entête
{
déclarations des constantes et des prototypes de méthodes
}
Exemple : interface Ecriture
{ static final int LIGNE_MAX = 50 ;
void ecrire() ;
}
GL_IGE_SMI

6 – DEFINITION D’UNE CLASSE ABSTRAITE

- Une classe abstraite est une classe qui contient au


moins une méthode abstraite, elle doit être déclarée avec le
modificateur abstract

- Dans une classe, une méthode est dite abstraite si


seul son prototype figure. Elle n’a pas de définition explicite

- Une classe abstraite ne peut pas être instanciée , il


faut l’étendre pour pouvoir l’utiliser

GL_IGE_SMI

58
Chapitre 4 LES COLLECTIONS DE DONNEES

INTRODUCTION
1- GENERALITES SUR LES COLLECTIONS EN JAVA
2- L’INTERFACE java.util.Collection
3- LES LISTES
4- LES ENSEMBLES
5- LES MAP
6- LES CLASSES UTILITAIRES

GL_IGE_SMI

1- GENERALITES SUR LES COLLECTIONS JAVA


1-1 Définition d’une collection
Une collection représente un groupe d'objets, connu par ses
éléments et utilisé pour stocker, rechercher et manipuler ces éléments
Les collections peuvent permettre des éléments en double (ou
doublons) à l'image des listes, ou parfois les interdisent telles que les
ensembles.
Le langage Java dispose de plusieurs outils destinés à gérer des
collections d’une façon unifiée qui met en oeuvre :
- des interfaces qui permettent la manipulation des collections
indépendamment de leurs représentations (l’interface Collection,
l’interface List, …)
- des classes qui implémentent les interfaces précédentes (la
classe Vector, ArrayList,…)
- des méthodes qui réalisent des opérations utiles (add(…),
contains(…),..)
GL_IGE_SMI

59
1- GENERALITES SUR LES COLLECTIONS JAVA
1-2 Organisation des collections
L’ensemble de ces outils java (interfaces, classes,
méthodes) qui permettent la mise en œuvre des collections
est organisé dans le package java.util selon deux
hiérarchies :
L’interface java.util.Collection et l’interface java.util.Map

GL_IGE_SMI

Chapitre4 LES APPLETS

INTRODUCTION

1 – LE LANGAGE HTML

2 – LES PRINCIPALES METHODES DE LA CLASSE


APPLET

3 – CREATION D’UNE APPLET

4 – EXEMPLE D’UNE APPLET

5- TRANSMISSION DE PARAMETRES A UNE APPLET

GL_IGE_SMI

60
Chapitre4 LES APPLETS

INTRODUCTION

Une applet est une application écrite en java et qui tourne à


travers le web dans un logiciel de navigation (les logiciels de
navigation les plus utilisés sont Internet Explorer, Netscape
Navigator, google chrome).

Pour publier une applet sur Internet , il faut d’abord créer une
page HTML. L’applet est référencée dans la page HTML et exécutée
par le logiciel de navigation.

GL_IGE_SMI

Chapitre4 LES APPLETS

1 – LE LANGAGE HTML

Le langage HTML (Hyper Text Markup Language) est un


langage universel de structuration de documents hypertextuels
indépendants des plates – formes
Il est basé sur les balises ou les tags qui permettent de
formater le texte. Les balises servent aussi à appeler des contenus
externes (image, animation, son, …)
- Pour afficher une image dans une page HTML, on écrit :
<img scr = « URL + Nom du fichier »
- Les fichiers de sons et les fichiers vidéo sont intégrés au
moyen du tag <embed> . La syntaxe est la suivante :
<embed scr = « URL + Nom du fichier »

GL_IGE_SMI

61
Chapitre4 LES APPLETS
Les liens dans une page HTML
Dans une page HTML , on peut définir des liens qui représentent
des sauts vers d’ autres endroits. Pour identifier la cible vers la quelle doit
pointer le lien., on utilise la balise a (ancre), cette balise a un attribut href
(hypertext reference) ; celui ci doit contenir une URL qui pointe sur un
document ou sur une partie du document
Il existe deux types de liens, des liens internes qui renvoient à un
emplacement situé dans le même document et des liens externes qui
appellent un autre document figurant dans le même ordinateur serveur ou
sur un autre géographiquement éloigné.

Lien interne : <a href= «#nom de l’ancrage» texte1 ou image1</a>


<a name= «nom de l’ancrag » texte2 ou image2 </a>
- Si on clique sur texte1 ou image1 , on va directement au texte2
ou à l’image2 spécifiée dans le tag <a name…>
Lien externe : <a href= «adresse URL» texte ou image </a>
- Si on clique sur le texte ou l’image, on va se déplacer vers l’URL
spécifiée
GL_IGE_SMI

Chapitre4 LES APPLETS

2 – LES PRINCIPALES METHODES DE LA CLASSE


Applet

Pour écrire une applet en java, il faut étendre (hériter) de la


classe Applet du package java.applet

La hiérarchie d’héritage de la classe Applet est la suivante :

java.lang.Object
java.awt.Component
java.awt.Container
java.awt.Panel
java.applet.Applet

GL_IGE_SMI

62
Chapitre4 LES APPLETS

2 – LES PRINCIPALES METHODES DE LA CLASSE


Applet

Les principales méthodes de la classes Applet :


-La méthode init() : appelé automatiquement par le browser pour initialiser
tous les objets et variables de l’applet.

-- La méthode start() : appelé automatiquement par le browser pour


démarrer l’applet. Elle exécutée à chaque démarrage de l’applet

-la méthode stop() : appelé automatiquement par le browser pour


interrompre l’exécution d’une applet

-La méthode destroy() : appelé automatiquement par le browser pour


fermer et finir l’exécution d’une applet

- La méthode paint() : pour afficher la fenêtre de l’applet.


GL_IGE_SMI

Chapitre4 LES APPLETS

3 – CREATION D’UNE APPLET

Une applet est incluse dans une page HTML sous la forme d’une
référence qui indique l’endroit où le logiciel de navigation doit aller la
chercher
La balise APPLET s’utilise comme n’importe quelle commande HTML.
Sa syntaxe est la suivante :
<APPLET CODE= ‘’Nomclass.class’’ widht = w height=h >
</APPLET>
NomClasse : indique le nom de la classe définissant l’applet
w et h désignent la largeur et la hauteur (en pixels) de la zone
de la page html destinée à représenter l’applet
GL_IGE_SMI

63
Chapitre4 LES APPLETS

3 – CREATION D’UNE APPLET

La balise APPLET peut comporter quelques attributs


facultatifs :
codebase : dans le cas où l’applet ne se trouve pas dans le même dossier
que le fichier HTML, il faut indiquer l’adresse de la classe définissant
l’applet par rapport à l’URL de la page HTML (en partant du dossier de la
page HTML). Le paramètre codebase est placé à la suite du paramètre
code
CODE = nom de l’applet codebase = chemin (nom du dossier)
Hspace/vspace : les paramètres hspace (espacement horizontal) et
vspace (espacement vertical) servent à fixer la distance en pixels entre
l’applet et le texte
align : Ce paramètre détermine la position relative de l’applet dans la
fenêtre. Les valeurs possibles sont : left, top, texttop,middle,
absmiddle, bottom, absbottom
GL_IGE_SMI

Chapitre4 LES APPLETS

3 – CREATION D’UNE APPLET

Pour créer et exécuter une applet , il faut suivre ces


étapes :
1 – Ecrire le code source de la classe qui définit l’applet et
l’enregistrer sous le nom de la classe .java
2 – Compilation et création du fichier .class
3 -Création du fichier HTML faisant référence à l’applet
4 - Le test de l’applet

GL_IGE_SMI

64
Chapitre4 LES APPLETS

4 – EXEMPLE D’UNE APPLET


1 ère étape le code source

import java.applet.Applet ;
import java.awt.Graphics ; // l’applet est une fenêtre graphique

public class Helloworld extends Applet


{
public void paint (Graphics g)
{
g.drawString(‘’ Hello World ‘’ , 20, 25);
/* affiche la chaine aux coordonnées spécifiées */
}
}
Ce code sera contenu dans un fichier de nom Helloworld.java

GL_IGE_SMI

Chapitre4 LES APPLETS

4 – EXEMPLE D’UNE APPLE


2ème étape la compilation
Une fois le code enregistré dans le fichier Helloworld.java. On
le compile pour obtenir le fichier Helloword.class

3ème étape Création du fichier HTML

<HTML>

<applet code = ‘’ Helloworld.class’’ width=100 height=50>

</applet>

</HTML>

On enregistre ce code dans un fichier .html (dans le même


dossier que le fichier Helloworld.class )
GL_IGE_SMI

65
Chapitre 5 LES INTERFACES GRAPHIQUES
INTRODUCTION

A - LE PACKAGE java.awt

1– LES POSSIBILITES de java.awt

2 -LES PRINCIPALES CLASSES DE java.awt

3 – LES COMPOSANTS DE L’INTERFACE


GRAPHIQUE

4 – LES GESTIONNAIRES DE MISE EN PAGE

5- LES CONTENEURS

6- LES EVENEMENTS ET LES ACTIONS


GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

INTRODUCTION

Il existe en java plusieurs packages dédiés au graphisme,


les plus utilisés sont :

- Le paquetage java.awt (Abstract Windowing Toolkit) fournit au


programmeur toutes les classes nécessaires à la gestion du
graphisme . Cette librairie de classes est destinée à fonctionner
sur toute plate forme ( Windows, MacOs, X- Window)

- Le paquetage javax.swing disponible depuis la version jdk1.2


offre beaucoup plus de composants graphiques que le package
java.awt et l’apparence des composants dans javax.swing est
totalement différente. javax.swing permet de réaliser de véritables
interfaces homme-machine.
GL_IGE_SMI

66
Chapitre 5 LES INTERFACES GRAPHIQUES

INTRODUCTION

Principes de base de java.awt et javax.swing

awt et Swing permettent de créer et gérer une interface graphique


en utilisant les mêmes principes :

- Créer un cadre ( un objet de la classe conteneur),

- Créer des composants (objets de la classe Component)

-Utiliser une mise en page pour ces composants,

- Insérer les composants dans le cadre

- Utiliser des méthodes en réponse aux actions de l’utilisateur.

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

A - LE PACKAGE java.awt

1 – LES POSSIBILITES de java.awt

Avec java.awt, on peut par exemple :

- Tracer différentes formes (polygones,, ovales, …)

- Définir des polices de caractères, des couleurs, …

- Créer des composants simples (boutons, cases à cocher, )

- Créer des composants complexes ( menus déroulants, …

- Gérer des événements utilisateurs (clique sur un bouton, coche


sur une case, …)

GL_IGE_SMI

67
Chapitre 5 LES INTERFACES GRAPHIQUES
2 – LES PRINCIPALES CLASSES DE java.awt
2-1 La classe Graphics

La classe java.awt.Graphics comporte un nombre important de méthodes


permettant de tracer des formes géométriques vides ou pleines. Voici un échantillon
des méthodes de Graphics :

* drawLine(int x1,int y1,int x2 ,int y2) : affiche le segment de (x1,y1) à (x2,y2).

Remarque : Les segments tracés en java ont une largeur égale à un point d’écran. Pour
tracer un segment plus épais , on doit tracer plusieurs segments parallèles

Le système de coordonnées x et y dans une fenêtre graphique ou une applet est


déterminé par son origine (0,0) qui est l’angle supérieur gauche de la fenêtre.
(0,0) 50

20
(50,20)

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

2-1 La classe Graphics


Exemple d’application de traçage de segment

import java.awt.*;
class TraceLigne extends Frame
{
TraceLigne( String titre) // Constructeur
{
super (titre);
/* appel au constructeur de la super classe de Traceligne (Frame) qui dessine une
fenêtre invisible et appelle automatiquement la méthode paint */
}
public void paint(Graphics g) // méthode redéfinie
{ g.setColor(Color.blue);
// dessin d’une ligne épaisse (2 pixels d’épaisseur
g.drawLine(50,65,150,100);
g.drawLine(50,66,150,101);
}
GL_IGE_SMI

68
Chapitre 5 LES INTERFACES GRAPHIQUES

2-1 La classe Graphics


public static void main(String[] argv)
{
TraceLigne monDessin = new TraceLigne("Une ligne");

monDessin.setSize(400, 400); // taille de la fenêtre

monDessin.setVisible(true);
/* la méthode setVisible(boolean) de la classe java.awt.component rend visible ou cache le
composant en fonction de l’état du boolean */
} // fin de main
} // fin de la classe

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

2-1 La classe Graphics

* drawString (String texte, int x, int y) : affiche la chaîne de caractères


texte aux coordonnées (x,y) dans une fenêtre graphique ou une
applety

* drawRect(int x1, int y1, int larg , int haut) affiche un rectangle vide
à partir du point (x1,y1) de largeur larg et de hauteur haut

(x1,y1)

hauteur

larg : largeur

* fillRect(int x1, int y1, int larg , int haut) affiche un rectangle plein à
partir du point (x1,y1) de largeur larg et de hauteur haut. La couleur de
remplissage du rectangle plein est la couleur courante
GL_IGE_SMI

69
Chapitre 5 LES INTERFACES GRAPHIQUES

2-1 La classe Graphics


Exemple d’application de traçage de rectangle’

import java.awt.*;
class TraceRect extends Frame
{
int x=50, y=60, largeur=150 , hauteur=100;
Color couleur=Color.red ; // déclaration d'un objet couleur
TraceRect (String titre)
{ super (titre); }
public void paint(Graphics g)
{
g.setColor(couleur);
g.drawRect(x,y,largeur,hauteur);
g.fillRect(x,y+150,largeur,hauteur); // rectangle plein
}
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

2-1 La classe Graphics


Exemple d’application de traçage de rectangle

public static void main(String[ ] argv)


{
TraceRect monDessin = new TraceRect ("Des Rectangles");
monDessin.setSize(400, 400);
monDessin.setVisible(true);
} // fin de main

} // fin de la classe

GL_IGE_SMI

70
Chapitre 5 LES INTERFACES GRAPHIQUES

2-1 La classe Graphics

* drawOval (int x, int y, int largeur, int hauteur) affiche un ovale vide de
coin supérieur gauche de coordonnées (x,y) et de largeur et hauteur
définis
(x,y)
Largeur
Largeur

Hauteur
Dans le cas d’un cercle largeur = hauteur = diamètre

* fillOval (int x, int y, int largeur, int hauteur) affiche un ovale plein

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

2-1 La classe Graphics


* drawPolygon (xpoints, ypoints, points) , trace un polygone
vide fermé en joignant les points un à un et en joignant le dernier point
au premier. xpoints est un tableau d’entiers réservés aux abscisses, et
ypoints est un tableau d’entiers réservés aux ordonnés et points est le
nombre de points à, relier

* fillPolygon (xpoints, ypoints, points) trace un polygone plein


Exemple de traçage de polygone (un triangle)
import java.awt.*;
class TracePoly extends Frame
{ int[ ] xPoints ={150,40,300}; // les abscisses des points
int[ ] yPoints ={40,240,240}; // les ordonnées des points
int points=3; // le nombre de points (3 c’est un triangle)
Color couleur ;
TracePoly(String titre) // Constructeur
{ super (titre); }
GL_IGE_SMI

71
Chapitre 5 LES INTERFACES GRAPHIQUES

2-1 La classe Graphics


public void paint(Graphics g)
{ couleur= Color.red;
g.setColor(couleur);
g.fillPolygon(xPoints,yPoints,points);
}
public static void main(String[] argv)
{ TracePoly monDessin = new TracePoly("Un triangle");
monDessin.setSize(400, 400);
monDessin.setVisible(true); }
}

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

2-2 La classe java.awt.Color

La classe java.awt.Color permet la gestion des couleurs en


java. Les couleurs peuvent être spécifiées de plusieurs manières
différentes car la classe Color offre plusieurs constructeurs :
- On peut utiliser des noms standards prédéfinis avec la
syntaxe :
Color.nom_de_la_couleur

Les noms de couleurs prédéfinis sont les suivants : black,


blue, cyan, darkGray, gray, green, lightGray, magneta, orange, pink,
red, white, yellow.

GL_IGE_SMI

72
Chapitre 5 LES INTERFACES GRAPHIQUES

2-2 La classe java.awt.Color

- On peut aussi spécifier une couleur à l’aide de trois nombres


entiers compris entre 0 et 255. Ces trois nombres représentent les 3
valeurs RGB (Red, Green, Blue) de la couleur

Exemple : Color bleu = new Color (0,0,255) ;


Color blanc = new Color (255, 255, 255) ;
Color noir = new Color (0,0,0) ;
Color maCouleur = new Color (150,200,250) ;

-On peut aussi spécifier une couleur à l’aide de trois nombres floats
compris entre 0.0 et 1.0
-Ces trois nombres représentent les 3 valeurs RGB
Color rouge = new Color(1.0f, 0.0f, 0.0f) ;
Color blanc = new Color(1.0f, 1.0f, 1.0f) ;

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

2-2 La classe java.awt.Color

* Pour afficher un texte ou un graphique dans une couleur


spécifique, on utilise la méthode setColor(couleur) de la classe
java.awt.Graphics

* Pour attribuer une couleur d’arrière plan à une fenêtre, on


utilise la méthode setBackground(couleur)

GL_IGE_SMI

73
Chapitre 5 LES INTERFACES GRAPHIQUES

2-3 La classe java.awt.Font


L’affichage des caractères est définie par trois éléments :
- Le nom de la police : Helvetica, Courier, Dialog, Times ,…
- Le style de la police : gras, italique ou normal
- La taille de la police en points

Pour afficher un texte dans une police définie, avec un style


défini et une taille précise, on doit créer un objet Font qui contient ces
informations. Le constructeur de la classe Font est :
Font(String nom, int style, int taille)
nom : nom de la police de la JVM ;
style : style de la police qui peut être l’une des constantes :
Font.PLAIN : texte normal
Font.BOLD : texte gras
Font.ITALIC : texte italique
taille : précise la taille de la police en pixels
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

• La liste des polices de la JVM est retournée par la méthode


getFontList() de la classe java.awt.Toolkit.

Exemple d’affichage des polices disponibles


import java.awt.*;
public class ListePolices extends Frame
{
ListePolices (String titre)
{ super(titre); }
public void paint (Graphics g)
{ int x=20;
int y=20;
String polices[ ] = getToolkit().getFontList();
for (int i=0 ; i<polices.length; i++)
{ g.drawString(polices[i], x, y) ;
y+=20 ; }
} // fin de paint
GL_IGE_SMI

74
Chapitre 5 LES INTERFACES GRAPHIQUES

2-3 La classe java.awt.Font

Exemple d’affichage des polices disponibles

public static void main (String[ ] argv)


{ ListePolice maListe= new ListePolice("polices");
maListe.setSize(400,400);
maListe.setVisible(true);
} // fin de main
} // fin de la classe ListePolices

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

* Pour attribuer un font à un texte on utilise la méthode :


public void setFont(Font font) de la classe java.awt.Graphics

Exemple d’utilisation de la classe Font

import java.awt.*;
public class UtiliseFont extends Frame
{ UtiliseFont(String titre)
{ super(titre); }
public void paint (Graphics g)
{
Font ft= new Font("Serif",Font.BOLD,20);
g.setFont(ft);
g.setColor(Color.red);
g.drawString("ATTENTION DANGER",100,100);
}
GL_IGE_SMI

75
Chapitre 5 LES INTERFACES GRAPHIQUES

2-2 La classe java.awt.Font

public static void main (String[] argv)


{ UtiliseFont monTexte= new UtiliseFont("Les Fonts");
monTexte.setSize(400,400);
monTexte.setVisible(true);
} // fin de main
} // fin de la classe

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE

En java, les éléments de l’interface utilisateur sont des


composants. Ce sont des objets dérivant de la classe
java.awt.Component.

Chaque type d'objet de l'interface graphique (bouton, case à


cocher, liste, menu…) est une classe dérivée de Component.

La classe java.awt.Container , qui hérite de Component est un


espace capable de contenir plusieurs objets de la classe Component .
Par exemple une fenêtre (Frame) ou une applet

GL_IGE_SMI

76
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Voici une partie de la hiérarchie de la classe java.awt.Compenent
java.awt.Compenent
Button (bouton)
Canvas(surface de dessin)
Checkbox (case à cocher)
Container
Panel (conteneur simple)
Applet
Window (fenêtre sans cadre ni titre)
Dialog (fenêtre de dialogue)
Frame (fenêtre avec cadre et titre)
Label (étiquette)
Ce diagramme définie les relations d’héritage des classes
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE

Pour utiliser des composants , il faut

- Créer un espace conteneur (Frame, Panel, Window, ..),


- Créer des composants (Bouton, CheckBox, …)
- Utiliser une mise en page pour ces composants,
- Insérer les composants dans l’espace

Pour insérer des composants dans un conteneur on utilise la


méthode add() de la classe java.awt.Component

GL_IGE_SMI

77
Chapitre 5 LES INTERFACES GRAPHIQUES

3-1 Les boutons

Les boutons sont les contrôles de tout écran d’interface, ils


permettent de déclencher des événements. En java.awt un bouton est
représenté par un objet de la classe java.awt.Button
Exemple d’utilisation de boutons dans une applet:
// Fichier DemoBouton.java
import java.awt.*;
public class DemoBouton extends java.applet.Applet
{
Button monBouton1;
Button monBouton2;

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


3-1 Les boutons

public void init ()


{
monBouton1 = new Button();
monBouton2 = new Button();
monBouton1.setLabel("bouton 1 ");
monBouton2.setLabel("bouton 2");
add(monBouton1) ; // pour insérer le bouton dans l’applet
add(monBouton2) ;
}
}

GL_IGE_SMI

78
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE

3-1 Les boutons

<! Fichier DemoBouton.htm>


<HTML>
<applet code = " DemoBouton.class" width=200 height=200>
</applet>
</HTML>

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


3-2 Les étiquettes

Une étiquette (label) est une chaîne de caractères qui ne


dépasse pas une ligne et qui permet d’afficher un texte qui n’est pas
interactif. Son rôle consiste à donner des informations sur les autres
contrôles , notamment les zones de saisie.
Pour accéder à une étiquette, il faut d’abord déclarer un objet
de la classe java.awt.Label
Label l = new Label (« Je suis une étiquette ») ;
add(l) ; // Affichage de l’étiquette sur la fenêtre
On peut modifier le texte d’un label en appelant sa méthode setText()
l.setText(« le nouveau texte ») ;
GL_IGE_SMI

79
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


3-3 les boîtes de dialogues
Les cases à cocher
Un composant. Checkbox est une case placée à côté d’une
ligne de texte et qui peut être cochée par l’utilisateur.
Les cases à cocher sont très utilisées dans les programmes
d’installation, les fenêtres de configuration ou d’une manière générale
dans les boîtes de dialogue
Chaque case à cocher ( Checkbox )représente un état booléen, vrai ou
faux selon qu’elle est cochée ou non.
Pour gérer les cases à cocher, on utilise la classe java.awt.Checkbox
Checkbox cb= new Checkbox() ; // crée une case à cocher
Checkbox cb= new Checkbox(String) ; // crée une case à
cocher affiche le texte en argument à côté de la case à cocher
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


3-3 les boîtes de dialogues
Les cases à cocher
L’état d’une case à cocher

cb.setState(boolean) ; // true pour cocher, false pour décocher

boolean etat=cb.getState() ; //retourne true si activée, false sinon

cb.getLabel() retourne la chaîne de caractères correspondant à


l’étiquette de la case à cocher

GL_IGE_SMI

80
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Pour savoir si une action a été déclenchée par l’utilisateur(
pression d’un bouton, coche d’une case,….), il faut appeler une
méthode écouteur (Listener) par exemple la méthode action :

public boolean action(Event e , Object arg) de la classe


java.awt.Component est appelée automatiquement lorsqu’une action
est déclenchée par l’utilisateur et traite les événements survenus
pendant l’exécution de l’application ou de l’applet.

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES


3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE
Exemple: L’application suivante permet d’afficher une case à cocher
de nom Test . Si l’utilisateur active cette case le message Case activée
sera affichée, sinon le message Case désactivée sera affichée

import java.awt.*;
class DemoCheckbox extends Frame
{
static boolean etat = false;
Checkbox test;
DemoCheckBox(String titre)
{ super (titre);
FlowLayout fl=new FlowLayout(); // gestionnaire de mise en page
setLayout(fl);
test=new Checkbox("TEST");
add(test);
}
GL_IGE_SMI

81
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


public boolean action(Event e,Object arg)
{
if (test.getState())
etat=true;
else
etat=false;
repaint(); // force la méthode paint()
return (true);
}
public void paint(Graphics g)
{ g.setColor(Color.red);
g.setFont(new Font("Helevetica",Font.BOLD,20));
if (etat==true)
g.drawString("Case activée",50,300);
else
g.drawString("Case désactivée",50,300); }
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


public static void main(String[] argv)
{
DemoCheckBox maCase = new DemoCheckBox("Case à cocher");
maCase.setSize(400, 400);
maCase.setVisible(true);
} // fin de main
} // fin de la classe

A l’exécution, on aura

GL_IGE_SMI

82
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Les Boutons radio
Une case à cocher peut être affichée individuellement ou dans un groupe.
Les boutons radio sont des cases à cocher rassemblées dans un groupe. A
l’intérieur du groupe, on ne peut activer qu’une seule case à la fois. La classe
java.awt.CheckboxGroup permet de créer des groupes de boutons radio
CheckboxGroup br ; // déclaration d’un groupe de boutons radio
Checkbox b1= new Checkbox(« étiquette1 », état1, br) ;
Checkbox b2= new Checkbox(« étiquette2 », état2, br) ;
:
:
Checkbox bn= new Checkbox(« étiquetten », étatn, br) ;
- étiquetten est l’étiquette du bouton radio
- etatn est l’état du bouton : true ou false
- br est le nom du groupe des boutons radio

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE

Les Boutons radio

Exemple : Ecrire une application en java qui permet d’afficher cinq


boutons radio correspondant au statut possible d’une personne
(célibataire, marié, divorcé, veuf, autre)
import java.awt.*;
class DemoCheckboxGroup extends Frame
{
CheckboxGroup status;
Checkbox celibataire,marie,divorce,veuf,autre;

GL_IGE_SMI

83
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Les Boutons radio
DemoCheckboxGroup(String titre)
{ super (titre);
FlowLayout fl=new FlowLayout();
setLayout(fl);
status = new CheckboxGroup();
celibataire=new Checkbox("Célibataire",true,status);
add(celibataire);
marie =new Checkbox("Marié(e)",false,status);
add(marie);
divorce=new Checkbox("Divorcé(e)",false,status);
add(divorce);
veuf=new Checkbox("Veuf(ve)",false,status);
add(veuf);
autre=new Checkbox("Autre",false,status);
add(autre); }
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


public static void main(String[] argv)
{ DemoCheckboxGroup monStatus = new
DemoCheckboxGroup("Status");
monStatus.setSize(400, 400);
monStatus.setVisible(true);
}
} cette application crée cinq boutons radio . Le bouton
célibataire est coché initialement , mais si l’utilisateur coche une autre
bouton du groupe status, la coche de célibataire sera
automatiquement supprimé (dans un CheckboxGroup un seul bouton
doit être coché la à la fois)
- La méthode getCurrent() de la classe CheckboxGroup retourne
l’objet Checkbox correspondant à la réponse seléctionnée

GL_IGE_SMI

84
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


3-4 Les listes déroulantes
Les listes déroulantes sont des composants qui permettent de
sélectionner des éléments dans une liste

Les listes à choix unique


Java permet de créer une liste déroulante à choix unique par
l’intermédiaire de la classe java.awt.Choice
L’objet Choice permet à l’utilisateur de choisir une valeur unique parmi
une liste. La syntaxe est la suivante :
Choice maListe = new Choice() ;
maListe.addItem(«choix 1») ;
maListe.addItem(«choix 2») ;
:
:
maListe.addItem(« choix n ») ;
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Les listes à choix unique
Gestion des sélections
maListe.select(indice) ;// sélectionne un élément par son indice
l’indice est un entier correspondant à l’ordre de l’élément dans la liste. 0 est
l’indice du premier élément
maListe.select(élement) ;// sélectionne un élément par son contenu
maListe.countItems() // retourne le nombre d’éléments de la liste

maListe.getItem(n) // retourne le contenu de l’élément n


maListe.getSelectedItem() //retourne le contenu de l’élément
sélectionné
maListe.getSelectedIndex() // retourne l’indice de l’élément sélectionné
GL_IGE_SMI

85
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Exemple : Une application java qui crée une liste déroulante de trois
éléments (JAUNE, ROSE, BLEU). La couleur sélectionnée est
appliquée à l’arrière plan de la fenêtre
import java.awt.*;
public class DemoChoice extends Frame
{
String str; // str contiendra la couleur choisit
Choice choix= new Choice(); // création d'une liste de choix
DemoChoice(String titre) // constructeur
{ super (titre);
choix.addItem("JAUNE");
choix.addItem("ROSE");
choix.addItem("BLEU");
add(choix);
}

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


public boolean action(Event e,Object arg)
{
str= choix.getSelectedItem();
repaint();
return (true);
}
public void paint(Graphics g)
{
if (str=="JAUNE")setBackground(Color.yellow);
else
if (str=="ROSE")setBackground(Color.pink);
else
if (str=="BLEU")setBackground(Color.blue);
}
GL_IGE_SMI

86
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE

public static void main(String[] argv)


{
DemoChoice monChoix = new DemoChoice("Couleur de l'arrière
plan");
monChoix.setSize(400, 400);
monChoix.setVisible(true); }
}

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Les listes à choix multiple

Une liste à choix multiple permet d’afficher une liste de choix


dans un cadre. Elle permet d’afficher plusieurs lignes et la sélection de
plusieurs éléments.
Pour gérer une liste à choix multiple, on doit faire appel à la
classe java.awt.List
La classe List contient plusieurs constructeurs, le constructeur
le plus intéressant est List ( int i, boolean valeur). Le premier
paramètre i définit le nombre de lignes qui seront affichées, et la
valeur indique si l’on autorise la sélection multiple (true) ou non.

GL_IGE_SMI

87
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Les listes à choix multiple

Une fois l’instance crée, on ajoute des propositions avec


addItem(String)
La classe List dispose d’un grand nombre de fonctions pour gérer
et consulter les informations mémorisées

List li = new List(nbligne, multiSelect) ; // Déclare et initialise une liste


li.addItem(String s) ; // ajoute l’élément s à la fin de la liste li
li.addItem(String s, int indice) ; // insère l’élément s à la position
indice, le premier élément de la liste a pour indice 0

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES


3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE
Les listes à choix multiple

li.delItem(int indice) ; // supprime l’élément qui est à la position indice


li.delItems(int indice1, int indice2) ;
// supprime les éléments qui sont entre les positions indice1 et //indice2
li.clear() ; // efface complètement le contenu de la liste
li.countItems() ; // retourne un entier correspondant au nombre
d’éléments de la liste

li.getItem(indice) ; // retourne une chaîne de caractères qui est le


//contenu de l’élément d’indice indice

GL_IGE_SMI

88
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Les listes à choix multiple
li.select(indice) ; // sélectionne l’élément d’indice indice
li.setMultipleSelections() ; // est un booléen qui retourne true si la
sélection multiple est autorisée, false sinon
li.deselect(indice) ; // désélectionne l’élément d’indice indice
li.getSelectedIndex();//renvoie l’indice de l’élément sélectionné en
cas de sélection simple. En absence de sélection, le résultat est -1
li.getSelectedIndexes () ; // renvoie un tableau de type int qui
contient les indices de tous les éléments sélectionnés en cas de
sélection multiple
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Les listes à choix multiple
li.getSelectedItem () ;// s’utilise dans le cas d’une sélection simple,
renvoie une chaîne de caractères qui contient le texte de l’élément
sélectionné , ou null en absence de sélection

li.getSelectedItems () ;// s’utilise dans le cas d’une sélection


multiple, renvoie un tableau de strings qui contient les textes de tous
les éléments sélectionnés , ou null en absence de sélection

li.isSelected(int indice) ; // retourne true si l’élément d’indice


indice est sélectionné, false sinon.

Exemple : Il s’agit d’écrire un programme qui écrit une liste


de 10 lignes qui autorise la sélection multiple. Il installe
deux boutons pour ajouter et supprimer des éléments
GL_IGE_SMI

89
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Les listes à choix multiple
import java.awt.*;
class DemoList extends Frame
{ List li = new List(10,true);
Button b1 = new Button("Ajouter");
Button b2 = new Button("Supprimer");
DemoList(String titre)
{ super (titre);
FlowLayout fl=new FlowLayout();
setLayout(fl);
add(b1); add(b2);
li.addItem("Element 1"); li.addItem("Element 2");
li.addItem("Element 3"); li.addItem("Element 4");
add(li);
}
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Les listes à choix multiple
public boolean action (Event e,Object o)
{
if (e.target==b1) // si le bouton b est pressé ("ajouter")
li.addItem("autre élément ajouté");
else if (e.target==b2)// si le bouton b2 est pressé ("supprimer")
{
int indice[]=li.getSelectedIndexes();
for (int i=0;i<indice.length-1;i++)
{ li.delItem(indice[i]);
indice[i+1]--;
}
li.delItem(indice[indice.length-1]);
}
return true;
}
GL_IGE_SMI

90
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Les listes à choix multiple
(autre algorithme)
public boolean action (Event e,Object o)
{
if (e.target==b1) // si le bouton b est pressé ("ajouter")
li.addItem("autre élément ajouté");
else if (e.target==b2)// si le bouton b2 est pressé ("supprimer")
{
int indice[ ]=li.getSelectedIndexes();
for (int i=indice.length-1;i>=0;i--)
li.delItem(indice[i]);
}
return true;
}
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Les listes à choix multiple

public static void main(String[] argv)


{ DemoList maListe = new DemoList("Liste d'éléments");
maListe.setSize(400, 400);
maListe.setVisible(true);
}
}

GL_IGE_SMI

91
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


3-5 Les zones de saisie
Pour recueillir les saisies de l’utilisateur dans une fenêtre
graphique, le package awt propose la classe TextField. Par définition, le
champ de texte se limite à une seule ligne. Il est généralement associé à
un bouton qui sert à confirmer la saisie et à transmettre au programme
les caractères tapés
Les quatre constructeurs disponibles sont :
TextField() : déclare un objet de la classe TextField
TextField(int) : déclare un objet TextField et fixe le nombre
maximum de caractères à saisir
TextField(String) : déclare un objet TextField et fixe un texte
par défaut
TextField(String, int) :déclare un objet TextField et fixe un texte
par défaut et le nombre max de caractères à saisir
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


3-5 Les zones de saisie
Lecture d’un champ de texte
La méthode getText() appliquée à un objet TextField retourne
une chaîne de caractères qui est la chaîne saisie
Pour lire le nombre de caractères prédéfinie, on applique a
méthode getColumns()à un objet TextField.
Un champ de texte peut servir entre autres à entrer une
information confidentielle (mot de passe par exemple). Cette
information ne doit pas apparaître directement sur l’écran pendant
qu’elle est tapée. A la place, on affiche un caractère symbolique ou
caractère d’écho. La méthode utilisée est setEchoChar(char)
TextField tF= new TextField (n) ;
TF.setEchoChar(‘*’) ;
GL_IGE_SMI

92
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


3-5 Les zones de saisie
Exemple : Une applet qui permet de saisir un nom et un mot de passe
import java.awt.* ;
import java.applet.* ;
public class DemoTextField extends Applet
{
TextField nom , motPasse ;
public void init()
{ add(new Label(« Nom : »)) ;
nom=new TextField (10) ;
add(nom); add(new Label(« Mot de passe : »)) ;
motPasse=new TextField (10) ;
motPasse.setEchoChar(‘*’) ;
add(motPasse); }
GL_IGE_SMI
}

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Zones de textes pour saisie multiligne
La classe TextField est limitée à la saisie d’une seule
ligne. Pour permettre la saisie de plusieurs lignes, il faut
recourir à la classe java.awt.TextArea
Les quatre constructeurs disponibles sont :
TextArea() : déclare un objet de la classe TextArea
TextArea(int nbLignes, int nbColonnes) : déclare un objet
TextArea et initialise le nombre de lignes et de colonnes
TextArea(String) : déclare un objet TextField et initialise le
contenu
TextArea(String, nbLignes, nbColonnes) :déclare un objet
TextArea et initialise le contenu, le nombre de lignes et le
nombre de colonnes
GL_IGE_SMI

93
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Lecture et modification du contenu d’une zone texte
* La méthode getText() appliquée à un objet TextArea retourne une
chaîne de caractères qui est le contenu intégral de la zone de texte
* Pour lire une partie du texte sélectionnée, on applique la méthode
getSelectedText() à un objet TextArea
* Pour déterminer le nombre de colonnes, on utilise la méthode
getColumns() à un objet TextArea
* Pour déterminer le nombre de lignes, on utilise la méthode
getRows()à un objet TextArea
* Pour insérer une chaîne de caractères à partir d’une position
donnée, on utilise la méthode insertText(Text, n). Cette méthode insère la
chaîne Text à partir du nème caractère.
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Exemple d’utilisation de TextArea pour recueillir des commentaires
import java.awt.* ;
import java.applet.* ;
public class DemoTextArea extends Applet
{
TextArea texte ;
public void init()
{ add(new Label(" Tapez vos commentaires : ")) ;
texte = new TextArea ("Pas de commentaires",5,10) ;
add(texte);
}
}
GL_IGE_SMI

94
Chapitre 5 LES INTERFACES GRAPHIQUES

3 – LES COMPOSANTS DE L’INTERFACE GRAPHIQUE


Exemple d’utilisation de TextArea pour recueillir des commentaires
import java.awt.* ;
import java.applet.* ;
public class DemoTextArea extends Applet
{ TextArea texte ;
public void init()
{ add(new Label(" Tapez vos commentaires : ")) ;
texte = new TextArea ("Pas de commentaires",5,10) ;
add(texte);
}
}

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


Lorsqu’on place des composants dans une applet ou dans
une fenêtre graphique, leur emplacement à l’écran se fait de
manière automatique et d’une façon variable
La disposition des différents composants dépend de:
La taille de la fenêtre ;
La taille des autres composants à ajouter
On peut changer la disposition des différents composants en
utilisant un gestionnaire de mise en page spécifié
Il existe plusieurs gestionnaires de mise en page, chacun
positionnant différemment les éléments graphiques, selon un
algorithme qui leur est propre.
GL_IGE_SMI

95
Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


Tous les gestionnaires de mise en page implémentent
l’interface java.awt.LayoutManager. Pour sélectionner un
gestionnaire de mise en page, on utilise la méthode
setLayout(LayoutManager) de la classe Container. Les
gestionnaires de mise en page les plus utilisés sont :

4-1 FlowLayout :
La classe FlowLayout (mise en page flot) place les
composants ligne par ligne de gauche à droite.

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


Tous les gestionnaires de mise en page implémentent
l’interface java.awt.LayoutManager. Pour sélectionner un
gestionnaire de mise en page, on utilise la méthode
setLayout(LayoutManager) de la classe Container. Les
gestionnaires de mise en page les plus utilisés sont :

4-1 FlowLayout :
La classe FlowLayout (mise en page flot) place les
composants ligne par ligne de gauche à droite.
C’est la disposition par défaut, celle qui sera utilisée si l’on
ne choisit pas un autre gestionnaire. Le principe est très simple :
tous les éléments sont mis côte à côte, de gauche à droite. Lorsqu’il
n’y a plus assez de place pour ajouter un élément, on passe à la
ligne suivante. Chaque ligne est centrée par défaut
GL_IGE_SMI

96
Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


4-1 FlowLayout :
- Déclaration d’un objet de la classe FlowLayout
FlowLayout fl1 = new FlowLayout();
FlowLayout fl2 = new FlowLayout( int );
/* l’entier définit l’orientation des éléments . On utilise à cet
effet les variables prédéfinies CENTER, LEFT et RIGHT*/
FlowLayout fl2 = new FlowLayout(int, int, int);
/* le premier argument définit l’orientation, le deuxième
argument définit l’espacement horizontal et le troisième
définit l’espacement vertical entre les composants */

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


4-1 FlowLayout :
* Pour qu’une nouvelle mise en page soit effective, il faut
l’installer avec la méthode setLayout() de la classe Container
Exemple de mise en page avec FlowLayout
// Fichier DemoFlowLayout.java
import java.awt.*;
import java.applet.*;
public class DemoFlowLayout extends Applet
{
Button monBouton1;
Button monBouton2;
GL_IGE_SMI

97
Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


4-1 FlowLayout :
public void init ()
{
FlowLayout fl = new FlowLayout(FlowLayout.CENTER,60,0);
setLayout(fl);
monBouton1 = new Button();
monBouton2 = new Button();
monBouton1.setLabel("bouton 1");
monBouton2.setLabel("bouton 2");
add(monBouton1) ;
add(monBouton2) ;
}
}
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


4-1 FlowLayout :

<! Fichier DemoFlowLayout.htm>


<HTML>
<applet code = " DemoFlowLayout.class" width=300 height=80>
</applet>
</HTML>
A l’exécution de l’applet :

L’espacement horizontal entre les 2 boutons est de 60 pixels, et


l’espacement vertical est de 0

GL_IGE_SMI

98
Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE

4-2 BorderLayout :

Lorsqu’on utilise BorderLayout, on peut placer les éléments


dans 5 zones différentes : « North », « South », « East », « West » et
« Center » (nord, sud, est, ouest et center)

Déclaration d’un objet de la classe BorderLayout


BordreLayout bl1 = new BorderLayout();

BorderLayout bl2 = new BorderLayout(int, int);


/* le premier argument définit l’espacement horizontal et le
deuxième définit l’espacement vertical entre les composants
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE

4-2 BorderLayout :

Remarque : Contrairement à ce qui se passe pour la mise en page flot,


l’espacement n’a pas d’influence sur la distance qui sépare les composants
du bord de l’applet */
Exemple de mise en page avec BorderLayout
// Fichier DemoBorderLayout.java
import java.awt.*;
import java.applet.*;
public class DemoBorderLayout extends Applet
{
public void init ()
{ BorderLayout bl = new BorderLayout(25,25);
setLayout(bl);
GL_IGE_SMI

99
Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


4-2 BorderLayout :
add("North",new Button("Bouton nord")) ;
add("South",new Button("Bouton sud")) ;
add("Center",new Button("Bouton Centre")) ;
add("East",new Button("Bouton est")) ;
add("West",new Button("Bouton ouest")) ;
}
}
<HTML>
<applet code = " DemoBorderLayout.class" width=400 height=120>
</applet>
</HTML>
A l’exécution, on aura :

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE

4-3 GridLayout :
La classe GridLayout organise tous les composants d’un
conteneur en grille (lignes et colonnes). Le même espace est affecté à
tous les composants. Lorsqu’on instancie GridLayout, on doit spécifier le
nombre de lignes et de colonnes. Les éléments sont ajoutés dans la grille
de gauche à droite, de haut en bas.
Déclaration d’un objet de la classe GridLayout
GridLayout gl = new GridLayout (int nb_lignes, int nb_colonnes);
/* On spécifie le nombre de lignes ou le nombre de colonnes souhaité. L'une
des deux valeurs doit être nulle sinon seul le nombre de lignes est pris en
compte. Par exemple GridLayout(5,4) est identique à GridLayout(5,0) */

GL_IGE_SMI

100
Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


4-3 GridLayout :
GridLayout gl = new GridLayout (int ligne, int colonne ,int h, int v);
/* les deux derniers arguments spécifient l'espacement horizontal et vertical
des composants */

Exemple : Affichage de l'applet suivante qui est composée de 4


boutons et une liste de 5 éléments . Ces composants sont disposés en
trois colonnes comme suit :

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


4-3 GridLayout :
public class DemoGridLayout extends Applet
{ List l=new List(1,false); // création d'une liste déroulante
public void init()
{
l.addItem("Premier");
l.addItem("Deuxième");
l.addItem("Troisième");
l.addItem("Quatrième");
l.addItem("Cinquième");
setLayout(new GridLayout(0,3,20,20));
/* mise en page grille de 3 colonnes, l'espacement horizontal
et vertical des composants et fixé à 20 pixels */
add(new Button(" Bouton 1 ")) ; //(1ère ligne et 1ère colonne)
GL_IGE_SMI

101
Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


4-3 GridLayout :

add(new Button(" Bouton 2 ")) ;// (1ère ligne et 2ème colonne)


add(l); // insértion de la liste (1ère ligne et 3ème colonne)
add(new Button(" Bouton 3 ")) ; //(2ème ligne et 1ère colonne)
add(new Button(" Bouton 4 ")) ; //(2ème ligne et 2ème colonne)
}
}
<HTML>
<applet code = "DemoGridLayout.class" width=280 height=120>
</applet>
</HTML>

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


4-4 GridBagLayout :
Le dernier gestionnaire de mise en page présenté
correspond à la classe GridBagLayout (grille étendue). Cette classe
est la plus puissante des gestionnaires de mise en page, mais elle
est également la plus difficile à utiliser . la grille est divisée en
cellules égales. Mais pour faciliter les ajustements, un composant
peut occuper plusieurs cellules de la grille. On introduit par ailleurs
un objet de la classe GridBagConstraints qui donne des indications
de positionnement et de dimension à l'objet GridBagLayout

GL_IGE_SMI

102
Chapitre 5 LES INTERFACES GRAPHIQUES

4 – LES GESTIONNAIRES DE MISE EN PAGE


Variables d'instance pour manipuler un objet GridBagLayout
gridx et gridy : ces variables contiennent les coordonnées de
l'origine de la grille (0,0)
gridwidth, gridheight : ces variables définissent combien de cellules
(en hauteur et largeur) va occuper un composant. Par défaut leur
valeur est 1
GridBagConstraints.REMAINDER spécifie que le prochain
composant inséré va être le dernier de la ligne ou de la colonne
courante
GridBagConstraints.RELATIVE est utilisé pour placer un composant
après le dernier composant d'une ligne ou d'une colonne

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

5 – LES CONTENEURS
Pour mettre en service les différents composants déjà vus
(boutons, listes, cases à cocher, …) , il faut toujours les incorporer
dans un objet d'une classe dérivée de la classe abstraite Container
(conteneur). Les conteneurs les plus utilisés sont :
Panel : Conteneur qui n'a pas de fenêtre propre sert surtout à
ordonner les contrôles. La classe java.applet.Applet est dérivée de
la classe Panel
Window : crée une fenêtre principale sans cadre ni menu
Frame (dérivant de Window) : il s'agit d'une classe de fenêtre avec
barre de titre

GL_IGE_SMI

103
Chapitre 5 LES INTERFACES GRAPHIQUES

5 – LES CONTENEURS
5-1 Le conteneur Panel

Le conteneur Panel est un panneau qui sert essentiellement à


ranger les composants. La classe Panel est très simple, elle ne
contient qu'un seul constructeur et une seule méthode add()
Panel p = new Panel() ; // définit un nouveau panneau
add(p); : intègre le panneau p dans un autre conteneur (une
applet par exemple)
Un panneau peut lui même contenir d'autres conteneurs. Ainsi des
panneaux peuvent être emboîtés

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES


5 – LES CONTENEURS
Exemple : Utiliser dans une applet deux panneaux
import java.awt.* ;
import java.applet.* ;
public class DemoPanel extends Applet
{ public void init()
{ FlowLayout fl=new FlowLayout();
setLayout(fl);
Panel p1= new Panel();
Button b1=new Button("Premier");
Button b2=new Button("Deuxième");
p1.add(b1);
p1.add(b2);
add(p1);
FlowLayout fl2=new FlowLayout(FlowLayout.LEFT,40,20);
setLayout(fl2);
Panel p2= new Panel();
Button b3=new Button("Troisième");
Button b4=new Button("Quatrième");
p2.add(b3);
p2.add(b4);
add(p2); }
}
GL_IGE_SMI

104
Chapitre 5 LES INTERFACES GRAPHIQUES

5 – LES CONTENEURS
5-2 Le conteneur Frame

Une frame ou encadrement permet de créer une fenêtre à


l'extérieur de l'applet qui s'exécute comme une application
indépendante

La classe Frame contient deux constructeurs :

Frame f = new Frame();


// création d'une fenêtre d'encadrement invisible

Frame f = new Frame(String);


// création d'une fenêtre d'encadrement invisible avec un nom de la
fenêtre.

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

6- LES EVENEMENTS ET LES ACTIONS

Les interactions de l'utilisateur avec l'interface (par


exemple cliquer sur la souris, taper sur une touche du
clavier, presser un bouton , …) sont appelés événements.
On dit que l'on "traite un événement" lorsqu'on prend en
compte celui ci et que l'on exécute des actions en
conséquence . La méthode qui traite l'événement est
également appelée gestionnaire d'événement
La classe java.awt.Event est capable de mémoriser
tous les paramètres relatifs à un événement
GL_IGE_SMI

105
Chapitre 5 LES INTERFACES GRAPHIQUES

6- LES EVENEMENTS ET LES ACTIONS

Des programmes à l'écoute


Les réactions aux événements utilisateur dans un
programme java sont gérés par des programme à l'écoute
(listener). Ces programmes doivent implémenter l'interface
EventListener (auditeurs d'événements) ou des interfaces qui
héritent de EventListener ( par exemple ActionListener). On
appellera "adaptateur" toute instance d'une classe implémentant
une interface héritée de EventListener.
L'interface ActionListener déclare une seule méthode :

public void actionPerformed(ActionEvent)


GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

6- LES EVENEMENTS ET LES ACTIONS

L'ajout d'un programme à l'écoute impose deux instructions :


- La classe doit importer le package java.awt.event qui
contient les classes d'écoute
import java.awt.event.*;
- La classe doit utiliser l'instruction implements pour
déclarer qu'elle utilisera une ou plusieurs interfaces d'écoute. Par
exemple :
public class Evenement extends java.applet.Applet implements
ActionListener

GL_IGE_SMI

106
Chapitre 5 LES INTERFACES GRAPHIQUES
6- LES EVENEMENTS ET LES ACTIONS
Les interfaces EventListener permettent à un composant
d'interface graphique utilisateur de générer des événements
utilisateur. Aucun composant ne pourra être entendu par les
autres éléments d'un programme sans la présence d'au moins un
des auditeurs. Un programme doit contenir une interface
d'auditeur pour chaque type de composant
Un objet peut déléguer la gestion de ses événements à
plusieurs Listeners. Chacun des Listener réagira aux événements
de l’objet.
Un Listener peut écouter plusieurs objets .
Pour qu’un objet puisse déléguer la gestion on doit spécifier qui s’en
chargera par une méthode du type : add<Typed’événement>Listener.

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES


6- LES EVENEMENTS ET LES ACTIONS

Tableau synthétique des événements et des « listeners »


Le tableau ci-dessous indique :
-En première colonne : un type d’événement
-En deuxième colonne, les types de composants graphiques pouvant
recevoir l’événement indiqué
-En troisième colonne, l’interface « Listener » qu’on peut
implémenter pour traiter l’événement indiqué, et la classe que l’on
peut étendre pour servir d’adptateur, lorsqu’une telle classe existe
-En dernière colonne , les méthodes déclarées par le « listener »

GL_IGE_SMI

107
Chapitre 5 LES INTERFACES GRAPHIQUES
6- LES EVENEMENTS ET LES ACTIONS

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES


6- LES EVENEMENTS ET LES ACTIONS

ComponentEvent Dialog ComponentListener ComponentMoved(ComponentEvent)


Frame ComponentHidden(ComponentEvent)
ComponentResized(ComponentEvent)
ComponentShown(ComponentEvent)

AdjustementEvent Scrollbar AdjustementListener AdjustementValueChanged


(AdjustementEvent)
MouseEvent Canvas MouseListener MousePressed(MouseEvent)
Dialog MouseAdapter MouseReleased(MouseEvent)
Frame
Panel
Window
KeyEvent Component KeyListener KeyPressed(KeyEvent)
KeyAdapter KeyReleased(KeyEvent)
KeyTyped(KeyEvent)
ContainerEvent Container ContainerListener ComponentAdded(ContainerEvent)
ComponentRemoved(ContainerEvent)

TextEvent TextComponent TextListener TextValueChanged(TextEvent)

GL_IGE_SMI

108
Chapitre 5 LES INTERFACES GRAPHIQUES
6- LES EVENEMENTS ET LES ACTIONS
Exemple : Il s’agit de construire une interface graphique qui
permet de tracer un cercle rouge si on clique sur le bouton trace et
d’effacer ce cercle si on clique sur le bouton efface
import java.awt.*;
import java.awt.event.*;
class EssaiBouton extends Frame implements ActionListener
{
Button trace = new Button("trace");
Button efface = new Button("efface");
EssaiBouton()
{
setLayout(new FlowLayout(FlowLayout.CENTER,5,5));

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES


6- LES EVENEMENTS ET LES ACTIONS
Exemple :
add(trace);
add(efface);
trace.addActionListener(this);
efface.addActionListener(this);
}
public void actionPerformed(ActionEvent e)
{ Graphics g=getGraphics();
if (e.getSource()==trace)
{ g.setColor(Color.red);
g.drawOval(50,50,100,100); }
else if (e.getSource()==efface)
{ g.setColor(getBackground());
g.drawOval(50,50,100,100); }
}
GL_IGE_SMI

109
Chapitre 5 LES INTERFACES GRAPHIQUES
6- LES EVENEMENTS ET LES ACTIONS

Exemple :

public static void main(String[] argv)


{
EssaiBouton monCadre=new EssaiBouton();
monCadre.setSize(300,300);
monCadre.setVisible(true);
}
}

GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

6- LES EVENEMENTS ET LES ACTIONS


* L’interface MouseListener

Les prototypes de méthodes définies dans MouseListener


void mouseClicked(MouseEvent e) la souris a été ciqué
(pressée et relachée)
void mouseEntered(MouseEvent e) : la souris entre dans le
composant
void mouseExited(MouseEvent e) : La souris sort du
composant
void mousePressed(MouseEvent e) : La souris est pressé
void mouseReleased(MouseEvent e) : la souris relachée. */
GL_IGE_SMI

110
6- LES EVENEMENTS ET LES ACTIONS
* Exemple : utilisation des événements de la souris
public class Souris extends Frame implements MouseListener
{ TextField text1;

Souris(String titre)
{ super(titre);
text1 = new TextField(30);
FlowLayout fl=new FlowLayout();
setLayout(fl);
add(text1);
addMouseListener(this);

}
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

6- LES EVENEMENTS ET LES ACTIONS


* Exemple : utilisation des événements de la souris
public void mouseClicked(MouseEvent e)
{
text1.setText("Vous avez cliqué sur la souris à " +
e.getX()+","+e.getY()); }
public void mouseEntered(MouseEvent e)
{text1.setText("La souris est entrée.");}
public void mouseExited(MouseEvent e)
{text1.setText("La souris est sortie.");}
public void mousePressed(MouseEvent e)
{text1.setText("La souris est enfoncée ");}
public void mouseReleased(MouseEvent e)
{text1.setText("La souris est relachée ");}
GL_IGE_SMI

111
Chapitre 5 LES INTERFACES GRAPHIQUES

6- LES EVENEMENTS ET LES ACTIONS


* Exemple : utilisation des événements de la souris
public void mousePressed(MouseEvent e)
{ text1.setText("La souris est enfoncée "); }
public void mouseReleased(MouseEvent e)
{text1.setText("La souris est relachée ");}
public static void main(String[] arg)
{Souris maSouris = new Souris("Gestion de la souris");
maSouris.setSize(300,300);
maSouris.setVisible(true);
}
}
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

6- LES EVENEMENTS ET LES ACTIONS


* Exemple : utilisation des événements du clavier

* Les méthodes de l'interface KeyListener

void keyPressed(KeyEvent e) : touche pressée

void keyReleased(KeyEvent e) : touche relachée

void keyTyped(KeyEvent e) :touche tapée

GL_IGE_SMI

112
Chapitre 5 LES INTERFACES GRAPHIQUES

6- LES EVENEMENTS ET LES ACTIONS


* Exemple : utilisation des événements du clavier

public class Touche extends Frame implements KeyListener


{ String text="";
Touche(String titre)
{
super(titre);
addKeyListener(this);
}

public void paint(Graphics g)


{ g.drawString(text,10, 100); }
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES

6- LES EVENEMENTS ET LES ACTIONS


* Exemple : utilisation des événements du clavier
public void keyTyped(KeyEvent e)
{ text = text + e.getKeyChar();
//getKeyChar() retourne le caractère pressée
repaint(); }
public void keyPressed(KeyEvent e)
{ }
public void keyReleased(KeyEvent e)
{ }
public static void main(String[] arg)
{Touche maTouche = new Touche("Gestion du clavier");
maTouche.setSize(300,300);
maTouche.setVisible(true); } }
GL_IGE_SMI

113
Chapitre 5 LES INTERFACES GRAPHIQUES
-Exemples de javax.swing
Exemple 1
import javax.swing.*;
import java.awt.*;
class TestJFrame extends JFrame
{ TestJFrame()
{ super("une application");
Container cp = getContentPane();
// public Container getContentPane() de la classe JFrame
// Retourne un objet de type Container de cette fenêtre
JLabel label = new JLabel("Hello",SwingConstants.CENTER);
cp.add(label, BorderLayout.CENTER);
}
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES


-Exemples de javax.swing

Exemple 1

public static void main(String args[])


{ JFrame f = new TestJFrame();
f.setBounds(200,200, 150, 100);
f.setVisible(true);
}
}

GL_IGE_SMI

114
Chapitre 5 LES INTERFACES GRAPHIQUES
-Exemples de javax.swing

Exemple2

import javax.swing.*;
import java.awt.event.*;
public class SwingDemo extends JFrame
{ Icon image = new ImageIcon("smallbabies.jpeg");
//JLabel label = new JLabel(image);
JButton SwingButton = new JButton(image);
public SwingDemo(String WindowTitle)
{super(WindowTitle);
getContentPane().add(SwingButton);
// getContentPane().add(label); }
GL_IGE_SMI

Chapitre 5 LES INTERFACES GRAPHIQUES


-Exemples de javax.swing

Exemple2

public static void main(String args[])


{ JFrame frame = new SwingDemo("Swing Demo Window");
frame.setSize(400, 400);
frame.setVisible(true);
}
}

GL_IGE_SMI

115
Chapitre 6 LES EXCEPTIONS

1- INTRODUCTION

2- DEFINITION D'UNE EXCEPTION

3- UN PREMIER EXEMPLE D'UNE EXCEPTION

4- ATTRAPER UNE EXCEPTION


4-1 Les blocs try et catch
4-2 Le mot clé throws
4-3 Le bloc finally
4-4 Quelques classes d'exceptions

5- DEFINIR SA PROPRE EXCEPTION

GL_IGE_SMI

LES EXCEPTIONS

1- Introduction
Un programme ne se déroule pas toujours comme
prévu. Plusieurs cas d'erreurs peuvent venir perturber son
bon déroulement : division par zéro, dépassement des
bornes d'un tableau, fichier inexistant,…
Dans tout programme, le traitement des erreurs
représente une tâche importante, souvent négligée par les
programmeurs.
Java dispose d'un mécanisme très efficace appelé le
mécanisme d'exceptions pour obliger les programmeurs à
prendre en compte les erreurs. Ce mécanisme admet deux
principes fondamentaux :
GL_IGE_SMI

116
LES EXCEPTIONS

1- Introduction
- La plus grande partie des erreurs qui pourraient
survenir doit être détectée par le compilateur, de façon à
limiter autant que possible les occasions de les voir se
produire pendant l'utilisation des programmes
- Le traitement des erreurs doit être séparé du reste
du code, de façon que celui-ci reste lisible.

GL_IGE_SMI

LES EXCEPTIONS
2- Définition d’une exception
Une exception est une interruption de l'exécution d'un
programme suite à une erreur. Par exemple, une division par
zéro provoque une exception de type ArithmeticException
Les exceptions en java sont des instances de sous-classes
des classes :
java.lang.Error (pour des erreurs graves, qui devront
généralement conduire à l'arrêt du programme)
ou
java.lang.Exception (pour des événements inattendus,
qui seront souvent traités de sorte qu'elle ne provoquent
pas l'arrêt du programme).
GL_IGE_SMI

117
LES EXCEPTIONS
3- Un premier exemple d' une exception

Avant de voir comment traiter les exceptions , regardons


à quoi elles correspondent en prenant un exemple très simple
de division par zéro :

class DivParZero
{
public static void main(String[] argv)
{
int zero = 0 ;
zero = 2000 / zero ;
}
}
GL_IGE_SMI

LES EXCEPTIONS
3- Un premier exemple d' une exception
A l'exécution du programme, on obtient l'affichage suivant :

Exception in thread "main"


java.lang.ArithmeticException: / by zero at
DivParZero.main(DivParZero.java:6)

On distingue :
- Le nom complet de l'exception qui a été levée :
java.lang.ArithmeticException
- Un message précisant la cause de cette erreur : / by zero
- L'indication de la classe, de la méthode et du numéro de ligne où s'est
produite cette exception : at DivParZero.main(DivParZero.java:6)
GL_IGE_SMI

118
LES EXCEPTIONS
3- Un premier exemple d' une exception
Si on désire ne pas avoir d'interruptions dans notre programme, on gérer
l'erreur en utilisant les blocs try et catch de la façon suivante :
class DivParZero
{
public static void main(String[] argv)
{
int zero = 0 ;
try
{ zero = 2000/zero ; }
catch (ArithmeticException e)
{ System.out.println("Une exception arithmétique a été levée");
System.out.println("Message : "+e.getMessage()); }
}
A l'exécution, on obtient :
Une exception arithmétique a été levée
Message : / by zero
GL_IGE_SMI

LES EXCEPTIONS
4- Attraper une exception
Pour pouvoir attraper une exception ( ne pas la laisser
arrêter le programme), il faut entourer le code susceptible de la
lancer dans un bloc précédé de l'instruction try. L'exception
lancée dans le bloc peut être attrapée par une sorte de méthode
d'un type particulier désignée par le mot clé catch et prenant
pour paramètre un objet du type de l'exception lancée ou du
type d'une classe parente.

GL_IGE_SMI

119
LES EXCEPTIONS

4-1 Les blocs try et catch


Si on décide de traiter une exception, on dit qu'on attrape
l'exception et il faut utiliser dans ce cas les mots clé try et
catch
Le mot clé try permet de spécifier un bloc de code sur le
quel on s'attend qu'une exception soit levée ( c à d possibilité
d'avoir une erreur)
Le bloc de l'instruction try doit être suivi d'une instructions
catch
Le mot clé catch sert à spécifier le code à exécuter pour
une exception donnée. Il faut faire suivre le mot catch d'une
parenthèse ouvrante, d'un type exception (une classe), du nom
qu'on lui donne , d'une parenthèse fermante et du code associé
placé entre accolade
GL_IGE_SMI

LES EXCEPTIONS
4-1 Les blocs try et catch

Donc les blocs try et catch sont utilisés comme suit :


try
{
// zone contenant des instructions pouvant générer des
erreurs
(lever des exceptions)
}
catch (NomException e)
{
// Traitement à faire dans le cas de l'exception e
( erreur e a été rencontré dans le bloc try)
}
GL_IGE_SMI

120
LES EXCEPTIONS

4-1 Les blocs try et catch


Un bloc try peut être suivi de plusieurs blocs catch chacun
spécifiant un type d'exception différent :
try
{
opération _dangereuse1;
opération_dangeureuse2;
opération_dangeureuse3;
catch (Exception1 e1)
{
}
catch (Exception2 e2)
{
}
catch (Exception3 e3)
{
}
GL_IGE_SMI

LES EXCEPTIONS
4-2 Mécanisme de lancement d'une exception
On suppose qu'une instruction i d'une méthode de nom
uneMethode génère une erreur (ou lance une une exception) :
* Si l'instruction i se trouve dans un bloc de uneMethode précédé
du mot réservé try, et suivi d'un bloc précédé du mot réservé catch
assorti d'un argument de la classe ou d'une super-classe de l'exception
lancée. Alors :
** les instructions qui suivent le lancement de l'exception et
intérieures au bloc try sont ignorées
** les instructions du bloc catch sont effectuées
** Le programme reprend normalement avec l'instruction qui suit
le bloc catch.

GL_IGE_SMI

121
LES EXCEPTIONS
4-2 Mécanisme de lancement d'une exception
* Si l'instruction i n'est pas située dans un bloc try ,
Alors :
** Si uneMethode est la méthode main, le programme se termine et
l'exception n'a pas été attrapée.
** Sinon, on se retrouve dans la méthode qui a appelée uneMethode,
au niveau de l'instruction j qui a fait appel à uneMethode. L'instruction j
lance à son tour l'exception.
Si une exception est lancée et pas attrapée, et donc qu'elle
provoque la terminaison du programme, la pile des méthodes
traversées par l'exception est indiquée à l'utilisateur. On dit qu'il y’a
propagation de l'exception

GL_IGE_SMI

LES EXCEPTIONS
Exemple : Calcul d'une moyenne (entière) de notes entières envoyées en
arguments par la ligne de commande .Les arguments non entiers doivent être
ignorés et signalés à l'utilisateur
class ExceptionCatch
{
static int moyenne(String[] liste)
{
int somme = 0,entier, nbNotes = 0;
for (int i = 0; i < liste.length; i++)
{
try {
entier = Integer.parseInt(liste[i]);
somme += entier;
nbNotes++; }
catch (NumberFormatException e)
{System.out.println("la "+ (i+1) +"ème note n'est pas entière");}
}
return (somme/nbNotes);
}
GL_IGE_SMI

122
LES EXCEPTIONS
public static void main(String[] argv)
{
System.out.println("La moyenne
est"+moyenne(argv));
}
}
A l'exécution : java ExceptionCatch 12 a 15
La 2 ème note n'est pas entière
La moyenne est 13

Si on donne en exécution : java ExceptionCatch 12.5 d


La 1 ème note n'est pas entière
La 2 ème note n'est pas entière
Exception in thread "main" java.lang.ArithmeticException: / by zero)
at ExceptionCatch.moyenne(Compiled Code)at
ExceptionCatch.main(ExceptionCatch.java:23
La division par zéro n'est pas attrapée
GL_IGE_SMI

LES EXCEPTIONS
4-3 Le mot clé throws
Une méthode susceptible de lancer une exception sans l'attraper
(c'est-à-dire contenant une instruction susceptible de générer une erreur
sans que celle-ci soit traitée à l'intérieur de la méthode) doit l'indiquer dans
son en-tête par le mot clé throws.
Ce mot clé permet d'avertir le système qu'une certaine catégorie
d'exceptions ne seront pas traitées.
Dans la déclaration d'une méthode, throws permet de déclarer la liste
des classes d'exceptions que la méthode est susceptible de déclencher :
Syntaxe :
Entête méthode throws ClasseException

GL_IGE_SMI

123
LES EXCEPTIONS
4-3 Le mot clé throws
Exemple :
void fonction() throws IOException
La méthode fonction est susceptible de lancer des exceptions
de type entrée/sortie
Remarque : Il est obligatoire d'indiquer par le mot clé throws les
exceptions susceptibles d'être lancées et non attrapées (sauf pour les
exceptions les plus courantes de l'API). Sinon il y 'aura erreur de
compilation

GL_IGE_SMI

LES EXCEPTIONS
4-4 Bloc Finally
Un bloc finally est un bloc d'instructions précédé du mot clé
finally. Ce bloc sera toujours exécuté après le traitement d'exception. Il
est en général utilisé pour fermer des fichiers, libérer des ressources,
Un bloc finally suit Un bloc try ou un bloc catch
Exemple d'utilisation d'un bloc finally
class UtiliseFinally
{
static int moyenne(String[] liste)
{
int somme=0, entier, nbNotes=0, i=0;
for ( i=0;i<liste.length;i++)
{ try
{ entier=Integer.parseInt(liste[i]);
somme +=entier;
nbNotes++; }
GL_IGE_SMI

124
LES EXCEPTIONS
4-4 Bloc Finally
finally
{ System.out.println("donnée traitée :"+liste[i]); }
}
return somme/nbNotes;
}
public static void main(String[] argv)
{
try
{ System.out.println("La moyenne est "+moyenne(argv)); }
catch (NumberFormatException e)
{ System.out.println("Erreur sur vos entiers"); }
}
}
A l'exécution de : java UtiliseFinally 20 xy
On aura : donnée traitée : 20
donnée traitée : xy
Erreur sur vos entiers
GL_IGE_SMI

LES EXCEPTIONS
4-5 Quelques classes d'exceptions
Exception Type d'exception
IOException Entrée Sortie
Exemples : lecture sur un fichier
inexistant
ArithméticException Arithmétique
Exemple : Division par zéro
ArrayIndexOutOfBoundsExcepti Dépassement des bornes d'un
on tableau
NumberFormatException Format du nombre n'est pas
respectée
Exemple : un int représentée en
float
OutOfMemoryException Dépassement de mémoire
GL_IGE_SMI

125
LES EXCEPTIONS
5- Définir sa propre exception
Si on veut pouvoir signaler un événement exceptionnel d'un
type non prévu par l'API, il faut étendre la classe java.lang.Exception.

En général la classe étendue ne contient qu'un ou plusieurs


constructeurs et éventuellement une redéfinition de la méthode toString

Lors du lancement de l'exception, (à l'aide du mot réservé throw) ,


on crée une instance de la classe définie

GL_IGE_SMI

LES EXCEPTIONS
5- Définir sa propre exception
Exemple :
class ExceptionRien extends Exception
{ public String toString()
{ return "Aucune note n'est valide " ; }
}
//Cette classe peut être utilisée comme exception dans une autre classe :
class ExceptionThrow
{
static int moyenne(String[] liste) throws ExceptionRien
{ int somme = 0,entier, nbNotes = 0;
for (int i = 0; i < liste.length;i++)
{
try
{entier = Integer.parseInt(liste[i]);
somme += entier;
nbNotes++;
GL_IGE_SMI
}

126