Vous êtes sur la page 1sur 136

Cours Java 1

Oussama El Ghoul

1
Introduction

2
Historique
1993: Gosling développe le langage OAK pour l’électronique en
collaboration avec Naughton
1995 : le projet OAK a été nommé Java et Naughton développe le
WebRunner, un interpréteur pour le navigateur web,(nommé par la
suite HotJava
HotJava)
Avril 1995 : la version alpha du logicel Java/
Java/HotJava
HotJava dédiée au Web est
disponible
Mai 1995 : 1ere licence du Java pour Netescape
Septembre 1995 : la version beta du java devlopment kit 1.0.b
Décembre 1995 : 2eme licence a été vendue à MicroSoft
Janvier 1996 : JDK 1.0.1
Fin 1996 : RMI
RMI, JDBC
JDBC, JavaBeans
JavaBeans, …
Mars 1997 : JDK 1.1,
1.1 …, JDK 1.1.7
Janvier 1998 : Java 2 et JDK 1.2
Mars 98: on parle de JAVA 2 SDK

3
CARACTERISTIQUE DU LANGAGE JAVA
• Java est un langage orienté objet
• Objets( collection d’attributs et méthodes
associées; les classes servent a définir les
modelés d’objets), encapsulation, héritage,
polymorphisme,…
• Simple et de syntaxe proche de C++ : basé sur
C/C++ mais :
– Pas des pointeurs ni des structures
– Pas de gestion de mémoire laissée au
programmeur(malloc() et free()).
– Facile à prendre en main

4
CARACTERISTIQUE DU LANGAGE JAVA
• Permet d'exécuter des programmes au travers
d'une machine virtuelle. Code C++

Compilation
Code Java
Fichiers .obj
Compilation (commande javac
javac)
Edition de lien

ByteCode Fichiers exécutables


sur machine réelle
Exécution
Exécution
Machine
Virtuelle (JVM) Machine réelle

Compilation et exécution Compilation et exécution


5
d’un programme en Java d’un programme en C++
CARACTERISTIQUES DU LANGAGE
JAVA
• La machine virtuelle java: « Write one, run everey
where», c’est le fondement d’un langage
portable.
portable
Code Java

Compilation (commande javac


javac)

ByteCode

Exécution

JVM JVM JVM JVM

Linux Windows Mac OS Symbian 6


CARACTERISTIQUES DU LANGAGE

JAVA
bytecode est indépendant de la plate-forme.
• Il est fourni avec un ensemble de ``packages
packages'' : les classes de
base du JDK (Java Developper's Toolkit) ou SDK (Software
Development Kit) qui ajoute des outils de développement.
• Robuste
– Des nombreuses vérifications sont faites avant l’exécution
dechaque programme java( tableaux, classes,…)
– Traitement très puissant des erreurs et des exceptions.
• Implémente le maximum de sécurité
sécurité,
– Class Loder : sépare entre les espaces de chargements des
classes
– locales et des classes distantes

7
CARACTERISTIQUES DU LANGAGE
JAVA
• Dynamique : application avec plusieurs classes
– Pas d’édition des liens : la JVM charge les classes
nécessaires à une application simultanément,
indépendamment l’une de l’autre et selon leurs
emplacements (local ou distant)
• Adapté à l’Internet
– Chargement dynamique des classes en cours
d’exécution
– Favorisé pour distribuer les taches entre plusieurs
machines ( RMI, Socket, … )

8
CARACTERISTIQUES DU LANGAGE
JAVA
Java C++
D é c l a r a t i o n e t définition d’une Déclaration d’une classe dans un
classe dans le même ficher ficher « .h » définition dans un
=> pas de problèmes d’inclusion autre fichier « .cpp »
Méthode main() dans une ou
Une seule fonction main()
plusieurs classes
#include
P a s d e dérictives de préprocesseur
#define(const)
uniquement: class struct, union, typdef, …
Uniquement des références pointeurs et références

9
CARACTERISTIQUES DU LANGAGE
JAVA
Java C++
• Pas d’allocation explicite
• La libération de mémoire se fait par malloc , free, new et delete .
G.C(Garbage Collector)

Pas de surcharge d’opérateurs, des fonction a


nombre variable d’arguments
Définition des classes presque identiques
Surcharge des méthodes
Même types primitifs (char(16 bits) en java et char (8 bits)en C++)
Constructeur par défaut

10
La plate-forme java

Programmes Java

API

JVM

Machine réelle

• Les 3 éditions du Java


– J2SE : Java 2 Standard Edition
– J2EE : Java 2 Enterprise Edition qui ajoute les API pour
écrire des application installées sur des serveurs,…
– J2MS : Java 2 Micro Edition, version allégée du Java
pour des applications spécifiques( carte à puce,
téléphone portable, …) 11
La plate-forme java
class HelloWolrd{
public static void main(String args[ ]){
System.out.println(“ hello world”);
}
}
Compilation et exécution :
set path= “c:\program files\java\ jdk1.6.0\bin”
javac HelloWorld.java (compilation)
Java HelloWorld 12
Les types de données prédéfinis
Type Codage Declaration
char 2 octets caractère Unicode 'A', 'b'
int 4 octets 145, -7, 0x
0xFF
Long 8 octets
byte 1 octet
short 2 octets
float 4 octets 134.789FF, -45EE-18FF
double 8 octets 134.789, -45EE-18
boolean 1 bit true, false
String référence d'objet chaîne de caractères "Java"
Date référence d'objet date new Date(13,10,1954)
Character référence d'objet char
Integer référence d'objet int
Long référence d'objet long
Byte référence d'objet byte
Float référence d'objet float
Double référence d'objet double
Boolean référence d'objet boolean
13
Déclaration des données
• Déclaration des constantes
– Sythaxe:
final type nom=valeur;
– Exemple:
final float PI=3.141592F;
• Déclaration des variables
– Sythaxe:
type variable1,variable2,...,variablen;
– Exemple:
float f=15.23F;
14
Déclaration des tableaux
– Sythaxe:
//declaration + instanciation
Type Tableau[]=new Type[n];
ou Type[] Tableau=new Type[n];
//déclaration et instanciation séparées
Type Tableau[];
Tableau = new Type[n];
ou Type[] Tableau;
Tableau = new Type[n];
– Exemple:
flaot Tableau[]=new float [5];
NB: un tableau est un objet qui possède un attribut
publique length indiquant sa langueur. 15
Déclaration des tableaux
– Exemple:
float tableau[] = new float[33];
tableau[0]=1;
tableau[1]=2;
tableau[2]=3;
for(int i=0;i<tableau.length
tableau.length;i++)
System.out.println(tableau[i]);

– Affiche:
1
2
3 16
Les conversions entre nombres et chaînes
de caractères
• nombre -> chaîne : "" + nombre
• chaine -> int : Integer.parseInt(chaine)
• chaîne -> long : Long.parseLong(chaine)
• chaîne -> double:
double:Double.parseDouble(chaine);
• chaîne -> float:
float: Float.parseFloat(chaine);

• NB: une chaine est un objet qui possède une


méthode publique length indiquant sa langueur.

17
Les structures de contrôle

18
Les operateurs
• Operateurs logiques:
&& : et logique
|| : ou
^ : ou exclusif
! : négation
• Operateurs de comparaison:
== , !=
!=,, <, >, <=
<=,, >=
• Operateurs arithmétiques:
* , /, %, +, -, ++
++,, --
19
Les operateurs
• Les opérateurs logiques && et || effectuent
une évaluation paresseuse.
• L’évaluation se fait de gauche à droite.
• Ainsi, dans X1 && X2 && …. && Xn Xn,, les
arguments ne sont évalués que jusqu’au
1erargument faux
• Exemple:
(X!=
!=0.0) && (2.0//X<<13.0)
(X==
==0.0) || (2.0//X<<13.0)
20
Les operateurs
• La concaténation ne modifie jamais les chaînes
concaténées.
• Elle effectue une copies de ces chaînes dans une
autre zone en mémoire.
mémoire.
• Exemple “ test” + “”
String s1 = “ test”;
String s2 = “ test”; S3
S1 “ test”
String s3 = s2; S2 S4
String s4 = s1+“ ”;
System.out.println((s1==s2)&&(s2==s3)); //true
//true
System.out.println(s1==s4); //false 21
Les operateurs
• Pour comparer deux objets de type String on
utilise les méthode equals et compareTo de la
classe String
String..
• Exemple
String s1 = “ test”;
s1.equals
s1.equals(“(“ test”); // true
s1.compareTo
s1.compareTo(“ (“ test”); //0
s1.compareTo
s1.compareTo(“ (“ test1”); //<0
s1.compareTo
s1.compareTo(“ (“ tes”); //>0
22
Les structures de branchement
If(condition){
// instructions
}

switch(expression){
switch(expression){
case val1: //instructions;
case val2: //instructions; break;
default: //instructions;
} 23
Les structures itératives
while(condition){
while(condition){
//instructions
}
do{
//instructions
}while
while(condition);
(condition);

24
Les structures itératives
for(preInstruction;condition;postInstructions){
for(preInstruction;condition;postInstructions){
//instructions
}
for(type nomVar:tableau
nomVar:tableau){){
//instructions
}

25
Les méthodes
• Déclaration:
[modificateur
modificateur]] [qualificateur
[qualificateur]] type nom(type1
nom1, type2 nom2, ….){
// instructions
}
• Modificateur : public, private,
private, protected
• Qualificateur : static
• Type : boolean
boolean,, int,
int, Float,
Float, Integer,
Integer, Boolean

26
Les méthodes
• Rappel : une méthode statique ne peut
appeler que des méthodes statiques
statiques..
• Une méthode peut être déclaré et définit
n’importe où dans la classe.
• Une méthode peut retourner un tableau (un
tableau en Java est un objet
objet))
• Le type de la valeur retournée doit
correspondre au type de retour de la
méthode.
27
Les méthodes
• Le compilateur doit être sûr de toujours
exécuter un return (pour les méthodes != void)
void)
• Exemple:
static double methode
methode((int a){
if(a>0){
return a;
}
}
// erreur
28
Les blocs
• Bloc = instructions entre {}
• Les blocs en Java sont autonomes:
if(a>0){
double y = 12.0;
}
// y n’est pas déclarée ici

29
Le passage des arguments et
l’affectation
• Le passage des arguments et l’affectation des
types primitives se font par valeur
valeur..
int x = 4;
int y = x;
x = 5; 4 4
x y 2
1

5
x

30
Le passage des valeurs et l’affectation
• Le passage des arguments et l’affectation des
types évolués se font par référence
référence..

Date x = new Date(2008,1,21);


Date y = x; 21/1/2008

x.setMonth(3);
x.setMonth (3); 1 2
x y
21/3/2008

3
y
x 31
Le passage des valeurs et l’affectation
• Le passage des arguments et l’affectation des
types évolués se font par référence
référence..

Date x = new Date(2008,1,21);


Date(2008,1,21);
Date y = x; 21/1/2008

x.setMonth(3);
x.setMonth (3); 1 2
x y
21/3/2008

3
y
x 32
Le passage des valeurs et l’affectation
class test{
Avant I5
public static void main(String[] argv
argv){
){
int []t1 = {1}; t1={1} t2={100}
methode(t1);
methode (t1);
System.out.println(t1[0]); t1
x t2
}
static void methode
methode((int [] x){ Après I5
int []t2 = {100};
t1={1} t2={100}
I5 x = t2;
System.out.println(x[0]);
} t1
x t2

} // 100 1 33
Le passage des valeurs et l’affectation
class test{
Avant I5
public static void main(String[] argv
argv){
){
int []t1 = {1}; t1={1} t2={100}
methode(t1);
methode (t1);
System.out.println(t1[0]); t1
x t2
}
static void methode
methode((int [] x){ Après I5
int []t2 = {100};
I5 x[0] = 100; t1={100} t2={100}
System.out.println(x[0]);
} t1
x t2

} // 100 100 34
Exercice

Donner un programme Java qui lit un tableau à


partir du clavier puis affiche son maximum.

35
Correction
package test1;
import java.util.
java.util.Scanner
Scanner;;
public class Main {
public static void main(String[] args
args)) {
System.out.println("donner la taille du tableau");
Scanner s = new Scanner(System.in);
int n = s.nextInt
s.nextInt();
();
int tab[] = new int
int[n];
[n];
for(int
for( int i=0;i<
i=0;i<tab.length;i
tab.length;i++)tab[i]
++)tab[i] = s.nextInt
s.nextInt();
();
int max = tab[0];
for(int
for( int v:tab)if(max<v)max = v;
System.out.println(max);
}

}
36
Concept de base de la POO

37
Les packages
• Un package est une unité logique regroupant un
certain nombre de classes.
• Le dossier qui contient des classes est appelé
package..
package
• L’instruction ‘package nomPackage;’
nomPackage;’ permet de
spécifier à quel package appartient une classe.
• Une classe peut être définie sans indiquer à quel
package elle appartient,
appartient, elle est alors considérée
comme faisant partie du package par défaut.
défaut.

38
Les packages
• Le package par défaut ne correspond à aucun
répertoire particulier.
• Les classes du package par défaut peuvent
être placées n’importe où dans les dossier
appartenant à la liste des dossier listés par la
variable d’environnement ‘path’
path’.
• L’instruction ‘import nomPackage;’
nomPackage;’ permet
d’importer les classes d’un package.

39
Les packages
• Pour pouvoir utiliser des classes
java appartenant à un autre
package, il faut utiliser Java
l’instruction import
import..
• Exemple: pour utiliser la classes UTIL
Scanner ou Vector on doit
importer le package util du
package java
java:: Scanner

• Import java.util.Scanner
java.util.Scanner;; Vector
//importer la classes Scanner
• Import java.util
java.util.*;
.*; ….

//importer toutes les classes du


package java.util
java.util..
40
Les packages
• 2 packages sont accessibles par défaut:
– Le package par défaut.
– Le package java.lang : qui contient un certain
nombre de classes d’usage général comme System
ou Math
Math..
– Exemple :
– On peut directement utiliser:
System.out.println(“ sans importer System”);
System.out.println( );
Math.abs(--15); // sans importer Math
Math.abs(

NB: Les autres packages doivent être importé


explicitement par l’instruction import.
41
Déclaration des classes
[Modificateur] [Qualificateur] class NomClasses
NomClasses{{
// corps de la classe
}

• Le nom de la classe doit débuter par une


majuscule.
• Exemple:
public class Point{
// corps de la classe
}
42
Les classes ‘final’
• Une classe ‘final’ ne peut être étendue pour
créer des sous
sous--classes
classes.. Par conséquent, ses
méthodes ne peuvent pas être redéfinies et
leurs accès peut donc se faire sans recherche
dynamique.
• Exemple:
final class ClasseFinale{
ClasseFinale{
// corps de la classes
}
43
Les classes internes
• Un fichier java peut contenir plusieurs classes.
• Dans le cas ou on a définit une classe qui ne sera utilisée que par une
seule classe.
• Exemple:
//les deux classes peuvent être codé dans un fichier Personne.java
// car Personne c’est la classe principale
class Personne{
NomComplet nom;
int age
age;;
int cin
cin;;
// méthodes
}
class NomComplet{
NomComplet{
String nom,prenom,prenomPere;
nom,prenom,prenomPere;
// méthodes
}
44
Les classes internes
• Dans certains cas, il est avantageux de placer la définition d’une
classe à l’intérieur d’une autre.
• Exemple:
//les deux classes peuvent être codé dans un fichier Personne.java
// car Personne c’est la classe principale
class Personne{
NomComplet nom;
int age
age;;
int cin
cin;;
static class NomComplet
NomComplet{{
String nom,prenom,prenomPere;
nom,prenom,prenomPere;
// méthodes
}
// méthodes
}
45
Les classes internes
• La référence à la classes NomComplet
devient ‘Personne.NomComplet
Personne.NomComplet’’.
• Lors de la compilation du fichier
Personne.java le compilateur produit deux
fichiers Personne.class et
Personne$NomComplet.class
Personne$ NomComplet.class..
• Il est possible d’importer une classe
imbriqué:
import nomPackage.Personne.NomComplet;
nomPackage.Personne.NomComplet;
46
L’encapsulation

Modificater Classes Classes Classes du Toutes les


courante dérivées même package classes

private oui non non non

protected oui oui oui non

public oui oui oui oui

Par défaut oui non oui non

47
L’encapsulation
• public : classes, interfaces, attributs et
méthodes.
• protected : attributs, méthodes, classes
internes (uniquement).
• private : attributs, méthodes, classes internes
(uniquement).
• Autorisation par défaut : classes, interfaces,
attributs et méthodes.

48
Déclaration et Initialisation des
attributs
[Modificateur] [Qualificateur] type nomAttribut ;

Modificateur : public, private,


private, protected
Qualificateur: static
static,, final

final : constantes.
Exemple:
class Rectangle{
static nbrRect
nbrRect;;
float x,y
x,y;;
….
}
49
Déclaration et Initialisation des
attributs
l’initialisation des attributs peut se faire selon 3
manières différentes:
• Directement lors de la déclaration des attributs
• À travers les initialiseurs
• À travers les constructeurs
Exemple:
class Rectangle{
int x = 1;
int y = 1;
….
}
50
Déclaration et Initialisation des
attributs
• À travers les initialiseurs:
Exemple:
class Rectangle{
float x,y
x,y;;
// initialiseur
{
x = Math.PI
Math.PI;;
float z = Math.cos(x/3);
y = z*2;
}
….
}
L’exécution de l’initialiseur est plus rapide que l’exécution des
constructeurs
L’exécution des initialiseur ce fait avant même l’exécution des
constructeurs 51
Déclaration et Initialisation des
attributs
• L’initialiseur peut être statique:
• Un initialiseur statique sert à initialiser les attributs statiques
• Il est exécuté une seule fois.
Exemple:
class Rectangle{
float x,y
x,y;;
static int nbrRectangle
nbrRectangle;;
// initialiseur
static {
nbrRectangle = 1;
}
….
}
52
Déclaration et Initialisation des
attributs
• Un constructeur est une méthode particulaire qui porte le
nom de la classe
• Un constructeur n’a pas de type de retour (même pas void)void)
• Il est généralement utilisé pour initialiser et/ou instancier des
attributs.
Exemple
class Rectangle{
float x,y
x,y;;
Rectangle(float
Rectangle( float _x, float _y){
x = _x;
y = _y;
}
…..
} 53
Déclaration des Méthodes
[Modificateur] [Qualificateur] type nomMethode
nomMethode(….){
(….){
}
Exemples:
void setX
setX((float x){ …. } // modificateur
float getX(){ …. } // accesseur
Rectangle(float
Rectangle( float _x, float _y){ … } // constructeur
String toString(){
toString(){ … } // méthode redéfinit
static int nbrRect
nbrRect(){
(){ … } // méthode statique
final int afficher(){ … } // méthode finale 54
Accesseur/Modificateur
• Un accesseur est une méthode qui permet de renvoyer
la valeur d’un attribut.
L’accesseur commence par get suivi du nom de l’attribut.
l’attribut.
Exemple:
float getX
getX{return
{return x;}
• Un modificateur est une méthode qui permet de
modifier la valeur d’un attribut.
Le modificateur commence par set suivi du nom de
l’attribut..
l’attribut
Exemple:
void setX
setX((float _x){x = _x;}
55
Les constructeurs
• Un constructeur est une méthode
-Sans type de retour
-Porte le nom de la classe( commence par une majuscule)
-Peut avoir un nombre quelconque de paramètres
• Une classe peut avoir un ou plusieurs constructeurs
• Si une classe n’a aucun constructeur, le
constructeur
co nstructeur par défaut est lui associé
automatiquement..
automatiquement
• Si un constructeur avec des paramètres est
défini, la classe en question n’a plus le
constructeur par défaut. 56
Méthodes statiques et méthodes final
• Une méthode statique est une méthode qui ne
peut manipuler que des attributs statiques.
• Une méthode statiques est une méthode accessible
via le nom de la classe.
classe.
Exemple :
NomClasse.nomMethodeStatique();
NomClasse.nomMethodeStatique ();
• Une méthode final est une méthode qui ne peut
pas être redéfinit dans les sous-
sous-classes.
• L’appel d’une méthode final est plus rapide de
l’appel à une méthode non final.
final.
• L’appel à une méthode final est remplacé par le
code de la méthode.
57
Masquage des attributs
• Dans une méthode, si un paramètre porte le même nom qu’un
attribut alors l’attribut sera masqué par ce paramètre.
Exemple:
class Rectangle{
float x,y
x,y;;
Rectangle(float
Rectangle( float x, float y){
// x permet d’accéder à x le paramètre
// pour accéder à x l’attribut on doit utiliser this
this.x = x;
this.y = y;
}
}
• this est une référence sur l’objet courant.
58
Masquage des attributs
• Rq : l’accès à un paramètre à l’intérieur d’une méthode
est plus rapide que l’accès à un attribut.
Exemple:
class Rectangle{
float x;
Methode((float v){
Methode
x = v;
// x et v sont égaux
// l’accès à v est plus rapide que l’accès à x
float a=v;
// float a = x;
}
} 59
Masquage des attributs
• Rq : l’accès à un paramètre à l’intérieur d’une méthode
est plus rapide que l’accès à un attribut.
Exemple:
class Rectangle{
float x;
Methode((float v){
Methode
x = v;
// x et v sont égaux
// l’accès à v est plus rapide que l’accès à x
float a=v;
// float a = x;
}
} 60
Surcharge de méthodes
• Une méthode peut être surchargé
surchargé,, dans le sens où
il peut y avoir plusieurs méthodes qui portent le
même nom mais de signatures différentes.
différentes.
• Une méthode est identifié par sa signature qui doit
être différente avec les autres méthodes
méthodes..
• Signature : type de retour, nom de la méthodes,
nombre et types des paramètres.
• Un constructeur peut être surchargé.

61
Héritage
• En Java Chaque classe dérive d’une classe de
niveau supérieur (sur
(sur--classe
classe)) sauf la classe
Object,, l’ancêtre de toutes les classes.
Object
• Tout objet est du type de sa classe de
déclaration,, mais aussi du type de toutes ses
déclaration
sur--classes
sur classes..
• Une classe dérivé est une sous
sous--classe d’une sur
sur--
classe

62
Héritage
• Exemple:
class Personne{
String nom;
int age
age;;
}
class Etudiant extends Personne{
int nce
nce;;
}
63
Héritage
• Lorsqu’un constructeur est exécuté, les
constructeurs des classes parentes le sont
également.
• Si à la première instruction le compilateur ne
trouve pas un appel à super(…) ou this
this(…)
(…) il
rajoute super(), dans ce cas la sur-
sur-classe doit
contenir un constructeur sans arguments.
• L’utilisation de this
this(…)
(…) permet de faire appel à
un constructeur de la même classe.
• L’un des constructeurs appelés doit contenir un
appel à super(…) dans la première instruction. 64
Classe A A(…){ obC
a1 1
….. a1
a2 } a2
m1()

Classe B B(…){ obC


b1 super(…); 2 a1
m2() ….. a2
} b1

C(…){ obC
Classe C a1
c1 super(…); 3
….. a2
m3() B1
}
c1
C obC = new C(…) 65
Héritage
• Exemple : corriger le programme suivant de deux manières
différentes.
class Personne{
String nom;
int âge;
Personne(String nom, int âge){
this.nom = nom;
this.âge = âge;
}
}
class Etudiant extends Personne{
int nce
nce;;
void setNCE
setNCE((int n){
n){nce
nce =n;}
} 66
Héritage
• 1ére solution :
class Personne{
String nom;
int âge;
Personne(){}
Personne(String nom, int âge){
this.nom = nom;
this.âge = âge;
}
}
class Etudiant extends Personne{
int nce
nce;;
void setNCE
setNCE((int n){
n){nce
nce =n;}
} 67
Héritage
• 2éme solution :
class Personne{
String nom;
int âge;
Personne(String nom, int âge){
this.nom = nom;
this.âge = âge;
}
}
class Etudiant extends Personne{
int nce
nce;;
Etudiant(String n, int a, int nc
nc){
){
super(n,a
super( n,a);//appeler
);//appeler le constructeur qui possède la signature suivante:
// Personne(String, int
int))
nce = nc
nc;;
}
void setNCE
setNCE((int n){
n){nce
nce =n;}
68
}
Héritage
• Une méthode peut être hérité
hérité..
Exemple :
class Personne{ …
public static void main(){
String nom, Etudiant e = new Etudiant();
int âge; ….
e.afficher();
e.afficher(); // affiche nom suivi de âge
void afficher(){ }
System.out.println(nom+âge);
}

}
class Etudiant extends Personne{
int nce
nce;;

69
}
Héritage
• Une 2éme déclaration d’une méthode dans une classe dérivée remplace la
méthode héritée
héritée..
Exemple :
class Personne{
String nom, …
int âge; public static void main(){
Etudiant e = new Etudiant();
void afficher(){
….
System.out.println(nom+âge); e.afficher
e.afficher();
(); // affiche nom suivi de âge suivi de
} nce
… }
}
class Etudiant extends Personne{
int nce
nce;;
void afficher(){
super.afficher();
super.afficher();
System.out.println(nce
System.out.println( nce);
);
}
… 70
}
Polymorphisme
Héritage du type.
Résolution dynamique des liens.
Polymorphisme

Un même code s’exécute de façon différente selon


la donnée à la quelle il s’applique.

71
Polymorphisme
Exemple
class FormeGeometrique{
FormeGeometrique{
//corps
}
class Cercle extends FormeGeometrique
FormeGeometrique{{
// corps
}
class Rectangle extends FormeGeometrique
FormeGeometrique{{
// corps
72
}
Polymorphisme
Exemple

FormeGeometrique fr = new Rectangle();


FormeGeometrique fc = new Cercle();
fc.dessiner();
fc.dessiner (); // dessine un cercle
fr.dessiner();
fr.dessiner (); // dessine un rectangle
Cercle c = fc;
fc; // erreur
Cercle c = (Cercle)fc
(Cercle)fc;; // OK

73
Polymorphisme
Exemple 2 : (polymorphisme, redéfinition et
surcharge de méthodes) public
{
static void main(String[] astrArgs)

A a = new A();
class A { A ab = new B();
B b = new B();
int f(A a) { return 1; } // Partie a
System.out.println( a.f(a) );
} System.out.println( a.f(ab) );
System.out.println( a.f(b) );
class B extends A { // Partie ab
System.out.println( ab.f(a) );
int f(A a) { return 2; } System.out.println( ab.f(ab) );
System.out.println( ab.f(b) );
int f(B b) { return 3; } // Partie b
System.out.println( b.f(a) );
} System.out.println( b.f(ab) );
System.out.println( b.f(b) );
} 74
Polymorphisme
Class A Class B
int f(A a) int f(A a) // héritée de A
int f(A a) // Redéfini
int f(B b) // Surchargée

A a = new A();
System.out.println( a.f(a) );
System.out.println( a.f(ab) );
System.out.println( a.f(b) );

75
Polymorphisme
Class A Class B
int f(A a) int f(A a) // héritée de A
int f(A a) // Redéfini
int f(B b) // Surchargée

A ab = new B();
System.out.println( ab.f(a) );
System.out.println( ab.f(ab) );
System.out.println( ab.f(b) );

76
Polymorphisme
Class A Class B
int f(A a) int f(A a) // héritée de A
int f(A a) // Redéfini
int f(B b) // Surchargée

B b = new B();
System.out.println( b.f(a) );
System.out.println( b.f(ab) );
System.out.println( b.f(b) );

77
Exercice
Créer une classe FormeGeometrique.
FormeGeometrique.
Créer les classes suivantes : Rectangle et Cercle
qui héritent de la classe FormeGeometrique.
FormeGeometrique.

78
Les classes abstraites
• Une méthode déclarée abstract ne peut pas être
exécutée..
exécutée
• Une classe qui contient une méthode abstract
doit être déclarée abstract
abstract..
• Une classe abstract ne peut pas être instanciée.
• Une classe peut être déclarée abstract
abstract,, même si
elle ne comporte pas de méthodes abstract
abstract..

79
Les classes abstraites
• Pour pouvoir instancier une sous
sous--classe d’une
classe abstract on doit redéfinir toutes les
méthodes abstract de la sur
sur--classe
classe..
• Si une méthode abstract n’a pas été redéfini
redéfini,, la
sous--classe doit être déclaré explicitement
sous
abstract..
abstract
• Les méthodes abstract n’on pas
d’implémentation..
d’implémentation
• Leurs déclaration doit être suivi par point
point--
virgule..
virgule
80
Les interfaces
• Une interface est une catégorie particulière de
classes qui ne contient que des méthodes
abstracts..
abstracts
• Il n’est pas nécessaire de l’indiquer
explicitement,, de même il n’est pas nécessaire
explicitement
de déclarer leurs méthodes abstract
abstract..
• Une interface ne peut contenir que des
variables static et final et des méthodes
abstraites..
abstraites
• Une interface peut dériver de plusieurs autres
interfaces et une classe peut dériver de
plusieurs interfaces
interfaces.. 81
Les interfaces
• Une interface n’est pas une classe:
– Pas de constructeur
– Impossible de faire new
• Une interface attribue un type supplémentaire à
une classe d’objets.
• Il est impossible de construire un objet avec
l’interface
• On peut déclarer une variable de type interface
interface..
• Y affecter un objet d’une classe qui implémente
l’interface..
l’interface
• Faire un transtypage explicite vers l’interface.
• Une interface est un moyen d’attribuer des
composants communs à des classes non non--liées par
82
une relation d’héritage
d’héritage..
Les interfaces
• On peut déclarer une hiérarchie d’interfaces
– Mot
Mot--clé extends
– La classe qui implémente une interface reçoit aussi
le type des super-
super-interfaces.
interface nomInterface1{
// corps de l’interface
}
interface nomInterface2 extends nomInterface1{
// corps de l’interface
}
83
Les interfaces
• Une classe peut implémenter une interface via
le mot réservé implements
interface nomInterface1{
// corps de l’interface
}
class nomClasse implements nomInterface1{
// corps de la classe
}

84
Exercice
Créer une interface FormeGeometrique.
FormeGeometrique.
Créer les classes suivantes : Rectangle et Cercle
qui héritent de la classe FormeGeometrique.
FormeGeometrique.

85
Les Exceptions

86
Les Exceptions
Problème: identifier le problème
class Factorielle {
static int factorielle(
factorielle(int
int n){
int res = 1;
for(int
for(int i = 1; i <= n; i++) {
res = res * i;
}
return res;
res;
}
87
}
Les Exceptions
Problème: si n est < 0 alors le programme ne va pas
retourner une valeur indiquant une erreur.
Solution 1:
class Factorielle {
static int factorielle(
factorielle(int
int n){
if(n<0) return -1;
int res = 1;
for(int
for(int i = 1; i <= n; i++) {
res = res * i;
}
return res;
res;
} 88
}
Les Exceptions
Si un autre utilisateur veut utiliser la classe
Factorielle que nous avons implémenté.

class Calcul{
public float clacul
clacul((int i){
int a = Factorielle. Factorielle(n);
Factorielle(n);
return Math.sqr(3*a)
Math.sqr(3*a);;
}
}
89
Les Exceptions
Problème le 2ième programmeur n’a pas pris en
compte le cas où la valeur retourné par la
factorielle est négative.
Car une factorielle par définition doit être
toujours positive.
Cas fréquent surtout pour les grands projets.

Solution: utiliser les exceptions.


90
Les Exceptions
De nombreux langages de programmation de haut
niveau possèdent un mécanisme permettant de
gérer les erreurs qui peuvent intervenir lors de
l’exécution d’un programme.
programme.
Le mécanisme de gestion d’erreur le plus répandu
est celui des exceptions
exceptions..
lorsqu’une fonction n’est pas définie pour
certaines valeurs de ses arguments on lance une
exception. Par exemple, la fonction factorielle
n’est pas définie pour les nombres négatifs
91
Les Exceptions
– Une exception est un message envoyé lors d'une erreur
à l'exécution.
• Ce message contient des informations sur l'erreur qui
s'est produite.
– JAVA stoppe l'exécution du code là où l'exception a été
levée.
• et envoie le "message" exception
• sans capture du message exception, celui ci provoque
l'arrêt successif des méthodes appelées jusqu'à la
machine JVM qui vous indique l'erreur produite avec
beaucoup de détails issus des informations du
message.
– Les exceptions sont organisées en classe. 92
Les Exceptions
Exemple:
class Factorielle {
static int factorielle(
factorielle(int
int n) throws PasDefini{
PasDefini{
// throws PasDefini permet de faire propager l’exception
int res = 1;
if (n<0
(n<0){
){
throw new PasDefini
PasDefini()
();;
// générer une exception de type PasDefini
}
for(int
for( int i = 1; i <= n; i++) {
res = res * i;
}
return res
res;;
}
}
class PasDefini extends Exception{}
93
// définition de l’exception (classe) PasDefini
Les Exceptions
Définir une exception
Afin de définir une nouvelle sorte d’exception, on
crée une nouvelle classe en utilisant une
déclaration de la forme suivante :
class NouvelleException extends
ExceptionDejaDefinie {}

ExceptionDejaDefinie doit être définit et hérite de


la classe throwable.
throwable.
94
Les Exceptions
Il existe de nombreuses classes d’exceptions prédéfinies en Java,
que l’on peut classer en trois
catégories :
– Celles définies en étendant la classe Error : elles représentent
des erreurs critiques. Par exemple, une exception de type
OutOfMemoryError..
OutOfMemoryError
– Celles définies en étendant la classe Exception : elles
représentent les erreurs qui doivent normalement être gérées
par le programme. Par exemple, une exception de type
IOException est lancée en cas d’erreur lors de la lecture d’un
fichier..
fichier
– Celles définies en étendant la classe RuntimeException : elles
représente des erreurs pouvant éventuellement être gérée
par le programme. L’exemple typique de ce genre d’exception
est NullPointerException,
NullPointerException, qui est lancée si l’on tente d’accéder
au contenu d’un tableau ou d’un objet qui vaut null
null..
95
Les Exceptions
Lorsque l’on veut lancer une exception, on utilise
le mot clé throw suivi de l’exception à lancer
qu’il faut auparavant la créer avec new
NomException(),
NomException (), de la même manière que
lorsque l’on crée un nouvel objet par un appel à
l’un de des constructeurs de sa classe. Ainsi
lancer une exception de la classe PasDefini
s’écrit :
throw new PasDefini();
PasDefini();

96
Les Exceptions

Lorsqu’une exception est levée, l’exécution


normale du programme s’arrête et on saute
toutes les instructions jusqu’à ce que l’exception
soit rattrapée ou jusqu’à ce que l’on sorte du
programme.

97
Les Exceptions
Une méthode doit capturer l’exception ou bien la
renvoyer vers la méthode appelante.
Par défaut une méthode ne peut faire propager
que les exceptions de type Error ou de type
RuntimeException..
RuntimeException
Si dans une méthode il y a une possibilité de
générer une exception alors le compilateur doit
être sure que cette exception a été capté ou
propagé par la méthode. Sinon il va générer une
erreur de compilation.
98
Les Exceptions
Exemple:
class Calcul{
public float clacul
clacul((int i){
int a = Factorielle. Factorielle(n);
Factorielle(n);
return Math.sqr(3*a)
Math.sqr(3*a);;
}
}
Dans cet exemple il n’y a ni capture ni propagation de
l’exception.
Erreur de compilation.
99
Les Exceptions
Exemple:
class Calcul{
public float clacul
clacul((int i) throws PasDefini
PasDefini{{
int a = Factorielle. Factorielle(n);
Factorielle(n);
return Math.sqr(3*a)
Math.sqr(3*a);;
}
}
Si une exception de type PasDefini est généré alors
elle sera routé vers la méthode appelante. Et il y
aura une sortie immédiate de la méthode courante.
return Math.sqr(3*a)
Math.sqr(3*a);; ne sera pas exécuté.
100
Les Exceptions
Exemple:
class Calcul{
public float clacul
clacul((int n){
int a;
try{{
try
a = Factorielle. Factorielle(n);
Factorielle(n);
}catch(PasDefini
}catch( PasDefini e1){
int v = Math.abs(n);
a = Factorielle. Factorielle(v);
Factorielle(v);
}catch(ExempleDeException
}catch( ExempleDeException e2){
//instructions
}finally{
finally{
System.out.println("une exception à été détecté ");
}
return Math.sqr(3*a)
Math.sqr(3*a);;
}
}
Si une exception de type PasDefini est généré alors elle sera capturé. L’exécution du bloc try sera
interrompu et il y aura un passage immédiat au bloc catch correspondant à l’exception, puis un passage
au bloc finally.
Math.sqr(3*a);; sera exécuté juste après le bloc catch.
return Math.sqr(3*a)

101
Les Exceptions
Exemple:
class Calcul{
public float clacul
clacul((int n){
int a;
try{{
try
a = Factorielle. Factorielle(n);
Factorielle(n);
}catch(PasDefini
}catch( PasDefini e1){
int v = Math.abs(n);
a = Factorielle. Factorielle(v);
Factorielle(v);
}catch(ExempleDeException
}catch( ExempleDeException e2){
//instructions
}finally{
finally{
System.out.println("une exception à été détecté ");
}
return Math.sqr(3*a)
Math.sqr(3*a);;
}
}
Si une exception de type PasDefini est généré alors elle sera capturé. L’exécution du bloc try sera
interrompu et il y aura un passage immédiat au bloc catch correspondant à l’exception, puis un passage
au bloc finally.
Math.sqr(3*a);; sera exécuté juste après le bloc catch.
return Math.sqr(3*a)

102
Les interfaces graphiques

103
Les Interfaces graphiques
Les programmes à interfaces graphiques font usage
des classes awt
awt(abstract
(abstract windowing toolkit
toolkit)) et/ou
swing..
swing
Ils sont dirigés par évènements
évènements..
Classe de base des awt : la classe abstraite
Component.
Classe de base des composants swing : JComponent.
JComponent.
On distingue, par service:
– les classes conteneur
– les classes d'interaction (boutons, champs de textes)
– les menus et dialogues
Swing offre une palette bien plus large.
AWT utilise les APIs des systèmes d’exploitations. 104
Les Interfaces graphiques
Swing est une extension des AWT
nombreux nouveaux composants
nombreuses facilités
séparation entre:
– modèle (données)
– aspect visuel (UI)
– contrôle
Les composants sont légers, sauf JApplet
JApplet,,
JWindow,, JFrame
JWindow JFrame,, JDialog
105
Les Interfaces graphiques
Component

Container

Window Jcomponent

Frame AbstractButton Jlabel Jlist JComboBox …

JFrame Jbutton JToggleButton

JcheckBox

JRadioButton
106
Les Interfaces graphiques
Exemple de code typique:
package calculatrice;
import javax.swing.*;
javax.swing.*;
import java.awt.*;
public class Main {
public static void main(String[] args)
args) {
JFrame f = new JFrame
JFrame("Titre
("Titre de la fenetre
fenetre");
");
// Créer une nouvelle fenêtre de Type JFrame
f.setSize(300,
f.setSize(300, 200);
// Redimensionner la fenêtre
Container c = f.getContentPane();
f.getContentPane();
// Récupérer le conteneur principal de la fenêtre
// Dans ce conteneur on pourra par la suite ajouter des composants
f.setVisible((true);
f.setVisible true);
// afficher la fenêtre
}
}
107
Les Interfaces graphiques
Par défaut un click sur le bouton
de fermeture de la fenêtre ne
ferme la fenêtre sans arrêter le
programme.

Pour arrêter le programme on doit associer à ce


bouton un evenement qui exécute l’instruction
System.exit();
System.exit(); ou bien d’exécuter la méthode
suivante de la classe JFrame:
JFrame:
f.setDefaultCloseOperation((JFrame.EXIT_ON_CLOSE);
f.setDefaultCloseOperation JFrame.EXIT_ON_CLOSE);
108
Les Interfaces graphiques
Les boutons:

JButton jb = new JButton ("Bouton OK");


// créer un objet de type JButton
c.add(jb
c.add( jb);
);
// ajouter le bouton au conteneur
109
Les Interfaces graphiques
Les cases à cocher:

JCheckBox r = new JCheckBox ("Rouge");


JCheckBox v = new JCheckBox ("Vert");
JCheckBox b = new JCheckBox ("Bleu");
// créer 3 cases à cocher
v.setSelected((true);
v.setSelected true);
// sélectionner la case à cocher ‘Vert’
c.add(r);
c.add(v);
c.add(b);
// ajouter les cases à cocher au conteneur
110
Les Interfaces graphiques
Les cases boutons radio:

JRadioButton r = new JRadioButton ("Rouge");


JRadioButton v = new JRadioButton ("Vert");
JRadioButton b = new JRadioButton ("Bleu");
// créer 3 boutons radio
ButtonGroup gb = new ButtonGroup
ButtonGroup();
();
// créer un groupe de bouton
gb.add(r); gb.add(v); gb.add(b);
// ajouter les 3 boutons au même groupe
v.setSelected((true);
v.setSelected true);
// sélectionner le bouton ‘Vert’
c.add(r);
c.add(v);
c.add(b);
// ajouter les 3 boutons au conteneur principal 111
Les Interfaces graphiques
Les listes:
String [] couleur = {"Rouge","Vert
{"Rouge","Vert","Bleu"};
","Bleu"};
// créer une liste
JList jl = new JList
JList(couleur);
(couleur);
//Pour sélectionner un élément
jl.setSelectedIndex(2);
jl.setSelectedIndex (2);
//ajouter une barre de défilement
// 1 spécifier le nombre de lignes visibles
jl.setVisibleRowCount(2);
jl.setVisibleRowCount (2);
// 2 créer un objet de type JScrollPane
JScrollPane jsp = new JScrollPane
JScrollPane((jl
jl);
);
//3 ajouter le JScrollPane dans le
// conteneur de la fenêtre
c.add(jsp
c.add( jsp);
); 112
Les Interfaces graphiques
Les listes:
Il existe 3 sortes de boites de liste:
Mode Type de sélection
SINGLE_SELECTION Sélection d’une seule valeur
SINGLE_INTERVAL_SELECTION Sélection d’une seule plage de valeurs (contigues)
MULTIPLE_INTERVAL_SELECTION Sélection d’un nombre quelconque de plages de
valeurs

Par défaut, le type d’une boite de liste est


MULTIPLE_INTERVAL_SELECTION
Pour changer le mode de sélection on utilise
setSelectionMode(SINGLE_SELECTION);
setSelectionMode (SINGLE_SELECTION);
113
Les Interfaces graphiques
Les listes:
Pour récupérer la valeur sélectionnée de la liste à sélection
simple on utilise la méthode getSelectedValue();
getSelectedValue();
Exemple : String s = (String) jl.getSelectedValue
jl.getSelectedValue();
();
Si la liste est de type sélection multiple getSelectedValue
retourne la 1ére valeur. Pour récupérer tous les valeurs il
faut utiliser la méthode getSelectedValue
getSelectedValue..
Exemple :
Object[] valeurs = jl.getSelectedValues();
jl.getSelectedValues();
for(int
for( int i=0; i<
i<valeurs.length
valeurs.length;; i++)
System.out.println((String) jl); jl);

Le transtypage avec (String) est obligatoire car


getSelectedValue()
getSelectedValue () retourne un objet de type Object. 114
Les Interfaces graphiques
Les listes déroulantes:
String [] couleur = {"Rouge","Vert
{"Rouge","Vert","Bleu"};
","Bleu"};
// créer une liste déroulante
JComboBox jc = new JComboBox
JComboBox(couleur);
(couleur);
// sélectionner l’élément d’indice 2
jc.setSelectedIndex(2);
jc.setSelectedIndex (2);
// choisir le nombre Max des
// éléments à afficher
// le ScrollPane est affiché
// automatiquement
jc.setMaximumRowCount(2);
jc.setMaximumRowCount (2);
115
Les Interfaces graphiques
Les menus et barres d’outils:
// il faut tout d'abord créer une barre de menu, en suite l’ajouter à l’objet fenêtre
(JFrame)
JFrame)
JMenuBar mb= new JMenuBar();
JMenuBar();
f.setJMenuBar(mb);
f.setJMenuBar (mb);

// la 2iéme étape consiste, à ajouter des Menus dans la barre des menu
JMenu fichier = new JMenu
JMenu("Fichier");
("Fichier");
JMenu edition = new JMenu("Edition");
JMenu("Edition");
mb.add(fichier);
mb.add(edition
mb.add( edition);
);

// ajouter des éléments dans chaque menu


JMenuItem ouvrir = new JMenuItem("Ouvrir");
JMenuItem("Ouvrir");
JMenuItem enregistrer = new JMenuItem("Enregistrer");
JMenuItem("Enregistrer");
fichier.add(ouvrir);
fichier.add(enregistrer);
116
Les Interfaces graphiques
Les menus et barres d’outils:
// créer un objet de type barre d’outils
JToolBar bo = new JToolBar
JToolBar();
();
// créer et ajouter des boutons à la barre d’outil
JButton bv = new JButton
JButton("Vert");
("Vert");
JButton br = new JButton
JButton("Rouge");
("Rouge");
JButton bb = new JButton
JButton("Bleu");
("Bleu");
bo.add(bv
bo.add( bv);
);
bo.add(br
bo.add( br);
);
bo.add(bb
bo.add( bb););
// modifier les couleurs des boutons
bv.setBackground((Color.GREEN);
bv.setBackground Color.GREEN);
br.setBackground(Color.RED);
br.setBackground (Color.RED);
bb.setBackground((Color.BLUE);
bb.setBackground Color.BLUE);
// ajouter la barre d’outils au conteneur de la fenêtre
c.add(bo
c.add(bo);
); 117
Les Interfaces graphiques
Les bulles d’aide:
// java permet d’afficher les bulles d’aide lorsqu’on
pointe le curseur de la souris sur un composant
graphique.
Cette bulle d’aide est défini par la méthode
setToolTipText(String
setToolTipText (String text
text);
);
Exemple:
bb.setToolTipText("choisir
bb.setToolTipText ("choisir la couleur bleu");

118
Les Interfaces graphiques
Les boites de dialogue:
La boite de dialogue est un conteneur. Elle permet
de regrouper n’importe quels composants dans
une sorte de fenêtre.
Java propose un certain nombre de boites de
dialogues standard obtenues à l’aide méthodes
des la classe JOptionPane.
JOptionPane.

119
Les Interfaces graphiques
Les boites de dialogue:
//afficher une boite de dialogue
// le 1er paramètre est le nom de la fenêtre
// le 2ième paramètre est le message
JOptionPane.showMessageDialog(f,
JOptionPane.showMessageDialog (f, "Bonjour");

120
Les Interfaces graphiques
Les gestionnaires de mise en forme (Layout
(Layout manager)
Pour chaque conteneur (fenêtre, boîte de dialogue,
…), Java permet de choisir un gestionnaire de mise
en forme (en anglais "Layout
"Layout manager")
manager")
responsable de la disposition des composants.
Les gestionnaires de mise en forme proposés par Java
sont les gestionnaires BorderLayout
BorderLayout,, FlowLayout
FlowLayout,,
CardLayout,, GridLayout
CardLayout GridLayout,, BoxLayout et
GridBagLayout.. Ce sont tous des classes du
GridBagLayout
paquetage java.awt dérivées de la classe Object et
qui implémentent l'interface LayoutManager
LayoutManager..
121
Les Interfaces graphiques
La méthode setLayout de la classe Container
permet d'associer un gestionnaire de mise en
forme à un conteneur.
Le gestionnaire BorderLayout est le gestionnaire
par défaut des fenêtres et des boîtes de
dialogue.

122
Les Interfaces graphiques
Le gestionnaire de mise en forme BorderLayout permet de placer
chaque composant dans une zone géographique.
L'emplacement d'un composant est choisi en fournissant en argument
de la méthode add de la classe Container l'une des constantes
entières suivantes (on peut utiliser indifféremment le nom de la
constante ou sa valeur) :

BorderLayout.NORTH "North
North""
BorderLayout.SOUTH "South"
BorderLayout.EAST "East"
BorderLayout.WEST "West"
BorderLayout.CENTER "Center"

Si aucune valeur n'est précisée à la méthode add


add,, le composant
est placé au centre.

123
Les Interfaces graphiques
JFrame f = new JFrame
JFrame(" ("Fenetre
Fenetre ego");
f.setSize(200,200);
f.setSize(200,200);
JButton b1 = new JButton
JButton("
("North
North");
");
JButton b2 = new JButton
JButton("
("West
West");
");
JButton b3 = new JButton
JButton("
("Center
Center");
");
JButton b4 = new JButton
JButton("
("East
East");
");
JButton b5 = new JButton
JButton("
("South
South");
");
c.add(b1,"
c.add(b1 ,"North
North");
");
c.add(b2,"
c.add(b2 ,"West
West");
");
c.add(b3,"
c.add(b3 ,"Center
Center");");
c.add(b4,"
c.add(b4 ,"East
East");
");
c.add(b5,"
c.add(b5 ,"South
South");
");
f.setVisible((true);
f.setVisible true);
f.setDefaultCloseOperation((JFrame.EXIT_ON_CLOSE);
f.setDefaultCloseOperation JFrame.EXIT_ON_CLOSE);

124
Les Interfaces graphiques

Le gestionnaire de mise en forme FlowLayout


permet de disposer les composants les uns à la
suite des autres, de gauche à droite.

125
Les Interfaces graphiques
c.setLayout(new FlowLayout());
c.setLayout(new FlowLayout());
f.setSize(200,200);
f.setSize(200,200);
JButton b1 = new JButton("
JButton("11");
JButton b2 = new JButton("
JButton("22");
JButton b3 = new JButton("
JButton("33");
JButton b4 = new JButton
JButton("
("44");
JButton b5 = new JButton("
JButton("55");
c.add(b1);
c.add(b1 );
c.add(b2);
c.add(b2 );
c.add(b3);
c.add(b3 );
c.add(b4);
c.add(b4 );
c.add(b5);
c.add(b5 );
126
Les Interfaces graphiques

Le gestionnaire de mise en forme GridLayout


permet de disposer les composants les uns à
la suite des autres sur une grille régulière,
chaque composant occupant une cellule de la
grille.
Les dernières cases d'une grille peuvent rester
vides. Toutefois si plus d'une ligne de la grille
est vide, le gestionnaire réorganisera la grille,
de façon à éviter une perte de place.
127
Les Interfaces graphiques
c.setLayout(new GridLayout(3,3));
c.setLayout(new GridLayout(3,3));
JButton b1 = new JButton("
JButton("11");
JButton b2 = new JButton("
JButton("22");
JButton b3 = new JButton("
JButton("33");
JButton b4 = new JButton
JButton("
("44");
JButton b5 = new JButton("
JButton("55");
c.add(b1);
c.add(b1 );
c.add(b2);
c.add(b2 );
c.add(b3);
c.add(b3 );
c.add(b4);
c.add(b4 );
c.add(b5);
c.add(b5 );
128
Les Interfaces graphiques

Il est possible de n'associer aucun gestionnaire


de mise en forme à un conteneur. Les
composants sont alors ajoutés au conteneur à
l'aide de la méthode setBounds de la classe
Component.

129
Les Interfaces graphiques

c.setLayout(null);
c.setLayout(null);
JButton b1 = new JButton
JButton("1");
("1");
c.add(b1);
c.add(b1 );
b1.setBounds
b1.setBounds(30,30,80,30);
(30,30,80,30);

130
Les Interfaces graphiques
La gestion des événements

L’événement émis suite à un clic souris dans une


fenêtre est de type MouseEvent …
L’événement émis suite à un clic souris sur un bouton
est de type ActionEvent …
Tout événement qui peut se produire dans une
interface graphique est de type XEvent
XEvent,, classe du
paquetage java.awt.event ou du paquetage
javax.swing.event dérivée de la classe EventObject
(classe du paquetage java.util dérivée de la classe
Object) …
131
Les Interfaces graphiques
La gestion des événements

Un composant ne traite pas forcément lui même les


événements qu’il génère. Il délègue ce traitement
à des objets particuliers appelés écouteurs
écouteurs..
En fonction des événements qu’ils traitent, un
écouteur doit implémenter une interface
particulière, dérivée de l’interface EventListener
EventListener,,
qui correspond à une catégorie d’événements.
Pour traiter un événement de type XEvent
XEvent,, un
écouteur doit implémenter l’interface XListener
XListener..
132
Les Interfaces graphiques
public interface MouseListener extends EventListener {
public void mousePressed
mousePressed((MouseEvent e) ;
public void mouseReleased
mouseReleased((MouseEvent e) ;
public void mouseClicked
mouseClicked((MouseEvent e) ;
public void mouseEntered
mouseEntered((MouseEvent e) ;
public void mouseExited
mouseExited((MouseEvent e) ;
}
Un écouteur de souris doit implémenter l’interface
MouseListner..
MouseListner
133
Les Interfaces graphiques

Créer un écouteur monPremierEcouteur pour


traiter l’événement mouseClicked
mouseClicked..
Afficher « Bonjour » suite à cet événement.

134
Les Interfaces graphiques
class monPremierEcouteur implements MouseListener
{
public void mouseClicked(
mouseClicked(MouseEvent e) {
System.out.println("Bonjour");
}

public void mousePressed


mousePressed((MouseEvent e) { }
public void mouseReleased
mouseReleased((MouseEvent e) { }
public void mouseEntered
mouseEntered((MouseEvent e) { }
public void mouseExited
mouseExited((MouseEvent e) { }
}
135
Les Interfaces graphiques
public static void main(String[] args)
args) {
JFrame f = new JFrame("
JFrame("Fenetre
Fenetre ego");
f.setSize(200,200);
f.setSize (200,200);
JButton b1 = new JButton("1");
JButton("1");
Container c = f.getContentPane
f.getContentPane();();
c.add(b1);
c.add(b1 );
f.setVisible((true);
f.setVisible true);
b1.addMouseListener
b1. addMouseListener(new (new monPremierEcouteur ());
f.setDefaultCloseOperation((JFrame.EXIT_ON_CLOSE);
f.setDefaultCloseOperation JFrame.EXIT_ON_CLOSE);
}
136