Cours Java Smi Ige s5

Cours JAVA
Filières: SMI, IGE

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

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

d’applications d’entreprise . Elle contient les classes J2SE plus d’autres
classes pour le développement d’applications d’entreprise.
Java 2 Micro Edition (J2ME). pour les produits
d’électronique grand public (téléphones portables,..) dans ce cas
seule une petite partie du langage est utilisée.
Chaque édition contient un kit de développement Java 2 (SDK) pour
développer des applications et un environnement d’exécution Java 2 (JRE)
pour les exécuter.
GL_IGE_SMI
3- 4 Le code source
- Une application java est généralement composée de
plusieurs fichiers source. Les fichiers source de java ont
l’extension .java.
- Un fichier .java peut contenir plusieurs classes.
- Le nom du fichier source java doit être le même que celui
de la classe publique que ce fichier renferme (Un fichier java ne
peut pas contenir plus d’une classe publique)
3- 5La compilation
* Le byte code
- La compilation va transformer le code source en J-code ou byte-
code Java indépendant de toute plate forme
- La commande qui permet la compilation est la suivante :
Javac nom_fich.java
Création d’un ou plusieurs fichiers .class.
GL_IGE_SMI
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
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
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
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
5 - 3 Conventions d’écriture en JAVA
Type Convention Exemple
Nom d’une class Polygone

classe Débute par une majuscule
Nom d’un Débute par une minuscule premierObjet

objet Peut s’étaler sur plusieurs mots Chaque
mot commence par une majuscule sauf le
premier
Nom de Débute par une minuscule void ecrire()

méthode Sauf pour le constructeur
Constante S’écrit en majuscules A_CONSTANT
GL_IGE_SMI
5- 4 Un premier exemple
public class Premier
{
public static void main (String[ ] arg)
{
System.out.println( ‘‘bravo’’) ;
}
}
public : visible de partout , y compris des autres paquetages
static : méthode de classe
System.out.println : La méthode println écrit sur l’écran la

chaine de caractères passée en paramètres à cette méthode
GL_IGE_SMI
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
6- 3 Exemple d’utilisation d’objet
Il s’agit d’écrire une application en java qui permet de calculer le
salaire hebdomadaire d’un employé en fonction du taux horaire et du
nombre d’heures
public class Employe

{
String nom; // le nom de l'employé
static float taux_h=50; // le taux horaire en dirhams
int nb_h;
float salaireh () // nb_h : nombre d’heures

{ float s;
s=(taux_h*nb_h);
return s;
}
GL_IGE_SMI
public static void main(String[] arg)
{ float s1,s2; // les salaires de 2 employés
Employe emp1,emp2; // 2 objets modélisant 2 employés
emp1=new Employe();
emp2=new Employe();
emp1.nom= " Mohammed"; // le nom de l’employé 1
emp1.nb_h= 35; // le nombre d’heures de l’employé 1
emp2.nom="Nadia"; // le nom de l’employé 2
emp2.nb_h=38 ; // le nombre d’heures de l’employé 2
s1=emp1.salaireh();
s2=emp2.salaireh();
System.out.println("Le salaire de "+ emp1.nom+" est"+s1+" dh");
} // 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
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
Exemple d’utilisation de constructeur

{ 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*/
s1=emp1.salaireh();
s2=emp2.salaireh();
} // fin de main
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
7 – 2 La variable this
float salaireh ()
{ float s;
s=(taux_h*nb_h);
return s;
}
{ float s1,s2;
Employe_this emp1,emp2;
emp1=new Employe_this (" Mohammed");
emp2=new Employe_this ("Nadia");
s1=emp1.salaireh();
s2=emp2.salaireh();
} // fin de main
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
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
2– Types élémentaires en java

JAVA dispose des 8 types élémentaires suivants, ces types
sont appelés primitives en java :
boolean Destiné à une valeur logique (true, false)

byte Octet signé 8 bits (-128 et 127)
short Entier court signé 16 bits (-32768 – 32767)
char Caractère 16 bits
GL_IGE_SMI
2– Types élémentaires en java
int Entier signé 32 bits

float Virgule flottante 32 bits
double Double précision 64 bits
long Entier long 64 bits
GL_IGE_SMI
Java dispose également des classes suivantes pour gérer ces primitives :
Classe Primitive
______________________________
Character char
Byte byte
Short short
Integer int
Long long
Float float
Double double
Boolean boolean
GL_IGE_SMI
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 - 1 Déclaration
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
33-2 Identificateurs
A Chaque objet , classe, programme ou variable est associé un identificateur. Les
identificateurs Java sont formés d'un nombre quelconque de caractères. Ils doivent
respecter les règles suivantes :
- Les majuscules et les minuscules sont distinguées.
- Le premier caractère ne doit pas être un chiffre
- L’ identificateur ne doit pas être un mot clé de Java.
En plus des règles ci-dessus, il est conseillé de respecter les directives
suivantes :
_ - Evitez les caractères accentués dans les noms de classes.
- - Evitez de donner le même nom à des identificateurs d'éléments différents
GL_IGE_SMI
3-3 Mots clé de java
Les mots suivants sont les mots clé de java :
abstract assert boolean break byte

case catch char class continue
default do double else enum
extends false final finally float
for if implements import instanceof
int interface long native new
null package private protected public
return short static super switch
synchronized this throw throws transient
true try void volatile while
enum Jours{Lun, Mardi, Mer, Jeudi, Vend, Sam, Dim};

GL_IGE_SMI
3 - 4 Les attributs statiques
Ce sont les attributs qui ont le modificateur static. Un attribut

statique ( ou de classe) appartient à une classe et non à ses instances.
Il est indépendant des objets
- Un attribut statique existe dès que sa classe est chargée en
mémoire alors qu’un attribut d’instance existe lors de l’instanciation de
la classe
Pour utiliser un attribut ou une méthode statique, on écrit :
NomClasse.nomAttributStatique
Cependant JAVA permet également d’utiliser :
nomObjet.nomAttributStatique où nomObjet est une
instanciation de la classe qui contient l’attribut ou la méthode statique
GL_IGE_SMI
Exemple1 : attribut statique
class Statique
{
int nons;
static int s;
}
public class UtiliseStatic
{
public static void main (String[] arg)
{
Statique.s=10;
Statique obj1= new Statique();
obj1.nons=20;
Statique obj2= new Statique();
obj2.nons=30;
obj2.s=15;//Pour tous ,les objets s=15
System.out.println(Statique.s); //15
System.out.println(obj1.s); //15
System.out.println(obj1.nons); //20
System.out.println(obj2.nons); //30
}
}
GL_IGE_SMI
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
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
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
}
{ System.out.println("a2="+a2);
Initialiseur obj= new Initialiseur();
System.out.println("obj.a1="+obj.a1);
obj.m1();
}
}
GL_IGE_SMI
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
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
{
{
System.out.println ( ( new Constantes (2)).C ) ;
System.out.println (Constantes.D ) ;
}
}
On obtient à l’exécution :
2
100
GL_IGE_SMI
4- Les structures de contrôle
Les structures de contrôle de java sont similaires à celles de C
Les instructions conditionnelles
a – L’instruction if
if (expression)
InstructionSiVrai ;
else
InstructionSiFaux
b- L’opérateur ?
condition ? siVrai : siFaux
Exemple : int a, b ;
int min = a<b ? a : b
GL_IGE_SMI
c- L’instruction switch
switch (variable)
{ case cas1 : instruc11 ;
instruc12 ;
.
break ;
case cas2 : instruc21 ;
instruc22 ;
.
break ;
.
default : instrDefault ;
}
GL_IGE_SMI
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
abstract Prototype de méthode

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

ont le modificateur static et sont indépendantes des instances
- Une méthode statique ne peut pas être redéfinie. Elle est
automatiquement finale
Pour utiliser une méthode statique, on écrit :
NomClasse.nomMethodeStatique(arguments)
Cependant JAVA permet également d’utiliser :
nomObjet.nomMethodeStatique(arguments)
nomObjet étant une instanciation de la classe qui

contient l’attribut ou la méthode statique
GL_IGE_SMI
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
public class EssaiSurcharge
{
{
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
6 – Les tableaux 65
Les tableaux en java sont des structures pouvant contenir un nombre fixe d ’éléments de
même nature. Chaque élément est accessible grâce à un indice correspondant à sa position dans
le tableau.
6-1 Déclaration d ’un tableau
Les tableaux doivent être déclarés comme tous les objets. Java dispose de deux syntaxes
équivalentes pour la déclaration des tableaux,
type_elements[ ] tableau;
ou
type_elements tableau[ ] ;
Exemple : int[] tab1

int tab2[]
6-2 Création d’un tableau
Comme tout objet java un tableau doit être crée après sa déclaration. Les tableaux java sont
de taille fixe.La création doit indiquer leur taille. La syntaxe à utiliser est la suivante :
x = new type[ dimension];
dimension est le nombre d'éléments que le tableau pourra contenir.
GL_IGE_SMI
Exemple :
class TableauA
{ public static void main(String[] arg)
{
int[] tableau ;
tableau = new int[2];
tableau[0]=-5;
tableau[1]= 8
for(int i=0 ;i<2 ;i++)
System.out.println(tableau[i]);
}
}
Autre façon de définir un tableau : On peut définir un tableau avec un
tableau littéral au moment de sa déclaration.
Exemple: boolean tableau[ ] = {true,false,true}; int t[ ]={0, 5, 9, -45}

GL_IGE_SMI
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
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
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
- 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));
}
{ Chaine1 obj = new Chaine1();
obj.affiche_longueur();
obj.affiche_caractere(obj.ch3);
}
}
GL_IGE_SMI
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
- 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 capacité "+stb2.capacity()); //10
stb1=new StringBuffer("Chaine");
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
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
{
{
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
9– 3 L’objet null
L’objet null n’appartient pas à une classe, mais il peut être utilisé en lieu et place
d’un objet de toute classe,
public class Case
{ int val ;
Case (int val ) // Constructeur de la classe Case
{ this.val=val ; }
boolean estEgal (Case c)
/* Méthode estEgal avec un paramètre objet de type Case */
{ return val = = c.val ; }
}
public class DemoNull
{ public static void main (String[] arg)
{
Case c1 = new Case (10) ;
Case c2 = new Case (15) ;
Case c3 = null ;
System.out.println (‘‘ c1 = =c2 :’’+c1.estEgal(c2)) ;
System.out.println (‘‘ c1= =c3 :’’+ c1.estEgal(c3)) ;
System.out.println (‘‘c1= =null:’’+c1.estEgal(null));
}
}
/* Le programme se compile correctement, en revanche son exécution est interrompue
à la ligne c1.estEgal(c3) puisque c3 = null et on ne peut pas accéder à c3.val (dans la
méthode
GL_IGE_SMIestEgal ) */
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
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
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
-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)
{ 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
-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
1-4- Opérateurs : super et instanceof
class A
{ }
class B extends A
{ }
public class C
{ public static void main(String[] arg)
{ A a= new A();
B b = new B();
C c = new C();
System.out.println( a instanceof A ); // true
System.out.println( a instanceof B );//false
System.out.println( b instanceof A );//true
System.out.println( b instanceof B );//true
a=b;
System.out.println( a instanceof A );//true
System.out.println( a instanceof B );//true
//System.out.println( c instanceof A ); :erreur de compilation
//(c et A ne sont pas de même type)
} }
GL_IGE_SMI
1-5- Un exemple de l’héritage
Prenons la hiérarchie suivante :
Personne
Fonctionnaires Profession_liberale Eleve

Chomeur
….
Avocat Commerçant Primaire

MedecinPublic Enseigantt
Les classes Fonctionnaire, Profession_liberale, Eleve et

Chomeur sont dérivés de la classe Personne
GL_IGE_SMI
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
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)
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)
this.numeroEleve=numeroEleve;
this.classe=classe; }
}
public class Heritage

{
{ 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
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
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
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;
}
{ 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
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
Exemple 2 : Utilisation de la méthode toString() redéfinie
{ 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
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

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
Exemple 1 : Utilisation de la méthode equals héritée
{ 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
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
Exemple 2 : Utilisation de la méthode equals redéfinie
{ 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
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
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
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
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
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
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
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
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
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
Les liens dans une page HTML
Dans une page HTML , on peut définir des liens qui représentent
des sauts vers d’ autres endroits. Pour identifier la cible vers la quelle doit
pointer le lien., on utilise la balise a (ancre), cette balise a un attribut href
(hypertext reference) ; celui ci doit contenir une URL qui pointe sur un
document ou sur une partie du document
Il existe deux types de liens, des liens internes qui renvoient à un
emplacement situé dans le même document et des liens externes qui
appellent un autre document figurant dans le même ordinateur serveur ou
sur un autre géographiquement éloigné.
Lien interne : <a href= «#nom de l’ancrage» texte1 ou image1</a>

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

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

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
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
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
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
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
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
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
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
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
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
2 – LES PRINCIPALES CLASSES DE java.awt
2-1 La classe Graphics
La classe java.awt.Graphics comporte un nombre important de méthodes

permettant de tracer des formes géométriques vides ou pleines. Voici un échantillon
des méthodes de Graphics :
* drawLine(int x1,int y1,int x2 ,int y2) : affiche le segment de (x1,y1) à (x2,y2).
Remarque : Les segments tracés en java ont une largeur égale à un point d’écran. Pour
tracer un segment plus épais , on doit tracer plusieurs segments parallèles
Le système de coordonnées x et y dans une fenêtre graphique ou une applet est

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

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

{
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
GL_IGE_SMI
* 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

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

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
GL_IGE_SMI
* 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

* 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

{ couleur= Color.red;
g.setColor(couleur);
g.fillPolygon(xPoints,yPoints,points);
}
{ TracePoly monDessin = new TracePoly("Un triangle");
monDessin.setSize(400, 400);
monDessin.setVisible(true); }
}
GL_IGE_SMI
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
- 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
* 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
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
• 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); }
{ 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
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
* 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); }
{
Font ft= new Font("Serif",Font.BOLD,20);
g.setFont(ft);
g.setColor(Color.red);
g.drawString("ATTENTION DANGER",100,100);
}
GL_IGE_SMI
public static void main (String[] argv)

{ UtiliseFont monTexte= new UtiliseFont("Les Fonts");
monTexte.setSize(400,400);
monTexte.setVisible(true);
} // fin de main
GL_IGE_SMI
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

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
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
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

3-1 Les boutons
public void init ()

{
monBouton1 = 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
3-1 Les boutons
<! Fichier DemoBouton.htm>

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

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

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

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

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
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

public boolean action(Event e,Object arg)
{
if (test.getState())
etat=true;
else
etat=false;
repaint(); // force la méthode paint()
return (true);
}
{ 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

{
DemoCheckBox maCase = new DemoCheckBox("Case à cocher");
maCase.setSize(400, 400);
maCase.setVisible(true);
} // fin de main
A l’exécution, on aura
GL_IGE_SMI

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
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

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

{ 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

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

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

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

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

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

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

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
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

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

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

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);
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

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

(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


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

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

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

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

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

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éthod
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

Exemple d’utilisation de TextArea pour recueillir des commentaires
import java.awt.* ;
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

Exemple d’utilisation de TextArea pour recueillir des commentaires
import java.awt.* ;
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

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

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

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

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

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

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

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
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
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

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
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

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

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

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

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

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
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
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
Exemple : Utiliser dans une applet deux panneaux
import java.awt.* ;
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
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
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
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
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
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
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
GL_IGE_SMI
ComponentEvent Dialog ComponentListener ComponentMoved(ComponentEvent)

Frame ComponentHidden(ComponentEvent)
ComponentResized(ComponentEvent)
ComponentShown(ComponentEvent)
AdjustementEvent Scrollbar AdjustementListener AdjustementValueChanged

(AdjustementEvent)
MouseEvent Canvas MouseListener MousePressed(MouseEvent)
Dialog MouseAdapter MouseReleased(MouseEvent)
Frame
Panel
Window
KeyEvent Component KeyListener KeyPressed(KeyEvent)
KeyAdapter KeyReleased(KeyEvent)
KeyTyped(KeyEvent)
ContainerEvent Container ContainerListener ComponentAdded(ContainerEvent)
ComponentRemoved(ContainerEvent)
TextEvent TextComponent TextListener TextValueChanged(TextEvent)
GL_IGE_SMI
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.*;
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
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
Exemple :

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

* 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
* 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);
setLayout(fl);
add(text1);
addMouseListener(this);
}
GL_IGE_SMI

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

public void mousePressed(MouseEvent e)
{ text1.setText("La souris est enfoncée "); }
public void mouseReleased(MouseEvent e)
{text1.setText("La souris est relachée ");}
{Souris maSouris = new Souris("Gestion de la souris");
maSouris.setSize(300,300);
maSouris.setVisible(true);
}
}
GL_IGE_SMI

* 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

public class Touche extends Frame implements KeyListener

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

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

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)
{ }
{Touche maTouche = new Touche("Gestion du clavier");
maTouche.setSize(300,300);
maTouche.setVisible(true); } }
GL_IGE_SMI
-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
Exemple 1
public static void main(String args[])

{ JFrame f = new TestJFrame();
f.setBounds(200,200, 150, 100);
f.setVisible(true);
}
}
GL_IGE_SMI
Exemple2
import javax.swing.*;
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
Exemple2
public static void main(String args[])

{ JFrame frame = new SwingDemo("Swing Demo Window");
frame.setSize(400, 400);
frame.setVisible(true);
}
}
GL_IGE_SMI
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
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
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
{
{
int zero = 0 ;
zero = 2000 / zero ;
}
}
GL_IGE_SMI
LES EXCEPTIONS
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
LES EXCEPTIONS
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
{
{
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
LES EXCEPTIONS
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
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
LES EXCEPTIONS
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)
{
}
{
}
{
}
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
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
LES EXCEPTIONS
{
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

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
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
LES EXCEPTIONS
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
LES EXCEPTIONS
4-4 Bloc Finally
finally
{ System.out.println("donnée traitée :"+liste[i]); }
}
return somme/nbNotes;
}
{
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
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

Cours Java Smi Ige s5

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Java Smi Ige s5

Transféré par

Droits d'auteur :

Formats disponibles

Cours JAVA

Filières: SMI, IGE

Chapitre 1 GENERALITES SUR LE LANGAGE

Chapitre 2 OUTILS ELEMENTAIRES POUR LA

Chapitre 3 HERITAGE ET INTERFACES EN JAVA

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

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

1 - 1 Notion de classe et d’objet

Objet = Données + Traitements

objet est une instance d’une classe.

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

- JAVA est un langage de programmation orientée objets

- JAVA fonctionne comme une machine virtuelle

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

- JAVA autorise le multitâche (multithreading)-

- JAVA peut être utilisé sur INTERNET

- JAVA est gratuit

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

- Créer des interfaces graphiques

-Projet de recherche en 1991 chez Sun Microsystems

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

Des éditeurs de grande réputation ont rapidement conclu

3- 1 Java Developer’s Kit (JDK)

3-3 Editions de la plate-forme Java

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

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

4- 2 Utilisation des classes d’un paquetage

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

- importé par défaut.

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

- Javax.swing contient les classes pour les interfaces graphiques

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

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

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

Une classe définit des attributs et des

5 - 1 Architecture d'une classe JAVA

Une classe se compose de deux parties :

5 - 1 Architecture d'une classe JAVA

Entête d’une classe

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

Corps d’une classe

Type Convention Exemple

Nom d’une class Polygone

Nom d’un Débute par une minuscule premierObjet

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

Constante S’écrit en majuscules A_CONSTANT

static : méthode de classe

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

- 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

6 - 1 Déclaration d’un 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 :

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

public class Employe

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

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

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

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