cours JAVA

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
2006
mai : Java EE 5
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 bytecode 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
Nom d’une
classe
Débute par une majuscule
Exemple
class Polygone
Nom d’un
objet
Débute par une minuscule
Peut s’étaler sur plusieurs mots Chaque
mot commence par une majuscule sauf le
premier
premierObjet
Nom de
méthode
Débute par une minuscule
Sauf pour le constructeur
void
Constante
S’écrit en majuscules
A_CONSTANT
ecrire()
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;
static float taux_h=50;
int nb_h;
// le nom de l'employé
// le taux horaire en dirhams
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
byte
short
char
Destiné à une valeur logique (true, false)
Octet signé 8 bits (-128 et 127)
Entier court signé 16 bits (-32768 – 32767)
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
Byte
Short
Integer
Long
Float
Double
Boolean
char
byte
short
int
long
float
double
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
case
default
extends
for
int
null
return
synchronized
true
assert
catch
do
false
if
interface
package
short
this
try
boolean
char
double
final
implements
long
private
static
throw
void
break
class
else
finally
import
native
protected
super
throws
volatile
byte
continue
enum
float
instanceof
new
public
switch
transient
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);
System.out.println(obj1.s);
//15
System.out.println(obj1.nons);
System.out.println(obj2.nons);
}
}
//15
//20
//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
Exemple :
int min = a<b ?
?
siVrai
:
siFaux
int 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
abstract
Définition
Prototype de méthode
Une méthode qui ne peut pas être redéfinie.
final
protected
private
public
Méthode ne peut être invoquée que par des
sous classes.
une méthode privée ne peut être utilisée que
dans les méthodes de la même classe
méthode visible
méthodes
par
toutes
les
autres
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
Exemple :
tableau[ ] ;
int
int
[] tab1
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
estEgal ) */
GL_IGE_SMI
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
HERITAGE ET INTERFACES EN JAVA
Chapitre 3
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
….
MedecinPublic
Enseigantt
Avocat
Commerçant
Primaire
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
LES APPLETS
Les liens dans une page HTML
Chapitre4
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
LES APPLETS
Chapitre4
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
LES APPLETS
Chapitre4
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)
20
50
(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
LES INTERFACES GRAPHIQUES
Chapitre 5
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
LES INTERFACES GRAPHIQUES
Chapitre 5
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
LES INTERFACES GRAPHIQUES
Chapitre 5
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
GL_IGE_SMI
{
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);
}
}
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
ComponentListener
ComponentMoved(ComponentEvent)
ComponentHidden(ComponentEvent)
ComponentResized(ComponentEvent)
ComponentShown(ComponentEvent)
AdjustementEvent Scrollbar
AdjustementListener
MouseEvent
MouseListener
MouseAdapter
AdjustementValueChanged
(AdjustementEvent)
MousePressed(MouseEvent)
MouseReleased(MouseEvent)
ComponentEvent
Dialog
Frame
KeyEvent
Canvas
Dialog
Frame
Panel
Window
Component
ContainerEvent
TextEvent
KeyListener
KeyAdapter
KeyPressed(KeyEvent)
KeyReleased(KeyEvent)
KeyTyped(KeyEvent)
Container
ContainerListener
ComponentAdded(ContainerEvent)
ComponentRemoved(ContainerEvent)
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