1. Télécharger ce document sur http://www.krymo.com
JAVA
LES BASES DU LANGAGE

2. LES BASES DU LANGAGE
Sommaire
Principes généraux de la syntaxe
Identificateurs et mots clefs
Types primitifs
Types objet
Types tableaux
Allocation de types
Conventions de codage

3. LES BASES DU LANGAGE La syntaxe : principes
Qu’est ce que la syntaxe :
Principes généraux
Écriture des lignes de programme :
le point-virgule ;
les parenthèses ( )
les accolades { }
La virgule ,
Écrire de commentaires
Identificateurs :
de constantes
de variables, tableaux, …
de méthodes, de classes, …
Mots clés :
de variables, tableaux, …
de méthodes, de classes, …

4. LES BASES DU LANGAGE
lignes de programme
Écriture des lignes de programme :
le point-virgule : Une ligne de programme ;
Une autre ligne ;
Encore une ligne ;
les parenthèses :
if ( condition dans un test )
for ( champ1 ; champ2; champ3 )
Methode ( )
les accolades : { ………………………….
délimite un bloc d’instruction
} ………………………….
int ValeurSomme , Moyenne, Total ;
La virgule : Methode( Var1, Var2, Var3 )

5. LES BASES DU LANGAGE
Les commentaires
Rôle d’un commentaire :
Comment écrire une ligne de commentaire
// voici une ligne de commentaire
/* voici une autre ligne de commentaire */
Comment écrire des commentaires sur plusieurs lignes
/* voici une première ligne
une deuxième ligne
encore une ligne
la fin du commentaire */

6. LES BASES DU LANGAGE
Les identificateurs
Rôle d’un identificateur
Cas des constantes
MINIMA
TOTAL
TAUX
Cas des variables, tableaux, référence
VoiciUneVariable
UnTableau[ ]
UnAutreTableau[ ][ ]
Cas des méthodes
AfficherTexte ( )

7. LES BASES DU LANGAGE
Les mot-clés
Qu’est ce qu’un mot-clé
Exemple de mot-clé
int
Applet
float
Random
string
drawRectangle

8. Les types, variables, commentaires
Les types primitifs les variables
boolean : true et false Identificateur : nom donné à la variable
byte : 1 octet Type voir à gauche
char : 2 octets Déclaration : partout dans un bloc de programme
short : 2 octets Syntaxe de déclaration : type Identificateur ;
int : 4 octets Exemple :
long : 8 octets float Longueur;
float : 4 octets int Somme, Couleur;
double : 8 octets
Affectation Variable1 = expression ;
Conversion de type
Les commentaires exemple : Somme = (int)Longueur ;
// commentaire sur une ligne
/* commentaires sur
plusieurs lignes
*/

9. Les tableaux
Les tableaux
Identificateur : nom donné au tableau par l’utilisateur
Type ( idem variables )
Déclaration : partout dans un bloc de programme
Syntaxe de déclaration : type Identificateur [ ] ou type [ ] Identificateur ;
Exemple :
int [ ] TableauColonnesLignes;
int Tab1 [ ] , Tab2 [ ] [ ] ;
Affectation
int [ ] compte = { 1,2,4,78,9, …. };
TableauColonnesLignes = new int [20] ;
Utilisation
int Longueur = TableauColonnesLignes.length ;

10. LES BASES DU LANGAGE La syntaxe : Conventions
Convention d’écriture de programme
Les entêtes de programme
L’entête contient les informations // Entête du programme
d’identification ( titre, version, auteur,..)
, de description ( résumé succinct, …)
//……………
, de protection ( copyright, … ) // ……………
La place des bibliothèques import package.sousPackage. * ;
………………
Ici on place les importations de package et de classes
nécessaires à la compilation du programme :
classes d’un package ou méthodes d’une classe // Entête de classe
utilisées dans le programme
Class nomDeClasse1 {
Les entêtes de classe
}
// Entête de classe
la place des classes Class nomDeClasse3 {
}

11. LES BASES DU LANGAGE
Ma première application
On veut créer une application informatique la plus simple possible
en java qui vous permette d’afficher le message hello world sur
L’écran.
Cette application se composera d’une seule classe nommée MonAppli
Et d’une seule méthode nommée main ( … )
Représentation graphique de l’application
MonAppli
main ( )

12. LES BASES DU LANGAGE Ma première application
Application : Gestion de message
// -------------------------------------------------------------------------------------------------------
// Application Hello World
// -------------------------------------------------------------------------------------------------------
// Version 1.0 : réalisé par A. Blanc le : 10 / 11 / 2004
//---------------------------------------------------------------
// Application informatique permettant d’afficher le message hello world sur l’écran
//-------------------------------------------------------------------------------------------------------
// copywright interdit
//-------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------
// importation des bibliothèques
import java.lang.* ;
// -------------------------------------------------------------------------------------------------------
// Classe de gestion de message
// -------------------------------------------------------------------------------------------------------
public class MonAppli {
// méthode principale de l’application
public static void main( String Arguments[ ]) {
system.Out.println ( "Hello World " );
}
}

13. LES BASES DU LANGAGE
Modification : Intégration d’une variable
On veut modifier l’application précédentepour pouvoir afficher le
même message. La différence consiste à déclarer une variable de type
String qui contiendra la chaîne de caractère hello world.
On utilisera une variable Message qui sera déclarée et initialisée
dans la méthode principale.

14. LES BASES DU LANGAGE Modif : variable
Application : Gestion de message avec intégration d’une variable
// -------------------------------------------------------------------------------------------------------
// Application Hello World
// -------------------------------------------------------------------------------------------------------
// Version 1.1 : réalisé par A. Blanc le : 10 / 11 / 2004
//---------------------------------------------------------------
// Application informatique permettant d’afficher le message hello world sur l’écran
//-------------------------------------------------------------------------------------------------------
// copywright interdit
//-------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------
// importation des bibliothèques
import java.lang.* ;
// -------------------------------------------------------------------------------------------------------
// Classe de gestion de message
// -------------------------------------------------------------------------------------------------------
public class MonAppli {
// méthode principale de l’application
public static void main( String Arguments[ ]) {
String Message = "Hello World ";
system.Out.println ( Message );
}
}

15. LES BASES DU LANGAGE
Modif : création d’une instance
On veut créer une application informatique en java qui vous permette d’afficher le message
hello world sur l’écran.
Cette application se composera de 2 classes l’une nommée MonAppli, l’autre nommée
GestionMessage.
La méthode Afficher permet l’affichage du message dans la fenêtre DOS en utilisant
system.Out.println ( "Hello World " );
Représentation graphique de l’application
GestionMessage
Afficher ( )
MonAppli
main ( )

16. LES BASES DU LANGAGE Modif : Instance
Application : Gestion de message avec création d’une instance
// -------------------------------------------------------------------------------------------------------
// Classe principale de l’application
// -------------------------------------------------------------------------------------------------------
class TriBulle {
public void GestionTri () {
Tri();
Afficher();
}
private void Tri(){
}
// -------------------------------------------------------------------------------------------------------
// private void Afficher(){
Classe principale de l’application
// -------------------------------------------------------------------------------------------------------
public class MonAppli {
}
} // méthode principale de l’application
public static void main( String Arguments[ ]) {
GestionMessage ref;
ref = new GestionMessage ( ) ;
ref . Afficher ( );
}
}

17. class TriBulle {
int Tab[]={2,4,1, };
public void GestionTri () {
System.out.println ( "Inst je suis dans gestion tri" );
Tri();
Afficher();
}
private void Tri(){
System.out.println (" Inst je suis dans tri" );
}
private void Afficher(){
System.out.println (" Inst je suis dans afficher" );
}
}
public class MonAppli 04{
public static void main( String Arguments[ ]) {
TriBulle ref = new TriBulle ( ) ;
System.out.println (" PP j’appelle Gestion tri" );
ref . GestionTri ( );
System.out.println (" PP fin du programme" );
}
}

18. POUR i …….. for (int i=0;i<12;++i) {
FINi }
SI ( condition) if ( Table[i]> Table[i+1]){
FSI }

19. Instance / référence et syntaxe
Place son adresse dans une reference
Voiture Reference = new Voiture ;
type Crée une instance
De voiture
La reference
Sur l’objet
Est de

20. LES BASES DU LANGAGE
Modif : création de 2 instances
On veut créer une application informatique en java qui vous permette d’afficher le message
hello world sur l’écran.
Cette application se composera de 2 classes l’une nommée MonAppli, l’autre nommée
GestionMessage.
La méthode Afficher permet l’affichage du message dans la fenêtre DOS en utilisant
system.Out.println ( "Hello World " );
Représentation graphique de l’application
GestionMessage
Afficher ( )
MonAppli
main ( )

21. LES BASES DU LANGAGE
Modif : 2 instances
Application : Gestion de message avec création de 2 instances
// -------------------------------------------------------------------------------------------------------
// Classe principale de l’application
// -------------------------------------------------------------------------------------------------------
class GestionMessage {
// méthode principale de l’application
public void Afficher () {
system.Out.println ( "Hello World " );
}
}
// -------------------------------------------------------------------------------------------------------
// Classe principale de l’application
// -------------------------------------------------------------------------------------------------------
public class MonAppli {
// méthode principale de l’application
public static void main( String Arguments[ ]) {
GestionMessage refObjet1, refObjet2;
refObjet1 = new GestionMessage ( ) ;
refObjet2 = new GestionMessage ( ) ;
……………….. ;
}
}

22. LES BASES DU LANGAGE
Mon Premier Applet
Applet : Gestion de message
// -------------------------------------------------------------------------------------------------------
// Applet Hello World
// -------------------------------------------------------------------------------------------------------
// Version 1.0 : réalisé par A. Blanc le : 10 / 11 / 2004
//---------------------------------------------------------------
// applet permettant d’afficher le message hello world sur l’écran dans la fenêtre dos
//-------------------------------------------------------------------------------------------------------
// copywright interdit
//-------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------
// importation des bibliothèques
import java.applet.* ;
import java.awt.*;
// -------------------------------------------------------------------------------------------------------
// Classe de gestion de message
// -------------------------------------------------------------------------------------------------------
class GestionDeMessage extend Applet {
// méthode principale de l’application
public void paint( Graphics ref) {
ref . drawString( ( "Hello World « ,10,25 );
}
}

23. LES BASES DU LANGAGE Un autre exemple d’applet
// --------------------------------------------------------------------
// importation des bibliothèques
//---------------------------------------------------------------------
import java.applet.*;
import java.awt.*;
// --------------------------------------------------------------------
// classe MonApplet : hérite de Applet
//---------------------------------------------------------------------
public class MonApplet extends Applet{
int XMessage,YMessage;
String Message;
// méthode d’initialisation de l’applet
public void init(){
Message="* mon premier applet *";
XMessage=10;
YMessage=10;
}
// méthode d’affichage
public void paint(Graphics g){
g.setColor(Color.black);
g.drawString(Message,XMessage,YMessage);
}
}

24. Les itérations et les tests
Les tests :
if (condition ) { inst1; inst2; inst3; }
if ( condition ) { ……} else {….}
if ( condition ) { ……} else if {….} else {….}
La sélection
switch ( valeur ) {
case 1 : …..;
case 2 : …..; break;
case 3 : ……;
default : ……;
Les itérations
for (int i=0;i<12;++i) {
inst1;
inst2;
}
La boucle while ( condition ) { ….; …..; …..}
La boucle do { inst1; inst2; …} while (condition);

25. Application : calcul d’une moyenne
On veut écrire une application permettant de saisir des valeurs entières au clavier et les mémoriser
dans un tableau nommé NotesEtudiant [ 24 ] puis de calculer la moyenne et de l’afficher.
On utilisera un objet Moyenne composé des méthodes privées:
SaisirNotes ( )
CalculerMoyenne( )
AfficherMoyenne( )
La méthode GestionCalcul( ) est une méthode publique qui permet de réaliser les appels des méthodes
SaisirMoyenne( ), CalculerMoyenne( ), AfficherMoyenne( )
L’objet MonAppli permettra de créer une instance de l’objet Moyenne et d’appeler la méthode GestionCalcul( )
On donne la représentation graphique du diagramme
des classes de l’application. Moyenne
On demande en utilisant les algorithmes vus en cours
de construire les classes MonAppli et Moyenne NbreNotes
NotesEtudiant[ ]
Moyenne
MonAppli
AfficherMoyenne ( )
CalculerMoyenne( )
SaisirNotes( )
main ( ) GestionCalcul ( )

26. Les packages
Les packages java
C’est le regroupement des classes utilisées dans le langage java
A un package correspond un domaine particulier ( awt : graphique , Math , …. )
import NomDePackage . * ; // on importe toutes les classes du package
import NomDePackage . NomDeClasse ; // on importe la classe

27. Classes, Objets, Instance
Instance : Objet réel ( une voiture bleue, numéro 1258 SF 28 , ….)
Objet : Objet abstrait ( les voitures en général )
Classe : modélisation de l’objet abstrait dans le domaine d’étude
Une instance Un objet Une classe
Voiture Voiture Voiture
Attributs
Couleur : bleue
Couleur
Numéro 1258SF28 numéro
Démarre Méthodes
Démarrer( )
class Voiture {
L’instanciation int Couleur;
new Voiture ; String Numéro;
L’instanciation et la référence public void Démarrer() {
Voiture Reference = new Voiture ; ………
}
}
Permet de manipuler

28. Classes / méthodes / attributs
class Voiture {
Déclaration des attributs
de la classe
encapsulation
Définition d’une méthode
Définition d’une autre méthode
}

29. Accès et visibilité
class Video {
public int NbreVideo ; Accès privé
private int TailleVideo ;
Accès public public void SelectionVideo (int ){
TailleVideo
this.TailleVideo = TailleVideo ;
AfficheNomVideo();
}
private void AfficheNomVideo ( ) {
Accès privé
}
}

30. Portée des variables, tableau, références, méthodes
class ………… {
Déclarées dans la classe :
accessibles depuis n’importe quelle méthodes de la classe
Déclarées en public :
accessibles en plus depuis n’importe quel autre objet
Déclarées en private :
inaccessibles depuis un autre objet
on encapsule les données et les méthodes
public ou private type Méthode ( int TailleVideo ) {
Déclarées dans la méthode :
Accessibles que de la méthode
}
}

31. Variables et méthodes statiques
Les variables et méthodes static sont communes à l’ensemble
des instances de la classe. Il est donc inutile d’instancier une
classe pour accéder à ses membres static
Exemple :
public static void main ( …) {
}

32. constructeurs
Il s’agit d’une méthode portant
Le même nom que la classe
class Voiture {
public Voiture ( ) {
}
}
class AutreClasse {
A l’instanciation on appelle ( exécute )
Implicitement le constructeur
new Voiture ( ) ;
}

33. Constructeurs et passage de paramètres
class Voiture {
String NomMarque;
public void Voiture (String Marque ) {
this.NomMarque = Marque ;
}
}
class AutreClasse {
new Voiture ( Marque) ;
}

34. Caractéristiques des constructeurs
Un constructeur est toujours public : public nomDeLaClasse ( ) { … }
Il ne retourne rien
Il peut y avoir plusieurs constructeurs dans une classe . On les distingue alors par
leur signature.
ex :
public Voiture () { ……….}
public Voiture ( int a) {…………}
public Voiture ( String n, int a) {…….}
public Voiture (int a , String n) {…….}

35. Héritage
class Vehicule {
Vehicule protected int marque;
marque
protected void Rouler ( ) { …….}
Rouler ( ) }
Hérite de
class Voiture extends Vehicule {
Voiture Le mot clé super () :
appelle le constructeur
super ( )
de la classe de base Rouler ( );
}
class AutreObjet {
Le constructeur
de la classe dérivée est
appelé à l’instanciation
new Voiture () ;
}

36. Les interfaces et classes abstraites
Il s’agit d’une classe ayant au moins une méthode abstraite mot clé abstract
Une classe abstraite ne possède pas de définition de méthode
L’instanciation est impossible par l’opérateur new
Une classe dérivée doit redéfinir l’ensemble des méthodes abstraites
exemple : Dans l’interface mouseListener
Les méthodes mousePressed(), mouseClicked(), ….
doivent toutes être redéfinies

37. interface
Une interface comporte uniquement des méthodes abstraites
Une interface n’est pas une classe
Une interface ne possède pas de constructeur
Une interface s’utilise comme un type
Le mot clé implements permet à une classe d’implémenter une interface
Une classe peut implémenter ( implements ) plusieurs interfaces et également hériter
d’une classe
ex : class Bouton implements Runnable, Serialisable extends Applet
Une interface peut hériter ( extends ) de plusieurs interfaces

38. Combinaison d’interfaces
public interface Dessinable{ Object
public void Dessine () ;
}
Dessinable déplaçable
public class Point implement Dessinable{
public void Dessine () {
Papier peint point
}
public void AutreMethodes () {
}
}

39. Extension d’interface
public interface Dessinable{ Object
public void Dessine () ;
}
Dessinable déplaçable
public interface DessinableDeplaçable extends Deplaçable,Dessinable {
}
Papier peint Dessinabledéplaçable
public class Point implement DessinableDeplaçable{
point
}

40. Le package AWT
// construction d’une frame et d’un bouton
import java.awt.*;
public class EssaiFrame {
public static void main(String argv[]) {
Frame f = new Frame("Fenetre"); //construit une fenêtre invisible
Button b = new Button("Push me"); //construit un bouton
f.add(b); // place le bouton dans la frame
f.pack(); // On ajuste la frame compactage
f.show(); // On la rend visible
}
}

41. // construction d’une frame et d’une boite de dialogue
import java.awt.*;
public class EssaiDialogue {
public static void createDialog(Frame f) {
Dialog Dial = new Dialog(f,"boite de dialog",true);
// création d’une instance de type
// dialog liée à une référence
Dial.setLayout(new BorderLayout());// choix de la stratégie de placement
Dial.add(new Label("Voulez vous sortir"),"North");// création d’une étiquette
Dial.add(new Button("OUI"),"West");// ajout d’un premier bouton
Dial.add(new Button("NON"),"East");// ajout d’un deuxième bouton
Dial.pack(); Dial.show(); // on compacte et on rend visible
}
public static void main(String argv[]) {
// création d’une instance de type Frame liée à une référence
Frame fenetre = new Frame("Fenetre");
Button Bouton = new Button("APPUYER");// création d’une instance de bouton
//lié à une référence bout
fenetre.add(Bouton); // On place le bouton dans la frame
fenetre.pack(); // On compacte la taille de la frame
createDialog(fenetre); // création de la boite de dialogue
// dans la fenetre
fenetre.show(); // ici on l'affiche
}
}

42. Les applets

43. Les événements
Qu’est ce qu’un événement
L’objet événement :
Gestion de l’événement : classe écouteur
Le rôle de la méthode add… listener ( )
Le modèle de la classe écouteur
Les classes d’événements
Les interfaces listener et classes écouteur
La marche à suivre

44. Qu’est ce qu’un événement
Événement :
Information externe ou interne permettant
d’influer sur le déroulement de l’application
Application
Événement interne
Ouverture ou fermeture
de frame
Événement externe :
Clic de souris
Appui sur le clavier
Appui sur un bouton
……………………

45. Présentation du déroulement
Phase 1 : On provoque l’événement
Objet
de l’interface
Clic de souris
Phase 2 : Analyse de l’événement
Objet
de l’interface
Clic de souris Signal
reconnu
Phase 3 : Association de l’événement
à un objet événement EventObject
Objet Objet
de l’interface événement
Clic de souris Signal
reconnu

46. Présentation du déroulement
Phase 4 : l’objet source délègue la gestion
Traite l’événement
Objet Ecouteur
de l’interface
Clic de souris
Délègue la gestion
Fournit l’événement
Phase 5 : On associe l’objet source à l’objet écouteur
Objet
Ecouteur
de l’interface
Clic de souris Objet source associé à écouteur
Méthode add…Listener( )

47. Classes, classification, packages
Classes d’événements
On doit bien choisir le type d’événement à traiter.
Les types d’événement les plus courants sont :
Un clic sur un bouton type Button
Un clic sur une zone de type Panel, événement MouseEvent
La frappe d’une touche du clavier de type KeyEvent
Le changement de position du curseur type FocusEvent
Les ouvertures / fermetures des objets de fenêtrage type WindowEvent
Classification des événements
Événements de haut niveau
Événements de bas niveau
Le package gérant les événements : java.awt.event

48. Les interfaces
Interface listener et classe Ecouteur
Toutes les classes écouteur hérite d’une interface java
prédéfinie
Classes d’événement Interface java
ActionEvent ActionListener
MouseEvent MouseListener
KeyEvent KeyListener
FocusEvent FocusListener
WindowEvent WindowListener
Association de l’objet source et de l’objet écouteur
Syntaxe : ObjetSource.add Type_Evt Listener ObjetEcouteur
ObjetSource : désigne l’objet qui émet l’événement
Type_Evt : désigne de façon abrégée le type d’événement
Il est accolé à add et à Listener et forme un mot
qui désigne une méthode
ex: addActionListener, addWindowListener
ObjetEcouteur : désigne la référence à l’objet écouteur

49. Démarche à suivre
o Choisir le type d’événement à prendre en compte
clic sur bouton implique ActionEvent
o Définir une classe écouteur qui implémente l’interface
si ActionEvent l’interface prédéfinie est ActionListener
la méthode prédéfinie est actionPerform(e)
o Associer l’objet source et l’objet instance de la classe écouteur
Si Btn1 est le bouton source et ObjEcout l’objet écouteur
l’appel se présente sous la forme :
Btn1.addActionListener ( ObjEcout )

50. Exemple d’application à compléter
Champ de saisie
Saisie d’une chaîne
Label
AFFICHER QUITTER
Frame
Button
On veut créer une application permettant d’afficher l’interface graphique ci dessus.
A partir de cette interface, on doit pouvoir saisir du texte dans un champ de saisie
L’appui sur le bouton AFFICHER permet d’afficher la chaîne saisie
L’appui sur le bouton QUITTER permet de sortir de l’application
Construction de l’application :
Ecrire l’objet AppliFrame permettant de créer cet interface graphique
Réaliser la gestion des événements des 2 boutons en utilisant les informations précédentes
Ecrire le programme principal permettant de créer un instance de l’objet AppliFrame
et de l’appeler

51. Exemple de programmation
Class fenetre extends Frame {
Button BtnCalcul = new Button( QUITTER );
………………………………..
Delegue1 D1 = new Delegue1(this);
BtnCalcul .addActionListener ( d1 );
}
// Objet ecouteur
Class Delegue1 implements ActionListener {
// méthode de gestion d’événement
public Delegue1 ( fenetre f) {
}
public void actionPerformed (ActionEvent(e) {
System.out.println( « fin par appui sur quitter « );
System.exit(0); // demande de sortie du programme
}
}

52. Import java.awt.*;
Import java.awt.event.*;
exemple
class fenetre extends Frame {
private TextField Champ1;
public fenetre () {
Frame Ref = new Frame ( « evenement sur bouton »);
Ref.setLayout ( new FlowLayout());
Button BtnQuit = new Button (« Quitter »);
Champ1 = new TextField (20);
Ref.add ( BtnQuit);
Ref.add ( Champ1);
ObjetEcouteurB RefEcout = new ObjetEcouteurB ( );
ObjetEcouteurTexte RefTexte = new ObjetEcouteurTexte (Champ1);
BtnQuit.addActionListener(RefEcout);
Champ1.addActionListener(RefTexte);
Ref.show();
}
}
class ObjetEcouteurTexte implements ActionListener {
TextField Champ1;
public ObjetEcouteurTexte (TextField Ch1) {
Champ1= Ch1;
}
public void actionPerformed (ActionEvent e ) {
Champ1.getText();
}
}

53. Import java.awt.*;
Import java.awt.event.*;
Exemple
class fenetre extends Frame {
public fenetre () {
}
}lass ObjetEcouteurB implements ActionListener {
c
public ObjetEcouteurB() {
}²
public void actionPerformed (ActionEvent e ) {
System.out.println(« quitter »);
System.exit(0);
}
class ObjetEcouteurTexte implements ActionListener {
} private TextField Champ1;
public ObjetEcouteurTexte (TextField Ch1) {
Champ1= Ch1;
}
public void actionPerformed (ActionEvent e ) {
Champ1.getText();
public class Debut {
}
public static void main ( String Args[] ){
}
fenetre Ref = new fenetre();
}}

54. La classe principale
// gestion des événements de souris et de bouton
import java.awt.*;
import java.awt.event.*;
public class MonAppli{
public int i=0;
public static void main(String argv[]){
Frame f= new Frame();
Button b=new Button("partir");
TextField Champ = new TextField(3);
f.setLayout(new FlowLayout());
f.add(b);
f.add(Champ);
btn bouton= new btn();
b.addActionListener(bouton);
clic clic=new clic();
f.addMouseListener(clic);
f.setSize(800,600);
f.show();
}
}

55. class clic implements MouseListener {
public int i=0;
public void mouseClicked(MouseEvent e){
}
Gestion des evt de la souris
public void mousePressed(MouseEvent e){
i=i+1;
System.out.println(i);
}
public void mouseReleased(MouseEvent e){
}
public void mouseExited(MouseEvent e){
}
public void mouseEntered(MouseEvent e){
}
}
Gestion des evt du bouton
class btn implements ActionListener {
public void actionPerformed(ActionEvent e){
System.exit(0);
}
}

56. Les Threads
Qu’est ce qu’un thread
Un thread est généralement appelé processus léger. Il possède un compteur ordinal, une zone de pile et
chaque thread partage
avec les autres l’espace d’adressage, un zone commune de données, l’environnement de variables.
Cette organisation lui permet de communiquer facilement avec les autres threads de l’application ou de
l’applet.
Cycle de vie d’un thread
Un thread comme un processus possède un cycle de vie bien définit. Il est d’abord inexistant, pour exister il
doit être crée,
pour vivre être activé. Lors de son déroulement il peut s’interrompre, être mise en attente d’un
événement ,
d’une demande de réactivation.

57. Les threads
Non Crée
new MonThread ( )
Crée
start( )
Activé
yield( )
notify()
En En
exécution Attente
Les états d’un thread Bloquée sur entrée sortie
Mise en attente wait()
On endort le processus Thread.sleep(30)
L’ordonnanceur de thread
C’est le chef d’orchestre de l’application. C’est lui qui contrôle
l’activation des processus et les mises en attente en fonction des
priorités attribuées aux différents Thread
Les priorités des processus

58. Les Threads
o La classe Thread
Cette classe permet de créer des processus et de contrôler leur déroulement
Plusieurs constructeurs sont disponibles les méthodes start( ), run(), stop() assurent ce contrôle
La classe Thread définit sept constructeurs associant les paramètres Runnable, String,
ThreadGroup
• Un objet Runnable dont la méthode run() s’exécutera à l’intérieur du thread.
• Un objet String pour identifier le thread.
• Un objet ThreadGroup auquel attribuer le thread. La classe ThreadGroup organise les
groupes de threads liés entre eux.
La création d’un processus consiste à créer une instance de Thread et une référence sur
l’instance.
A la création le constructeur de Thread appelle la méthode start() ce qui à pour effet d’activer
le Thread. La méthode start() lance ensuite la méthode run() pour l’exécution.
La méthode stop( ) a pour effet de l’arrêter
Les méthodes de la classe static void yield();
final boolean isAlive();
final void setName(String Nom);
final String getName();
public void run();

59. Une première Classe
Thread
solution
Classe
Ceci est une classe threadée
EnVoiciUneDeThread
Dérivée de thread
// la classe assurant la gestion du processus ( thread )
class EnVoiciUneDeThread extends Thread {
public EnVoiciUneDeThread(String str) {
super(str);
}
public void run() {
for (int i=0; i<10; i++) {
System.out.println(i+" "+getName());
try {
sleep((int)(Math.random()*10));
}
catch (InterruptedException e){
}
}
Classe System.out.println(getName()+" est finie");
MesDeuxThreads }
}
// La classe principale
class MesDeuxThreads {
public static void main(String args[ ]) {
// création d’une instance de thread
EnVoiciUneDeThread RefThread1 = new EnVoicUneDeThread("la thread 1");
//lancement de l’exécution du thread
RefThread1.start();
// création d’un autre instance de thread
EnVoiciUneDeThread RefThread2 = new EnVoicUneDeThread("la thread 1");
//lancement de l’exécution du thread
RefThread1.start();
}
}

60. Interface Runnable
Une deuxième
solution
Classe // la classe assurant la gestion du processus ( thread )
EnVoiciUneDeThread
class EnVoiciUneDeThread implements Runnable {
public EnVoiciUneDeThread(String str) {
super(str);
}
public void run() {
for (int i=0; i<10; i++) {
System.out.println(i+" "+getName());
try {
sleep((int)(Math.random()*10));
}
catch (InterruptedException e){
}
}
System.out.println(getName()+" est finie");
}
}
Classe
MesDeuxThreads
// La classe principale
class MesDeuxThreads {
public static void main(String args[ ]) {
// création d’une instance de thread
EnVoiciUneDeThread RefThread1 = new EnVoicUneDeThread("la thread 1");
//lancement de l’exécution du thread
RefThread1.start();
// création d’un autre instance de thread
EnVoiciUneDeThread RefThread2 = new EnVoicUneDeThread("la thread 1");
//lancement de l’exécution du thread
RefThread1.start();
}
}

61. import java.awt.*;
Une solution applet
import java.util.*;
import java.applet.*;
import java.lang.*;
public class TestAppletThread extends Applet implements Runnable{
private int VarAffiche;
Thread Process1;
public void init( ) {
setBackground(Color.yellow);
}
public void start ( ) {
Process1= new Thread(this);
Process1.start();
}
public void stop ( ) {
}
public void destroy ( ) {
}
public void run() {
// ici on se trouve dans le processus
for (int i=0; i<100; i++) {
// ici aussi on se trouve dans le processus
VarAffiche=1;
try {
// ici on endort le processus
// on attend sur la ligne Thread.sleep
VarAffiche=2;
Thread.sleep(1000);
VarAffiche=3;
// à la fin du délai on sort de la ligne Thread.sleep
// le processus se réveille
}
catch (InterruptedException e){
}
repaint();
}
}