EC923-Programmation Objet

_______________________
UFR S&T, ,40 Rue du Pelvoux F-91020 Evry Cedex Tl :+33-1-69 47 75 15

Fax :+33-1-69 47 75 99
Universit d'Evry-Val d'Essonne - UFR Sciences & Technologies/Dpt de Gnie Informatique/Master 1 E3A
Enseignement : II74 GEII & GSI & RVSI- POO & IHM - Programmation orient objet (JAVA)
Objectif : Ce module se situe dans la continuit des modules GI62 et GI63 et permet de perfectionner les connaissances de la modlisation et
de la programmation orientes objet. Les notions de base de cration dinterface homme-machine graphique seront galement abords.
Le langage JAVA est pris comme exemple.
Avertissement : Ce cours suppose la connaissance et la matrise du langage C++
CONTENU DU COURS
HISTORIQUE ........................................................................................................................................................................................................................................................... 2
1.INRODUCTION ..................................................................................................................................................................................................................................................... 4
2.SPECIFICITES DE JAVA .................................................................................................................................................................................................................................. 10
3.CLASSES ET OBJETS ........................................................................................................................................................................................................................................ 16
4. INTERFACES ..................................................................................................................................................................................................................................................... 33
5. PAQUETAGE ...................................................................................................................................................................................................................................................... 36
6. HERITAGE ET POLYMORPHISME ............................................................................................................................................................................................................. 37
8. THREADS ............................................................................................................................................................................................................................................................ 58
9. PROGRAMMATION GRAPHIQUE ............................................................................................................................................................................................................... 66
10.APPLET .............................................................................................................................................................................................................................................................. 85
11. LES FLUX (STREAMS) ................................................................................................................................................................................................................................... 93
12 LES COLLECTIONS ...................................................................................................................................................................................................................................... 100
13. ENONCES DES TPS ....................................................................................................................................................................................................................................... 104
1 http://lsc.univ-evry.fr/~mallem
HISTORIQUE
1990-1992, projet Oak
Joy, Gosling (Sun)
Langage de programmation pour systmes embarqus:TV interactive,PDA,
But: avoir une plateforme commune.
Projet abandonn en 1992
1996, Java(Sun Microsystems Joy et Gosling) -
Projet Oak appliqu WWW.

Java, combin avec un browser spcial Hotjava, apporte le concept dapplet.
Avec le dveloppement du web, Java est n.
LIENS WEB
http://java.sun.com/docs/books/jls/
http://java.sun.com/reference/docs/index.html
HISTORIQUE (Suite)
Java combine les caractristiques des langages :

- Smalltalk(Xerox: Palo Alto (Californie) :Langage dobjets communiquant
par messages) (1980),
- ADA ( Dfense amricaine : Langage mutitaches) (1979),
- C++ (Bell Lab : Langage pseudo objet ) (1992).
En Smalltalk :
1 programme = objets +messages
En JAVA :
1 programme = objets + interfaces
1.INRODUCTION
1.1 Objectif de Java
public class Pgme{
public static void main(...)...}
Compilation
javac Pgme.java
-
Code intermdiaire (Byte code) Pgme.class
Interprtation local ou distant
Sun HP PC
java Pgme.class
ou par l'intermdiare 4 http://lsc.univ-evry.fr/~mallem
d'un navigateur web
1.2 Machine Virtuelle Java

Rle :
Interprte le byte code en langage machine de la cible: - interprtation
- supervise lexcution des classes,
- gre les classes et les mthodes communes (constr. Init, classe
Object, ),
- gre la pile d'excution et la mmoire(lance le ramasse miettes
garant d'une meilleure stabilit des applications),
- interprte le code intermdiaire.
Constitution :
Types de donnes
Les registres
Jeu dinstructions
1.3 Caractristiques de Java
Simple
syntaxe du langage "C"
sr
pas de pointeurs, vrification de lintgrit du code l excution et des accs rseau et/ou
fichiers,cryptage des donnes vhicules sur le rseau
Orient Objet
Compltement orient objet(fichier,type primitif, chaine de caractres, exception, thread,) , pas
de variables ni de fonctions globales.
Robuste
ramasse miettes, fortement typ, gestion des exceptions,
Indpendant d une architecture
Portabilit assure par la prsence d un interprteur de bytecode sur chaque machine cible.
Environnement riche
Classes pour l accs Internet
classes standard compltes
fonctions graphiques volues
Applications interactives et rseaux
(alphanumrique ou graphique)
Stand alone : executable en local
applet : executable en local /rseau dans un navigateur Web
Programme Minimal
Exemple 1.1 : pgme minimal ss java faisant appel une mthode de
sortie(printl)de l'objet (out) de la classe System :
public class PgmeMinimal // (1)
{ public static void main (String[] args) // (2)
{ System.out.println ("Universite d'Evry, UFR Sciences et Technologies, cours de
java") ; // (3)
}}
(1) : PgmeMinimal : classe thorique limite la dfinition de la mthode main ;
public utilis par la MV(Machine Virtuelle) de java pour accder la classe.
(2) : static : main n'est pas associe un objet (instance de la classe)
String[] args : tableau d'objets de type String quivalent argv du C/C++
public utilis par la MV(Machine Virtuelle) de java pour accder la mthode
main.
(3) : System : la classe
out : champ reprsentant la fentre d'affichage,
println : mthode d'affichage avec saut de ligne non attach un objet.
Mise en uvre
Compilation :
[mallem@gsc18 ]$ /usr/java/j2sdk1.4.1_03/bin/javac PgmeMinimal.java
Le Programme doit avoir le mme nom que la classe thorique
La compilation produit un code intermdiaire("bytecode"), nomm PgmeMinimal.class
Execution :
[mallem@gsc18 ]$ /usr/java/j2sdk1.4.1_03/bin/java PgmeMinimal
Universite d'Evry, UFR Sciences et Technologies, cours de java
Lancement de la MV de java (Interprtation/execution)
Remarque :
Une application Java peut tre excute sur une plate-forme quelconque condition que celle-ci
dispose d'une Java Virtual Machine(JVM) prsente dans :
un environnement de dveloppement, par exemple le Java Development Kit (JDK),
un environnement d'excution comme le Java Runtime Environment (JRE) - (voir les produits
de Sun),
un navigateur Web capable java d'excuter des applet Java.
Exemple 1.2 : Calcul trigonometrique - Utilisation des classes Clavier(Utilisateur) et System (java)
// La classe Calcul utilise la classe Clavier
public class Calcul
{ public static void main (String[] args)
{ int i ;
double angle,angledeg;
double sinus,cosinus ;
{ System.out.print ("Donnez un angle en degres : ") ;
angledeg = Clavier.lireDouble () ; angle=angledeg*3.14/180.;
System.out.print ("Cosinus (0) ou Sinus (1)? ") ;
choix = Clavier.lireInt () ;
if (choix==0)
{ cosinus = Math.cos(angle) ; System.out.println (angledeg + " a pour cosinus : " + cosinus) ;}
else {
sinus = Math.sin(angle) ; System.out.println (angledeg + " a pour sinus : " + sinus) ;}
}}}
/* rsultat d'excution
[mallem@gsc18 02]$ /usr/java/j2sdk1.4.1_03/bin/java Calcul
Donnez un angle en degrs : 90
Cosinus(0) et Sinus(1)? 0
90.0 a pour cosinus : 0
Donnez un angle en degrs : 0
Cosinus(0) et Sinus(1)? 1
0 a pour sinus : 0*/
2.SPECIFICITES DE JAVA
2.1 Introduction
pas de structures et d'unions,
pas de define
pas de pointeurs
pas d'hritage multiple bien que Java permet une classe d'implmenter plus d'une
interface.
pas de surcharge d'oprateurs
Les oprateurs du langage Java sont quasi identiques ceux du langage C.
Java peut tre considr comme un C++ allg de sa complexit formelle.
2.2 Mots cls

abstract boolean break byte case
catch char class const continue
default do double else extends
final finally float for goto
if implements import instanceof int
interface long native new package
private protected public return short
static super switch synchronised this
throw throws transient try void
volatile while
En souligns les nouveauts par rapport au C++
2.3 Types de base
entier
signs seulement
type byte ( 8 bits), short ( 16 bits), int ( 32 bits), long ( 64 bits)
flottant
standard IEEE 754
type float( 32 bits), double (64bits)
boolen
type boolean (true,false)
caractre
unicode,
type char (16 bits)
Conversion implicite :
Byte short int long float double
Char short int long float double
2.4 Oprateurs
Priorit Oprateur(s) Associativit

Max () [] . ++(post) --(post)
+ - ~(unaires) ! cast new ++(pre) --(pre)
* / %
+ -
>> << (arith) >>> <<< (logique)
> >= < <= instanceof
== !=
&
^
|
&&
||
?:
Min = op=
En gras les nouveauts par rapport au C++

A noter labsence des oprateurs sizeof : par rapport au C/C++
2.5 Tableaux
Dclaration
int[] tableau_entiers;
double tableau_reels[];
long[][] tableau_2D; ou long[]tableau_2D [] ;
Cration
tableau_entiers = new int[12];
tableau_reels = new double[23];
tableau_2D = new long[5][4]; // peut avoir des lignes de taille diffrentes
tableau_entiers.length() ; //donne la taille du tableau
Utilisation
public static int [] suite(int n) // Mthode permettant de crer et
{ int [] tab = new int [n] ; //initialiser un tableau dentiers et le
for (int i=0; i<n; i++) // retourner
tab[i] = 2 * i;
return tab ; }
Exemple dun tableau 2 dimensions :

int[][] t = new int[4][];
for (int i=0; i<t.length(); i++) { //instantiation des lignes
t[i] = new int[4-i];}
for (int i=0; i<t.length(); i++) { //initialisation des colonnes
for (int j=0; j<t[i].length(); j++) {
t[i][j] = i+j;}}
t[0] 0 1 2 3
t[1] 1 2 3
t[2] 2 3
t[3] 3
[0] [1] [2] [3]
Remarques
Un tableau multidimensionnel est un tableau de tableaux.
La notion de tableau est gnralise.
La dimension dun tableau ne peut figurer dans la dclaration(int t[4] erreur)
3.CLASSES ET OBJETS
3.1 Dfinition dune classe :
class Point
{
// dfinition de Point
...
}
Remarques
Le code de la classe Point doit tre crit dans un fichier Point.java.
La dclaration et la dfinition dune classe sont combines.
Une classe dfini un type.
3.2 Instantiation
Point p1; // dclaration
p1 = new Point(); // instantiation
Point p2 = new Point(); // dclaration avec initialisation
Point p3 = null;
Remarques
Une variable est dclare avec un type.
Une variable contient une rfrence sur un objet.
Un objet est cr en instantiant une classe.
new est un oprateur dinstantiation.
null est une valeur qui dnote labsence dobjet.
null na pas de type.
Contrairement Smalltalk, null nest pas un objet.
// Exemple 3.2 : l'instanciation d'un objet System.out.println ("(2) : nbre objets =

ne permet pas de le crer, il faut avoir recours " + Obj.nbObj() ) ;
a une allocation dynamique (new). Obj b ;
class Obj System.out.println ("(3) : nbre objets =
{ public Obj() //constructeur " + Obj.nbObj() ) ;
{ System.out.print ("++ creation objet Obj b = new Obj() ;
; ") ; Obj c = new Obj() ;
nb ++ ; System.out.println ("(4) : nbre objets =
System.out.println ("il y en a " + nb) ; } " + Obj.nbObj() ) ;
public static long nbObj () }
{ return nb ;} }
private static long nb=0 ;
} /* Rsultats d'execution
public class TstObj2 (1) : nbre objets = 0
{ public static void main (String args[]) ++ creation objet Obj ; il y en a 1
{ Obj a ; //declaration (2) : nbre objets = 1
System.out.println ("(1) : nbre objets = (3) : nbre objets = 1
" + Obj.nbObj() ) ; ++ creation objet Obj ; il y en a 2
a = new Obj() ; //instantiation ++ creation objet Obj ; il y en a 3
(4) : nbre objets = 3
3.3 Notion de constructeur
Si une classe ne dispose pas de constructeur, Java fait appel un

constructeur par dfaut.
Remarques :
. pas de valeur de retour (comme en C++),
. possibilit de surdfinir un constructeur,
. appel direct dun constructeur depuis une autre mthode (super),
3.4 Exemples
// Exemple 3.4a : appel du constructeur par dfaut
class Point
{
public void Affiche()
{System.out.println ("constructeur par defaut : " + x + " " + y) ;}
private int x, y ;
}
public class _ConstDefaut
{ public static void main (String args[])
{
Point a = new Point() ;
a.Affiche();
}
}
/* Resultats
[mallem@gsc18 objets]$ /usr/java/j2sdk1.4.1_03/bin/java _ConstDefaut
constructeur par defaut : 0 0
[mallem@gsc18 objets]$*/
// Exemple 3.4b surdefinition de constructeurs, un constructeur ss arguments appelant un

const. a 2 arguments
class Point
{ public Point(int abs, int ord) //constructeur a 2 parametres
{ x = abs ;y = ord ;
System.out.println ("constructeur deux arguments : " + x + " " + y) ;}
public Point() //constructeur sans parametres
{ this (0,0) ; // appel Point (0,0) ; doit etre la premiere instruction
System.out.println ("constructeur sans argument") ;}
private int x, y ; //donnees membres
}
public class _Consthis
{ Point a = new Point (1, 2) ; Point b = new Point() ;}
}
/* Resultats
[mallem@gsc18 objets]$ /usr/java/j2sdk1.4.1_03/bin/java _Consthis
constructeur deux arguments : 1 2
constructeur sans argument
//Java permet de raliser des appels entre constructeurs lintrieur dune classe
// Exemple 3.4c : surdfinition de constructeurs (suite)

class Point
{ public Point(int abs, int ord)
{ x = abs ; y = ord ;
{
System.out.println ("coordonnees du point : " + x + " " + y) ;}
private int x, y ;
}public class _ConstDefaut2
{ Point a = new Point (1, 2) ; Point b = new Point() ; b.Affiche();}
}/* Resultats
[mallem@gsc18 objets]$ /usr/java/j2sdk1.4.1_03/bin/javac _ConstDefaut2.java
_ConstDefaut2.java:21: cannot resolve symbol
symbol : constructor Point ()
location: class Point
Point b = new Point() ;
^
1 error // le constructeur par dfaut nest pas appel ds linstant ou au moins un
constructeur est dfini
//Exemple 3.4d : Surdefinition de public class _Surdef2

constructeurs (suite) { public static void main (String args[])
class Point { Point a = new Point () ; // appelle
{ public Point () // constructeur 1 constructeur 1
(sans argument) a.affiche() ;
{x=0; y=0; Point b = new Point (5) ; // appelle
} constructeur 2
public Point (int abs) // b.affiche() ;
constructeur 2 (un argument) Point c = new Point (3, 9) ; // appelle
{ x = y = abs ; constructeur 3
} c.affiche() ;
public Point (int abs, int ord ) // }
constructeur 3 (deux arguments) }
{ x = abs ; y = ord ;
} /*
public void affiche () [mallem@gsc18 objets]$
{ System.out.println ("Coordonnees : " + /usr/java/j2sdk1.4.1_03/bin/java _Surdef2
x + " " + y) ; Coordonnees : 0 0
} Coordonnees : 5 5
private int x, y ; Coordonnees : 3 9
}
// Exemple 3.4e : appel du constructeur par recopie

class Point
{public Point(int abs, int ord)
{ x = abs ; y = ord ;
public Point(Point p) //constructeur par recopie
{ x = p.x ; y = p.y ;
System.out.println ("constructeur par recopie : " + x + " " + y) ;}
{ System.out.println ("coordonnees du point : " + x + " " + y) ; }
private int x, y ;
}
public class _ConstRecopie
{ Point a = new Point (1, 2) ; Point b = new Point(a) ; b.Affiche(); }
}/* Resultats
[mallem@gsc18 objets]$ /usr/java/j2sdk1.4.1_03/bin/java _ConstRecopie
constructeur par recopie : 1 2
coordonnees du point : 1 2
*/
3.5 Champs dun objet

Initialisation des types primitifs :
Boolean : false,
Char, short, int, long, float, double : null ou 0
Tout champ doit tre initialis !

Un champ donne peut tre un objet dune classe diffrente
Champ statique :
Plusieurs objets dune mme classe peuvent se partager un champ statique
Exemple [cf. exemple 3.2]

class B
{static int n ;
float y ;
}
B b1 = new B(), b2 = new B() ;

n est un champ de classe, car il commun la classe et tout objet de la classe :
Les critures suivantes sont quivalentes :
b1.n , b2.n et B.n
3 .6 Mthode de classe
Cest une mthode, dont la dfinition est prcde de static, et qui existe en un seul
exemplaire. Cette mthode ne peut agir que sur des champs de classe.
Cette notion est applique aux mthodes des librairies standard telles que Math
(exemple : Math.sqrt()).
Surdfinition de mthodes
Il sagit du mme mcanisme quen C++.
Exemple : constructeur par recopie
public Point (Point p)
{x=p.x ; y=p.y ;}
Point a = new Point (1,2) ; //constructeur usuel
Point b = new Point (a) ; //constructeur par recopie
}
3.8 Passage de paramtres entre mthodes
Par valeur. Les objets tant connus par leur rfrence (adresse). La mthode
appele travaille directement sur le mme objet que la mthode appelante.
Java ne dispose pas de pointeurs (absence des oprateurs * et &,->). Dans ce
cas, si une mthode appele doit modifier un paramtre pour la mthode
appelante, ce dernier doit obligatoirement tre un objet.
Un constructeur peut faire appel un autre en utilisant this qui doit tre la
1ere instruction de ce constructeur.
Exemple 1 : Passage dun objet en paramtre sans modification du paramtre

a.coincide(b) ; a et b objets de la classe Point.
Exemple 2 : Passage dun objet en paramtre avec modification du paramtre

a.permute(b) ; a et b objets de la classe point
a= a.permute(b) ;
3.9 Classe interne

Cest une classe dfinie lintrieur dune autre classe. Dans ce cas, la cration dun
objet de la classe externe implique celle de lobjet de la classe interne. Les objets
externe et interne accdent alors leur champs respectifs mme privs. Linconvnient
est la limitation de la r utilisation des classes.
Exemple : Une classe(Segment) encapsulant une autre(Point)
class Segment // { //moyen de contourner lhritage entre classes
class Point
{ public void affiche()
{ System.out.println ("point de coordonnees : " + x + " " + y) ;}
public Point (int x, int y){ this.x = x ; this.y = y ;}
private int x, y ;} //Point
public Segment (int xd, int yd, int xf, int yf, byte c)
{ orig = new Point (xd, yd) ; extrem = new Point (xf, yf) ; this.c = c ;}
public void affiche()
{ System.out.println ("segment de coordonnees : " + this.orig.x + " " + this.orig.y + " " +
this.extrem.x + " " + this.extrem.y + " " + this.c) ;
private Point orig, extrem ; private byte c ;} // Segment
public class _TstSeg
{ Segment s = new Segment (1, 3, 5, 9, (byte)2) ; s.affiche() ;} } //_TstSeg
[mallem@gsc18 ]$ /usr/java/j2sdk1.4.1_03/bin/java _TstSeg segment de coordonnees : 1 3 5 9 2
3.10 Classe enveloppe

Correspond une classe associ un type primitif(boolean, char, short, int, long, float,
double).
Toute classe enveloppe(Boolean,Character,Short,Integer,Long,Float,Double) dispose
dun constructeur ayant un type primitif en argument et de mthodes,dont :
- xxxValue (valeur de la variable),
- toString() (conversion valeur-ascii),
- parsexxx() (conversion ascii valeur)
(cf. paquetage : java.lang)

Exemple :
int n=12 ;
Integer nobj = new Integer(n) ;
int m = nobj.intValue() ;
3.11 Classe String
Classe standard permettant dinstancier des objets non modifiable.

Exemple :
Cration
String s = new String() ; // chane vide appel du constr. Sans argument
String s1 = new String( chane des caracteres ) ; // appel du constr. a 1 argument
String s2 = new String(s1) ; // reference sur s2 copie de s1appel du constr.par recopie
String s3=s1+s2 ; //concatnation
Oprations
s=clavier.lireString() ; //lecture
System.out.Println(s) ; //affichage
int n=s.lenght (); //longueur de la chane s
s.charAt(i) ; //accs au caractre i
n=s1.indexOf(d) ; //recherche de lindex de d dans s1
s2=s1.replace(d,c) ; // remplace d par c
s1.compareTo(s2) ; //comparaison de s1 et s2
Tableau de chane de caractres

String args[] //paramtre de la mthode de classe main
int argc=args.length ; //permet dobtenir le nombre de paramtres de la ligne de
commande
for(int i=0 ; i<argc ; i++)System.out.Println(args[i]) ; //affiche les paramtres de la
ligne de commande
(Illustrer par le programme args.java)
La classe StringBuffer permet de manipuler des chanes de caractres modifiables.
3.12 Classe abstraite

Cest une classe qui ne permet pas dinstancier des objets. Elle sert de classe de base
pour une drivation. Elle est destine contenir la dclaration des fonctionnalits de la
descendance.
Ex : Abstract class A
A a = new A() ; cause une erreur la compilation
Il existe galement la notion de mthode abstraite qui est dclare (prototype) mais non
dfinie.
public abstract void f()
Rgles :
. Une classe est abstraite si elle contient au moins une mthode abstraite,
. Une classe abstraite est forcment publique, car destine participer une drivation,
. Une classe drive dune classe abstraite nest pas oblige de re dfinir toutes les mthodes de
la classe abstraite. Si elle ne dfinit pas toutes les mthodes de la classe abstraite, elle devient
abstraite.
4. INTERFACES
4.1 Dfinition
Comme les classes abstraites, les interfaces permettent de dclarer des champs
(donnes et mthodes) sans les dfinir. Leur dfinition sera faite dans les classes
drives. La notion de classe abstraite est + gnrale que celle dinterface car elle
permet de dfinir des mthodes.
Exemple :
public interface I class A implements I
{ {
void f(int n) ; //A doit dfinir les mthodes de I
void g() ; }
}
Une classe peut implmenter plusieurs interfaces, il faudrait alors dfinir toutes les
mthodes de ces interfaces.
class A implements I1,I2,,In ( hritage multiple)
4.2 Remarques sur les interfaces

Une interface ne possde pas dimplmentation.
Une interface ne peut pas tre instantie, mais dfini un type (de la mme manire
quune classe abstraite).
Une interface peut aussi dfinir des constantes (static et final).
interface Rotateable
{
static final double PI = 3.1415926535;
public void rotate();
}
Une interface peut tendre une ou plusieurs autres interfaces.
interface Transformable extends Scalable, Rotateable {}
Une interface hrite de toutes les mthodes et constantes de sa super-interface.

Une interface dnote ce quun objet peut faire. Par convention, le nom dune inter-
face se termine gnralement par -able.
//4.2 Interfaces { public static void main (String[] args)

interface Affichable { Affichable [] tab ;
{ void affiche() ;} tab = new Affichable [3] ;
class Entier implements Affichable tab [0] = new Entier(12) ;
{ public Entier (int n) tab [1] = new Flottant (1.23f) ; ;
{ valeur = n ;} tab [2] = new Entier (34) ;
public void affiche() int i ;
{ System.out.println ("entier de valeur " for (i=0 ; i<3 ; i++)
+ valeur) ;} tab[i].affiche() ;
private int valeur ; }
} }
class Flottant implements Affichable /*
{ public Flottant (float x) [mallem@gsc18 objets]$
{ valeur = x ; } /usr/java/j2sdk1.4.1_03/bin/java _Interface
public void affiche() entier de valeur 12
{ System.out.println ("flottant de valeur " flottant de valeur 1.23
+ valeur) ;} entier de valeur 34
private float valeur ; [mallem@gsc18 objets]$
} */
public class _Interface
5. PAQUETAGE
5.1 Dfinition
Cest un regroupement logique, sous un identificateur, dun ensemble de classes qui se
partageront des donnes et mthodes.
5.2 Rgles :
Toutes les classes contenues dans un mme fichier source appartiennent au mme
paquetage par dfaut.
Le nom du paquetage correspond celui du rpertoire o il se trouve.
Un paquetage est unique pour une implmentation donne.
Lidentification dun paquetage se fait avec le mot cl package (Ex. package user)
La dsignation dun paquetage se fait de plusieurs faons :
Nom_paquetage.Nom_classe //dans une instruction
import Nom_paquetage.* //inclusion
import Nom_paquetage. Nom_classe //inclusion
Paquetages standards :
java.lang (contient les classes System, Math, Float, Integer ,)
java.awt ; java.swing (paquetages graphiques)
6. HERITAGE ET POLYMORPHISME
6.1 Introduction:
Terminologie :
mre, anctre, parente, super-classe
hritire, fille, drive, sous-classe
Hritage simple : (Java, Smalltalk)
Toutes les classes descendent dune superclasse Object
Une et une seule classe mre
Java : Une classe hrite dune autre mais peut implmenter plusieurs interfaces.
Hritage multiple : (C++)
Une classe peut ne pas avoir danctre
Plusieurs classes mres
Difficults pour lhritage rpt de membres :
Membres de mme nom
Mme classe hrite plusieurs fois
6.2 : Hritage simple en Java

Syntaxe :
class Derivee extends Base
Lobjet de la classe Derivee peut accder aux membres publiques de

sa classe de base, mais pas aux membres prives (Comme en C++).
6.3 Droits daccs aux classes et interfaces
Modificateur Signification
Public Accs pour tous
/ Accs depuis les classes du mme paquetage
// 6.2.1. Heritage simple avec appel public class _HerSimple

explicite du constr. de la classe de base { public static void main (String args[])
class Point { Point p = new Point (1, 2) ;
{ public Point (int x, int y) p.affiche() ; // appelle affiche de Point
{ this.x = x ; this.y = y ;} Pointcol pc = new Pointcol (3, 4, (byte)2) ;
public void deplace (int dx, int dy) p = pc ; // p de type Point, reference un
{ x += dx ; y += dy ;} objet de type Pointcol
public void affiche () p.affiche() ; // on appelle affiche de Pointcol
{ System.out.println ("Je suis en " + x + " " + p = new Point (5, 6) ; // p reference a nouveau
y) ;} un objet de type Point
protected int x, y ; p.affiche() ; // on appelle affiche de Point
} }
class Pointcol extends Point }
{ public Pointcol (int x, int y, byte couleur) /*[mallem@gsc18 objets]$[mallem@gsc18
{ super (x, y) ;// obligatoirement comme objets]$ /usr/java/j2sdk1.4.1_03/bin/java
premire instruction (remplace : du C++) _HerSimple
this.couleur = couleur ;} Je suis en 1 2
public void affiche () Je suis en 3 4
{ super.affiche() ; et ma couleur est : 2
System.out.println (" et ma couleur est : " + Je suis en 5 6
couleur) ;} [mallem@gsc18 objets]$
private byte couleur ; */
}
//
6.3 Droits daccs pour les membres et classes internes
Modificateur Signification
Public Accessible ds linstant o sa classe lest
Accessible depuis les classes du mme paquetage
protected Accessible depuis les classes drives ou celles du mme
paquetage
private Accs restreint la classe o est faite la dclaration du
membre ou de la classe interne
Rem. :
1)Il nya pas dexception faite, comme en C++, pour les fonctions amies
2)Il nya pas, comme en C++, de type dhritage private/protected .
6.4 Drivations successives

En java, toute classe drive dispose dune seule classe mre.
Exemple :
class D extends B extends A A

class E extends B extends A
class F extends B extends A
class G extends C extends A
B C
D E F G
6.5 Finalisation
Mot cl final : permet de figer limplmentation dune classe,

dune mthode, ou dune variable
De classe
Il ne pourra pas y avoir dhritires cette classe
exemple : public final class AFinalClass { }
De mthode
Une telle mthode ne pourra pas tre redfinie dans les classes hritires
(protection du code)
exemple : public final static void main (String args[])
De variable
Une telle variable est une constante (on lavait dj vu !)
exemple : final float PI = 3.1415927
6.6 Polymorphisme
Bas sur les notions de redfinition et de surdfinition de mthodes
6.6.1 Redfinition
Surcharge dune mthode en apportant une extension celle-ci. La redfinition
impose la mme signature (paramtres) et la mme valeur de retour la fonction
redfinie que celles de la mthode surcharge.
6.6.2 Surdfinition
Surcharge dune mthode en apportant une modification celle-ci. La surdfinition
nimpose pas la mme signature (paramtres) et la mme valeur de retour la fonction
redfinie que celles de la mthode surcharge.
Le polymorphisme permet de manipuler des objets sans en connatre parfaitement le
type. A (f)
Exemple : f est redfinie dans A, C et D.
dans la classe de lobjet layant invoque. Si chec, elle est B C (f)
recherche dans les classes ascendantes.
D(f) E F G
//6.6.3a polymorphisme1 : f() redfinie this.f() ; (3)

dans 2 classes (mre et fille) }
}
class A public class _Super
{ void f() { public static void main (String args[])
{ System.out.println ("appel f de A") ; { B b = new B() ;
} b.test() ;
} }
class B extends A }
{ void f() //f redfinie /*
{ System.out.println ("appel f de B") ; [mallem@gsc18 objets]$
} /usr/java/j2sdk1.4.1_03/bin/java _Super
public void test() appel f de A (1) //car a est un objet de A
{ A a = new A(); appel f de A (2)//appel de f() de A
a.f() ; (1) appel f de B (3)//appel f() de B
super.f() ; (2) */
//6.6.3b - polymorphisme :2 fonctions {public void test() // test() redfinie

redfinies dans 2 classes apparentes { C c = new C();
A,B et utilise dans une classe fille C. c.f() ; } (4)
class A }
{ void f() public class _Super2
{ System.out.println ("appel f de A") ;} { public static void main (String args[])
} { B b = new B() ;
class B extends A b.test() ;
{ void f() //f redfnie C c = new C();
{ System.out.println ("appel f de B") ; c.test(); // appel test() de C
} }
public void test() }
{ A a = new A(); /*[mallem@gsc18 objets]$
a.f() ; (1) /usr/java/j2sdk1.4.1_03/bin/java _Super2
super.f() ; (2) appel f de A (1) //car a est un objet de A
this.f() ; (3) appel f de A (2)//appel de f() de A
} appel f de B (3)//appel f() de B
} appel f de B (4)//appel f() de B car C ne
class C extends B //partie rajoute(rouge) contient pas de f()
//6.6.3c polymorphisme 3 : f() et public void test(int i) //test() surdfinie

test() surdfinies et utilise dans B et { C c = new C();
C. A B et C sont apparentes c.f(i) ; } (4)
class A }
{ void f(int i) public class _Super3
{ System.out.println ("appel f de A { public static void main (String args[])
avec un argument i = "+ i ) ; } { B b = new B() ;
} b.test() ;
class B extends A C c = new C();
{ void f() c.test(3); // appel test() de C
{ System.out.println ("appel f de B") ;} }
public void test() }
{ A a = new A(); /*
a.f(1) ; (1) [mallem@gsc18 objets]$
super.f(2) ; (2) /usr/java/j2sdk1.4.1_03/bin/java _Super3
this.f() ; } (3) appel f de A avec un argument i = 1 (1)
} appel f de A avec un argument i = 2 (2)
class C extends B appel f de B (3)
{ appel f de A avec un argument i = 3 (4)
//6.6.3d polymorphisme 4 : f() surdfinie {public void test(int i)

dans B et utilise dans B et C. A B et C { C c = new C();
sont apparentes c.f(i) ;
// Un objet de la classe mere peut }
rfrencer un objet de la classe fille }
class A public class _Super4
{ void f(int i) { public static void main (String args[])
{ { B b = new B() ;
System.out.println ("appel f de A avec un b.test() ;
argument i = "+ i ) ;} B c = new C();
} c.test();}// appel test() de B car pas ds C
class B extends A }
{ void f() /*mallem@gsc18 objets]$
{ System.out.println ("appel f de B") ;} /usr/java/j2sdk1.4.1_03/bin/java _Super4
public void test() appel f de A avec un argument i = 1 (1)
{ A a = new A(); appel f de A avec un argument i = 2 (2)
a.f(1) ; (1) (4) appel f de B (3)
super.f(2) ; (2) (5) appel f de A avec un argument i = 1 (4)
this.f() ; (3) (6) appel f de A avec un argument i = 2 (5)
}} appel f de B (6)
class C extends B
//6.6.3e polymorphisme 5 : f() { public void test(int i)

surdefinie dans B et redefinie dans C. { C c = new C();
A B et C sont apparentees. Un objet de c.f(i) ;}
la classe grand mere ne peut pas }
referencer un objet de la classe fille public class _Super5
class A { public static void main (String args[])
{ void f(int i) { B b = new B() ;
{ b.test() ;
System.out.println ("appel f de A avec A c = new C();
un argument i = "+ i ) ;} c.test();}
} }
class B extends A /*[mallem@gsc18 objets]$
{ void f() /usr/java/j2sdk1.4.1_03/bin/java _Super5
{ System.out.println ("appel f de B") ;} _Super5.java:32: cannot resolve symbol
public void test() symbol : method test ()
{ A a = new A(); a.f(1) ; location: class A
super.f(2) ; c.test();
this.f() ;}} ^
class C extends B 1 error
6.7 Super classe Object
Classe mre
toutes les autres classes Java descendent dObject
implictement une classe descend dObject
Mthodes de la Classe Object
Ces mthodes servent dcrire un objet et devraient tre surcharges par les
descendants de la classe:
toString() rend une version textuelle de lobjet appel implicitement si ncessaire.
equals() compare avec un autre objet rend true si gal.
Exemples :
Object o1 = new Point(1,2) ;
Object o2 = new Point(1,2) ;
o1.equal(o2) ; // retourne false
o1.toString() ; //retourne une chane de caractres contenant le nom de la classe et l@
de lobjet en hexadcimal.
7. EXCEPTION
7.1 Introduction
Cest une anomalie
Une exception reprsente une erreur qui survient lexcution. Elle peut avoir
+sieurs sources :
gnre par le systme (dpassement dindex de tableau), implicites et gres
par la MV. Linstant de leur occurrence nest pas connu lavance.
gnre explicitement par le programmeur et contrl par ce dernier.
Considre comme un objet

Une exception est reprsente dans le systme par un objet.
Les exceptions sont des instances de la classe Exception.
Traite par le programme utilisateur

Une exception peut tre installe, intercepte et manipule dans un programme.
7.2 Utilisation
- Cration
Pour dfinir une nouvelle catgorie dexception, il suffit de crer une sous-classe
dException. Une exception peut avoir ses propres variables dinstance et donc
transporter une information supplmentaire.
- Soulvement dune exception :
clause throw :
les mthodes susceptibles de lever une exception doivent le signaler : clause
throws suivant lentte de la mthode.
Capture dune exception : bloc try catch
try { bloc dinstructions pouvant soulever une ou plusieurs exceptions }
catch type dexception { bloc de traitement de lexception }
catch autre type dexception {bloc de traitement de lexception }
Rgles dutilisation
Une clause throw implique la prsence dune clause catch : une exception doit
tre traite,
La clause finally permet de spcifier un bloc de code qui doit tre excut avant
le programme de lexception ( rangement/sauvegarde,).
7.3a Exemple :Exception utilisateur gnre { this.abs=0; this.ord=0;}

explicitement. La classe layant gnre ne la traite pas. public int abs, ord;
//lancement de l'exception Exception1 car p } //class Exception1
pour abscisse -1, le bloc catch de main est public class Parcour1
execut car f n'en a pas. La suite de f n'est { public static void main (String args[])
ensuite pas execute. Il ya retour dans main et { try
poursuite en squence de main(). Si f doit tre { Point a = new Point (1, 2) ;
poursuivie en squence, il faut y prvoir un bloc a.f() ;
try - catch. System.out.println ("apres appel de f dans
class Point main") ;
{ public Point(int x, int y) throws Exception1 }
{ if ( (x<0) || (y<0))throw new Exception1() ; (2) catch (Exception1 e) (3)
this.x = x ; this.y = y ; { System.out.println ("dans catch
} (Exception1) de main") ;
public void f() throws Exception1 }
{Point p = new Point (-1, 0) ; (1) System.out.println("apres try dans main") ; (4)
System.out.println ("les nouvelles coordonnees }
de p sont : "+ p.x + " " + p.y) ; }
System.out.println ("apres exception ans f") ; /*
} [mallem@gsc18 7exception]$
public int x, y ; /usr/java/j2sdk1.4.1_03/bin/java Parcour1
} // class Point dans catch (Exception1) de main (3)
class Exception1 extends Exception apres try dans main (4)
{ Exception1 ()
7.3b Exemple : lancement de l'exception { Exception1 ()

Exception1 dans f car p pour abscisse -1, { this.abs=0; this.ord=0;}
le bloc catch de f est excut. La suite de f public int abs, ord;
} //class Exception1
est ensuite excute. Il y a retour dans
public class Parcour2
main et poursuite en squence de main(). { public static void main (String args[])
f traite lexception. { try{ Point a = new Point (1, 2) ;
class Point a.f() ;System.out.println ("apres appel de f
{ public Point(int x, int y) throws Exception1 dans main") ; (5)
{ if ( (x<0) || (y<0))throw new Exception1();(2) }
this.x = x ; this.y = y ;} catch (Exception1 e)
public void f() { System.out.println ("dans catch
{ try{ Point p = new Point (-1, 0) ; (1) (Exception1) de main , le pb est corrige, les
System.out.println ("les nouvelles coordonnees coordonnees sont : "+ e.abs + " " +e.ord) ;}
de p sont : "+ p.x + " " + p.y) ; } System.out.println("apres bloc try demain");(6)
catch (Exception1 e) (3) }
{ System.out.println ("dans catch }
(Exception1) de f , le pb est corrige, les [mallem@gsc18 7exception]$
coordonnees sont : "+ e.abs + " " +e.ord) ; /usr/java/j2sdk1.4.1_03/bin/java Parcour2
} dans catch (Exception1) de f , le pb est corrige,
System.out.println ("apres bloc try de f") ; (4)} les coordonnees sont : 0 0 (3)
private int x, y ; apres bloc try de f (4)
} //class Point apres appel de f dans main (5)
class Exception1 extends Exception apres bloc try de main (6)
7.3c Exemple : Rcupration derreur { // Point b = new Point (1, 2) ;

//lancement de l'exception Exception1 car b a Point b = new Point (-1, 2) ; //objet de saisie(1)
une abscisse < 0. L'exception remet a zero les a=b; // si cood >0 , initialiser objet de calcul
coord. de b, ce qui permet au programme de se }
poursuivre. On suppose que si les coord sont <0, catch (Exception1 e) (3)
le calcul ne peut se poursuivre. { System.out.println ("dans catch
class Point (Exception1) de main, les coordonnees sont : "+
{ public Point(int x, int y) throws Exception1 e.abs + " " +e.ord) ;
{ if ( (x<0) || (y<0))throw new Exception1();(2) a.x=e.abs; a.y=e.ord; // si coord < 0
this.x = x ; this.y = y ; } initialiser objet de calcul 0
public Point() }
{ this.x = 0 ; this.y = 0 ; } System.out.println ("apres try dans main les
public int x, y ; coordonnees de a sont : "+ a.x + " " +a.y) ; (4)
} //class Point }
class Exception1 extends Exception }
{ Exception1 () /*[mallem@gsc18 7exception]$
{ this.abs=0; this.ord=0;} /usr/java/j2sdk1.4.1_03/bin/java Parcour1
public int abs, ord; apres try dans main les coordonnees de a sont :
} //class Exception1 1 2 // pour b=(1,2)
public class Parcour11 //2 execution
{ public static void main (String args[]) dans catch (Exception1) de main, les
{ coordonnees sont : 0 0 //pour b=(-1,2) (3)
Point a = new Point () ; // objet de calcul apres try dans main les coordonnees de a sont :
try 0 0 (4)
{}
7.3d Exemple : Relance dexception class Exception2 extends Exception
//lancement de l'exception Exception1 dans f car {}
p pour abscisse -1, le bloc catch de f est public class Relance
excut, ensuite il ya lancement de l'exception { public static void main (String args[])
Exception2. Comme il n'ya pas de bloc catch { try
correspondant dans f, celui de main est alors { Point a = new Point (1, 2) ;
excut. Ensuite il y a sortie du bloc try. a.f() ;
class Point }
{ public Point(int x, int y) throws Exception1 catch (Exception1 e)
{ if ( (x<0) || (y<0))throw new Exception1();(2) { System.out.println ("dans catch
this.x = x ; this.y = y ;} (Exception1) de main") ;
public void f() throws Exception2 }
{ try catch (Exception2 e)
{ Point p = new Point (-1, 0) ; } (1) { System.out.println ("dans catch
catch (Exception1 e) (Exception2) de main") ; (4)
{ System.out.println ("dans catch }
(Exception1) de f") ; (3) System.out.println("apres bloc try demain");(5)
throw new Exception2() ; // on lance une }}
nouvelle exception} $ /usr/java/j2sdk1.4.1_03/bin/java Relance
System.out.println ("apres bloc try de f") ; } dans catch (Exception1) de f (3)
private int x, y ; dans catch (Exception2) de main (4)
} apres bloc try de main (5)
class Exception1 extends Exception
7.3eExemple :Inteception de la {double result = Double.MAX_VALUE;

division/zro try {result = frac.divide(); }
class DivideByZeroException catch (DivideByZeroException dze)
extends Exception {System.out.println("Sorry: " +
{public DivideByZeroException () {} dze.toString()); } (2)
public DivideByZeroException (String msg) return result;
{super(msg); }} }
class Fraction { public static void main (String args[])
protected double numerator; {Fraction frac1 = new Fraction();
protected double denominator; Fraction frac2 = new Fraction(1.0, 2.0);
Fraction()
{numerator = 0.0; denominator = 0.0; } // essaye de calculer les fractions
Fraction(double numerator, double System.out.println("Dividing frac1"); (1)
denominator) tryToDivide(frac1);
{this.numerator = numerator; System.out.println("Dividing frac2"); (4)
this.denominator = denominator;} tryToDivide(frac2);
double divide() throws DivideByZeroException }
{ if (denominator == 0.0)
throw new DivideByZeroException("It [MALLEM@ens-unix ii34_linux]$
happened, I can't believe it!"); (3) /usr/java/j2sdk1.4.2_02/bin/java testDivision
else Dividing frac1 (1)
return numerator / denominator; }} Sorry: DivideByZeroException: It happened, I
class testDivision can't believe it! (2) et (3)
{public static double tryToDivide(Fraction frac) Dividing frac2 (4)
Exceptions - classe Throwable Exceptions - clause finally

(Classe mre de Exception) try {...
Constructeurs } catch (Exception e) {
public Throwable() ...
public Throwable(String) // Constructeur } finally {
permettant de crer une nouvelle exception et dy ... }
associer un message. Remarques
La clause finally permet de spcifier un bloc de
Mthodes code qui doit tre excut dans tous les cas.
String getMessage() Si une exception nest pas intercepte ou alors est
Retourne le message associ lexception. releve dans un des blocs catch, cette exception
String toString() reste leve aprs lexcution du bloc finally.
Donne une reprsentation textuelle de lexception La clause finally permet notamment de fermer ou
pouvant tre affiche. de librer des ressources utilises dans le bloc try
void printStackTrace() (fermer un fichier, librer une connexion,)
Affiche le contenu de la pile au moment o
lexception a t leve. // Mthode appelant main
Throwable fillInStackTrace() public static void _system_(String [] args)
Permet de remettre jour la pile de lexception. {try {
Surtout utile lorsquune exception est cre // initialise le systme.
main(args);
et jete depuis des endroits diffrents. } catch (Throwable e) {
e.printStackTrace();
} finally {// libre les ressources du systme ;}}
8. THREADS
8.1 Introduction
Un thread est un objet de la classe Thread. Il sagit dun pseudo processus gr par la
Machine virtuelle.
La classe Thread est prdfinie (package java.lang)
Catgories de thread : - dmons (MV),

- utilisateur
Cration d une nouvelle instance

Thread unThread = new Thread()
Excution du processus
unThread.start();
Cet appel engendre lexcution de la mthode unThread.run(),
(rend eligible unThread dont le corps est dfini par la mthode run())
new Thread().start() : Cration + passage ltat ligible.
8.1a Exemple :
class ThreadExtends extends Thread {

public void run(){
while(true){
System.out.println("dans ThreadExtends.run");
}
}
}
public class Thread1 {
public static void main(String args[]) {
ThreadExtends t0 = new ThreadExtends();
t0.start();
while(true){
System.out.println("dans Thread1.main");
}
}
}
8.1b La classe Thread

import java.lang.Thread // par dfaut pour java.lang
Les constructeurs publics
Thread();
Thread(Runnable target);

Les mthodes publiques
void start();
void run();
void stop();
static void sleep(long ms);
void interrupt() ;

8.1c Etats dun Thread

priorit : [0..10]
par dfaut priorit =5 Bloqu attente, sommeil,fin E/S
stop()
rveil wait()
fin E/S sleep()
Cre stop() Mort
start() stop()
yield() interrupt()
Eligible Actif fin de run()
Attribution du
processeur par
l'ordonnanceur de la MV
8.2a Exemple
//Excution alterne de 3 threads this.attente = attente ;
public class threads }
{ public static void main (String args[]) public void run ()
{ Affiche t1 = new Affiche ("t1 ", 20) ; { try { while (true)
Affiche t2 = new Affiche ("t2 ", 10) ; { if (interrupted()) return ;
Affiche t3 = new Affiche ("t3 ", 30) ; System.out.print (texte) ;
t1.start() ; t2.start() ; t3.start() ; sleep (attente) ; }}
Clavier.lireString(); catch (InterruptedException e) {}
t1.interrupt() ; // interruption premier }
thread private String texte ;
System.out.println ("\n*** Arret premier private long attente ;
thread ***") ; }
Clavier.lireString();
t2.interrupt() ; // interruption deuxime
thread $ /usr/java/j2sdk1.4.1_03/bin/java threads
t3.interrupt() ; // interruption troisime t1 t2 t3 t2 t1 t2 t3 t1 t2 t2 t1 t3 t2 t1 t2 t3 t2 t1 t2
thread t3 t1 t2 t2 t1 t3 t2 t1 t2 t3 t2 t1 t2 t3 t1 t2 t2 t1 t3
System.out.println ("\n*** Arret deux t2 t2 t1 t3 t2 t1 t2 t3 t2 t1 t2
derniers threads ***") ;
}} *** Arret premier thread ***
class Affiche extends Thread t3 t2 t2 t3 t2 t2 t3 t2 t2 t3 t2 t2 t3 t2 t2 t3 t2 t2 t3
{ public Affiche (String texte, long attente) t2 t2 t3 t2 t2 t3 t2 t2 t3 t2 t2 t3 t2 t2 t3 t2 t2 t3 t2
{ this.texte = texte ; *** Arret deux derniers threads ***
8.2b Exemple // Synchronisation de 2 threads }

permettant laffichage dun nombre et de son public synchronized void affiche ()
carr. { System.out.println (n + " a pour carre " +
public class _Sync2threads carre ) ;
{ public static void main (String args[]) }
{ Nombres nb = new Nombres() ; private int n=0, carre ;
System.out.println ("nb dans main "+ }
nb.toString()) ;
Thread cal = new ThrCal (nb) ; // l'objet nb passe au thread est accessible dans
Thread aff = new ThrAff (nb) ; la methode run
System.out.println ("tapez entree pour class ThrCal extends Thread
sortir") ; { public ThrCal (Nombres nb)
cal.start() ; aff.start() ; { this.nb = nb ;
Clavier.lireString() ; System.out.println ("nb dans Thrcal "+
cal.interrupt() ; aff.interrupt() ; nb.toString()) ;
} }
} public void run ()
// La classe Nombres contient 2 methodes { try
synchroniees. Chaque methode s'execute de { while (!interrupted())
faon atomique. { nb.calcul () ;
class Nombres sleep (1000) ;
{ public synchronized void calcul() }
{ n++ ; }
carre = n*n ;
catch (InterruptedException e) {} catch (InterruptedException e) {}

} }
private Nombres nb; // il s'agit d'une private Nombres nb ; // il s'agit d'une
reference nb reference nb
} }
/*
1 a pour carre 1
2 a pour carre 4
class ThrAff extends Thread 4 a pour carre 16
{ public ThrAff (Nombres nb) 5 a pour carre 25
{ this.nb = nb ; 7 a pour carre 49
System.out.println ("nb dans ThrAff "+ 8 a pour carre 64
nb.toString()) ; 10 a pour carre 100
} // Les threads cal et aff travaillent sur la
public void run () rfrence nb. Donc, la modification faite par
{ try cal est connue par aff .
{ while (!interrupted())
{ cal est le producteur
nb.affiche() ; aff est le consommateur
sleep (1000) ;
}
}
8.3 Mcanismes de synchronisation

8.3.1 Synchronised
Ce mcanisme permet de simuler les oprations P et V dun smaphore. P est
applique en dbut de la mthode synchronise et V la fin de celle-ci.
8.3.2 wait() notify()

Ce sont 2 mthodes permettant de synchroniser des threads sur laccs une
ressource critique. Ci dessous les modif. De lexemple prcdent :
// La classe Nombres contient 2 methodes synchroniees. Chaque methode s'execute de faon atomique.
class Nombres
{ public synchronized void calcul()
{ if( !pret) {n++ ; carre = n*n ; pret=true ; notify() ; }
} else wait() ;
public synchronized void affiche ()

{ if( pret) { System.out.println (n + " a pour carre " + carre ) ;
pret=false ; notify() ; }
} else wait() ;
private int n=0, carre ;
private boolean pret=false ;
} // Lutilisation de notify() et wait() vite au thread cal de faire sleep() aprs le calcul.
9. Programmation graphique
9.1 Introduction
Version Java Anne Librairies
1.0 1996 Awt,applet
1.1 1998
1.2 1999 +swing
1.3 2000
1.4 2002
JFC (Java Foundation Classes de JAVA 2 (1999)) : ensemble de classes qui enrichi de manire
significative la gestion de l'interface graphique actuelle AWT. Il se dcompose en diffrents types de
fonctionnalits :
Swing : ces nouvelles classes dfinissent un nouvel ensemble de composants reprenant les composants
classiques (bouton, liste,...) enrichi de composants plus complexes (arbre, tableau,...). Par ailleurs elle
dfini le Model-View-Controller (MVC) qui permet une meilleure gestion de l'apparence des
composants, des vnements et de la reprsentation des donnes.
Une interface utilisateur obissant l'architecture MVC est compos de trois type d'objets qui
communiquent entre-eux:
un modle qui une reprsentation logique de l'interface utilisateur
une vue qui est la reprsentation "visuelle" du modle
un contrleur qui gre l'interaction avec l'utilisateur.
Java 2D : ces nouvelles classes du package java.awt permettent d'effectuer des oprations plus riches
de dessins : dfinitions et compositions de formes, transformations, antialiasing, gestion plus riche des
polices de caractres...
Java 3D (compatible Java 2) : cette bibliothque permet de programmer de raliser des scnes
virtuelles en 3D, et permet de grer les clairages, les textures, les animations d'objets 3D.
9.1a - Comment crer une fentre ?
Exemple :
import javax.swing.* ;
public class fenetre0
{ JFrame fenetre = new JFrame() ; // Cration de lobjet de taille nulle
fenetre.setSize (300, 50) ; // Dimensionnement de la fentre
fenetre.setTitle ("Ma Fenetre") ; // Titre de la fentre
fenetre.setVisible (true) ; //Affichage de la fentre
}
}
La fentre(Affiche en haut gauche) est reprsente par un thread(qui subsiste aprs la
fin de main()). Pour la fermer, cliquer sur
9.2 vnements
9.2.1 Introduction
Un vnement est un message qu'un objet envoie un autre objet lui signalant la
survenue de quelque chose de ``remarquable''. Il y a donc un metteur et un rcepteur.
Dans une application graphique, il y a gnralement une quantit importante d'objets et
d'vnements possibles. Aussi, pour tre rcepteur d'un vnement, un objet devra
signaler son intrt pour cet vnement. Un mme vnement peut intresser plusieurs
objets et inversement un mme objet peut s'intresser plusieurs vnements.
LA JVM ragit aux vnements qui surgissent dans l'environnement du systme
d'exploitation (clic souris, frappe d'une touche ..) et les traduit en crant des objets de
la classe EVENT (dans java.awt.Event).
Pour intercepter les vnements il faut :
- importer java.awt.Event.*;
- poser des couteurs d'vnements sur les composants qui doivent interagir avec
l'utilisateur ,
- redfinir des mthodes gestionnaires d'vnements, automatiquement appeles.
9.2.2. Les classes de composants
Vue partielle de la hirarchie

d'hritage des composants
AWT. Les classes abstraites
sont entoures en hachur.
9.2.3 Tableau des interfaces implmenter en fonction des vnements grer

Evnement gnr par Interface d'coute implmenter Signatures des mthodes abstraites ( redfinir obligatoirement)
Button, List, MenuItem, TexField ActionListener public void actionPerformed(ActionEvent e)
public void
Scrollbar AdjustmentListener
adjustmentValueChanged(AdjustmentEvent e)
public void componentHidden(ComponentEvent e)
public void componentMoved(ComponentEvent e)
Dialog, Frame ComponentListener
public void componentResized(ComponentEvent e)
public void componentShown(ComponentEvent e)
public void componentAdded(ContainerEvent e)
Container ContainerListener
public void componentRemoved(ContainerEvent e)
public void focusGained(FocusEvent e)
Component FocusListener
public void focusLost(FocusEvent e)
Checkbox,CheckboxMenuItem, Choice ItemListener public void itemStateChanged(ItemEvent e)
public void keyPressed(KeyEvent e)
Component KeyListener public void keyReleased(KeyEvent e)
public void keyTyped(KeyEvent e)
public void mouseClicked(MouseEvent e)
Canvas, Dialog, public void mouseEntered(MouseEvent e)
Frame, Panel, MouseListener public void mouseExited(MouseEvent e)
Window public void mousePressed(MouseEvent e)
public void mouseReleased(MouseEvent e)
public void mouseDragged(MouseEvent e)
Canvas, Dialog, Frame, Panel, Window MouseMotionListener
public void mouseMoved(MouseEvent e)
TextField TextListener public void textValueChanged(TextEvent e)
public void windowActivated(WindowEvent e)
public void windowClosed(WindowEvent e)
public void windowClosing(WindowEvent e)
Dialog, Frame WindowListener public void windowDeactivated(WindowEvent e)
public void windowDeiconified(WindowEvent e)
public void windowIconified(WindowEvent e)
public void windowOpened(WindowEvent e)
9.2.4. Boutons
. Cration
- crer une fentre(constitue dune racine, dun contenu et dune vitre),
- crer le ou les boutons, les associer au contenu de la fentre, - le bouton est visible
par dfaut,
- choisir le gestionnaire de formes, permettant de redimensionner et de placer les
composants dans la fentre
. Slection (avec un priphrique dentre quelconque)

- crer un couteur sur le bouton qui implmente linterface ActionListener,
- associer lcouteur la source de lvnement.
Quand lvnement est dclench, la mthode ActionPerformed de linterface

ActionListener est excute.
Si plusieurs boutons, la mthode getSource(), permet de les distinguer.
- 9.2.4. Exemples
9.2.4a - Comment dsigner dans une fentre avec la souris?
import javax.swing.* ; // Pour JFrame }

import java.awt.event.* ; // pour MouseEvent public void mousePressed (MouseEvent ev)
et MouseListener {}
class MaFenetre extends JFrame implements public void mouseReleased(MouseEvent ev)
MouseListener {}
{ public MaFenetre () // constructeur public void mouseEntered (MouseEvent ev)
{ setTitle ("Ma fenetre + Dsignation") ; {}
setBounds (10, 20, 300, 200) ; public void mouseExited (MouseEvent ev)
addMouseListener (this) ; {}
// la fenetre sera son propre couteur }
// d'vnements souris public class Designe
} { public static void main (String args[])
//Redfinition des mthodes vnements { MaFenetre fenetre = new MaFenetre() ;
public void mouseClicked(MouseEvent ev) fenetre.setVisible(true) ;
{ System.out.println ("clic dans fenetre") ; }}
$ java Designe
clic dans fenetre
Explications : Identication des touches
9.2.4b - Comment saisir des info. clavier dans une fentre?

Exemple :
import javax.swing.* ; { int code = e.getKeyCode() ;

import java.awt.* ; System.out.println ("Touche"+code+ " relachee :
import java.awt.event.* ; " + e.getKeyText (code)) ;
}
class MaFenetre extends JFrame implements public void keyTyped (KeyEvent e)
KeyListener { char c = e.getKeyChar() ;
{ public MaFenetre () System.out.println ("Caractere frappe : " +
{ setTitle ("Exemple lecture clavier") ; c + " de code " + (int)c) ;
setSize (300, 180) ; }
addKeyListener (this) ; }
} public class Clavier0
public void keyPressed (KeyEvent e) { public static void main (String args[])
{ int code = e.getKeyCode() ; { MaFenetre fen = new MaFenetre() ;
System.out.println ("Touche "+code+ " pressee : fen.setVisible(true) ;
" + e.getKeyText (code)) ; }
} }
public void keyReleased (KeyEvent e)
9.2.4b - Comment crer des boutons Bouton2.addActionListener(this);

dans une fentre + couteur ? }
Exemple import javax.swing.* ; public void actionPerformed (ActionEvent
import java.awt.* ; ev)
import java.awt.event.* ; { if (ev.getSource() == Bouton1)
class Fenetre extends JFrame implements System.out.println ("action sur bouton 1") ;
ActionListener if (ev.getSource() == Bouton2)
{ public Fenetre () System.out.println("action sur bouton 2");
{ setTitle ("Fentre + Boutons") ; }
setSize (300, 200) ; private JButton Bouton1, Bouton2 ;
Bouton1 = new JButton ("Bouton 1") ; }
Bouton2 = new JButton ("Bouton 2") ; public class Boutons
Container contenu = getContentPane() ; { public static void main (String args[])
contenu.setLayout(new FlowLayout()) ; { Fenetre fenetre = new Fenetre() ;
contenu.add(Bouton1) ; fenetre.setVisible(true) ;
contenu.add(Bouton2) ; }
Bouton1.addActionListener(this); }
$ java Boutons
action sur bouton 1
Explications sur lexemple 9.2.4b prcdent
Quand un "clic" a lieu sur un bouton (c--dire presser et relacher un bouton de la souris), une instance de la
classe ActionEvent est envoye.(La souris gnre d'autres vnements, voir la classe MouseEvent).
Le bouton cliqu met de toute faon un vnement de type ActionEvent.
Mais pour le dtecter dans son code, le programmeur doit poser un couteur spcifique sur ce bouton. Cela
s'effectue par la mthode addActionListener() qui est dfinie dans la classe java.awt.Button
Plus prcisment, le bouton bouton1 est la source d'un objet-vnement de la classe ActionEvent
Le paramtre this signifie que c'est la classe courante, ici Fenetre, qui est destinataire de l'vnement et
qui va se charger d'y rpondre grce la mthode actionPerformed.
Pour pouvoir rpondre l'vnement clic mis, la classe laquelle est dlgue la charge de rpondre, doit
implmenter obligatoirement l' interface ActionListener .
Alors, Java excute automatiquement toutes les mthodes de toutes les interfaces implmentes .
Dans l'interface ActionListener, il n'y a qu'une seule mthode actionPerformed
(ActionEvent ev) excute automatiquement
Le programmeur doit "profiter" de l'appel automatique de cette mthode pour y associer le code qui dcrit la
raction souhaite au clic, ou plus gnralement le traitement souhait en raction l'vnement ev.
Ici, le code se borne vrifier que c'est bien le bouton bouton1 qui a t cliqu, et le signale en affichant le
message " action sur bouton 1" sur la console.
La mthode de base pour reconnatre le composant metteur est getSource() qui adress l'objet-
vnement ev renvoit l'objet de la classe mre Object.
9.2.4c. Les contrles usuels
. Case cocher : permet deffectuer un choix de type oui/non
- Cration : caseAcocher = new JcheckBox( case ) ;

- associer un contenu : getContentpane().add(caseAcocher) ;
- associer un couteur de la catgorie Item et rdfinir sa mthode
ItemStateChanged(),
- consulter ltat de la case cocher : caseAcocher.isSelected() renvoie true/false
- positionner case cocher : caseAcocher.setSelected(), positionne true la case et
gnre un vnement Item.
. Bouton radio : permet deffectuer un choix de type oui/non

- Cration : BoutonRadio = new JRadioButton( boutonradio ) ;
- La suite est identique celle de la case cocher
. Champ de texte : insertion dune texte

- Cration : Texte = new JTextField( texte ) ;
- La suite est identique celle de la case cocher
9.3. Dessin
. Cration
- Peut se faire sur nimporte quel composant,

- Le rafrachissement du dessin est assur paintComponent(), appel
automatiquement par la JVM,
- Le composant fentre utilise paint() qui ne ralise pas le rafrachissement, cest la
raison pour laquelle il faut utiliser un panneau pour le dessin,
- Le panneau na ni titre, ni bordure, il est confondu la fentre.
- Dans la classe panneau, il faut redfinir paintComponent(), en commenant par faire
appel la mthode paintComponent() de la classe mre Jcomponent qui ralise le
rafrachissement.
9.3 Dessin
9.3.2 Exemple
import javax.swing.* ; g.setColor(Color.GREEN);
import java.awt.* ; g.fillOval (100, 20, 50, 30) ;
class Fenetre extends JFrame g.fillOval (10, 20, 50, 30) ;
{ Fenetre () }
{ setTitle ("Dessins ...") ; }
setSize (300, 150) ; public class dessins
p = new Panneau() ; { public static void main (String
getContentPane().add(p) ; args[])
} { Fenetre f = new Fenetre() ;
private JPanel p ; f.setVisible(true) ;
} }
class Panneau extends JPanel
{ public void
paintComponent(Graphics g)
{ super.paintComponent(g) ;
g.drawLine (40, 80, 80, 20) ;
g.drawRect (30, 90, 70, 10) ;
9.4. Dynamique des composants :

En java, la gestion des composants est dynamique :
. Cration : composant.validate() force le gestionnaire de formes placer le
composant,
. Suppression : composant.remove supprime le composant de son conteneur
. Dsactivation : composant.setEnabled(false) rend le composant non dsignable
. Activation : composant.setEnabled(true) rend le composant dsignable
9.4. Menus
. Cration Barre de menu : BarreMenu = new JmenuBar() ;

setJmenuBar(BarreMenu) ;
. Cration dun sous menu : Menu = new Jmenu( Titre ) ;
. Cration dun raccourci clavier : Menu.setMnemonic(T) ; //laccs au ss menu
Titre peut tre obtenu par lappui sur la touche T.
. Ajout dun sous menu la barre de menu : BarreMenu.add(Menu) ;

. Cration action dans un ss menu :
choix = new JcheckMenuItem( action1 ) ; //case cocher
couleur = new ActionCouleur[1] ; //Attribut graphique
attribut_geo = new JmenuItem( rayon ) ; // Attribut gomtrique
. Installation dun couteur sur action :

{choix,couleur, attribut_geo}.addActionListener(this) ;
. Cration dun menu surgissant : Surg = new JPopupMenu() ;
. Cration dune bulle daide : composant.setToolTipText(String)
Exemple : /* creation barre des menus */

barreMenus = new JMenuBar() ;
setJMenuBar(barreMenus) ;
/* creation menu formes et ses options rectangle et ovale */

formes = new JMenu ("Primitive") ; formes.setMnemonic('P') ;
barreMenus.add(formes) ;
rectangle = new JCheckBoxMenuItem ("Rectangle") ;
formes.add(rectangle) ;
rectangle.addActionListener (this) ;
ovale = new JCheckBoxMenuItem ("Ovale") ;

formes.add(ovale) ;
ovale.addActionListener (this) ;
/* creation menu Parametres et ses options Hauteur et Largeur */

Parametres = new JMenu ("Parametres") ;
barreMenus.add(Parametres) ;
largeur = new JMenuItem ("Largeur") ;
Parametres.add(largeur) ;
largeur.addActionListener (this) ;
hauteur = new JMenuItem ("Hauteur") ;
Parametres.add(hauteur) ; hauteur.addActionListener (this) ;
//Modification de la largeur du rectangle dans actionPerformed()

if (source == largeur)
{ String ch = JOptionPane.showInputDialog (this, "Largeur") ;
pan.setLargeur (Integer.parseInt(ch)) ;
}
9.4. Menus (exemples - suite)
//Preparation des ss menus couleur appeles actions commune a plusieurs menus

static public final String[] nomCouleurs = //noms des ss menus de Fonds
{"jaune", "vert", "cyan"} ;
static public final Color[] couleurs = //les couleurs reelles correspondantes
{Color.yellow, Color.green, Color.cyan} ;
static public final String[] nomIcones = //les fichiers correspondants aux couleurs
{"jaune.gif", "vert.gif", "cyan.gif"} ;
int nbCouleurs = nomCouleurs.length ; // Nombre de couleurs envisages

/* creation des actions */
actions = new ActionCouleur [nbCouleurs] ; //actions est un meta objet{jaune/vert/cyan}
for (int i=0 ; i<nbCouleurs ; i++) //Initialisation du meta objet "actions"
{ actions[i] = new ActionCouleur (nomCouleurs[i], couleurs[i],
nomIcones[i], pan) ; //pan : destination des ss menus de
"Fond"
}
/* creation menu surgissant Couleur et ses options */

couleurSurg = new JPopupMenu () ;
for (int i=0 ; i<nomCouleurs.length ; i++)
couleurSurg.add(actions[i]) ; //ajout au menu surgissant des ss menus {jaune/vert/cyan}
/* affichage menu surgissant sur clic dans fentre */

addMouseListener (new MouseAdapter ()
{ public void mouseReleased (MouseEvent e)
{ if (e.isPopupTrigger())
couleurSurg.show (e.getComponent(), e.getX(), e.getY()) ;
}
}) ;
/* creation barre d'outils couleurs */

/* (avec suppression textes associes et ajout de bulles d'aide */
barreCouleurs = new JToolBar () ;
for (int i=0 ; i<nomCouleurs.length ; i++)
{ JButton boutonCourant = barreCouleurs.add(actions[i]) ;
boutonCourant.setText(null) ;
boutonCourant.setToolTipText
((String)actions[i].getValue(Action.SHORT_DESCRIPTION)) ; //bulle daide
}
contenu.add(barreCouleurs, "North") ;
}
10.Applet
10.1 Introduction
10.1a Def. :Une applet est un programme qui est excut suite l'analyse d'un fichier
HTML contenant le nom et les paramtres de l'applet.
Applet.html Applet.class
Appletviewer/Browser
Console alphanum. Fentre graphique
10.1b Mthodes de contrle dune applet
Une applet est controle au moyen des quatre mthodes suivantes :
public void init()appele aprs le chargement de l'applet.

public void start()appele chaque fois que l'on entre dans le document
la contenant.
public void stop()appele chaque fois que l'on sort dans le document la
contenant.
public void destroy()appele pour dtruire les ressources alloues par
l'applet.
La mthode stop() ne fait rien par dfaut, l'applet pourra donc continuer
s'excuter en arrire plan.
Entre un appel start() et l'appel suivant stop() la mthode isAlive
retourne true.
10.1c Fichier HTML de lapplet
Une applet est incluse dans un document HTML grce la balise

<APPLET>,
exemple:
<APPLET
CODE = "Applet0.class"
WIDTH = 250
HEIGHT = 100
>
</APPLET>
La mthode suivante permet de rcuprer les paramtres passs dans la
page HTML :
public String getParameter(String name)
10.1d Exemple : Applet

// Applet0.html // Applet0.java
<HTML> import javax.swing.* ;
<BODY> public class Applet0 extends JApplet
<APPLET { public void init ()
CODE = "Applet0.class" {;
WIDTH = 250 System.out.println ("Applet0") ;
HEIGHT = 100
> }
</APPLET> }
</BODY>
</HTML>
Affichage sur la console :
Applet0
10.1e Exemple : Applet avec paramtres
// Applet1.html
<HTML> // Applet1.java
<BODY> import javax.swing.* ;
<APPLET public class Applet1 extends JApplet
CODE = "Applet1.class" { public void init ()
WIDTH = 250 { String fichier = getParameter ("fichier") ;
HEIGHT = 100 String proprio = getParameter ("proprio") ;
> int uid ;
<PARAM NAME = "fichier", VALUE = "f.dat"> System.out.println ("Fichier = " + fichier) ;
<PARAM NAME = "proprio", VALUE = "250"> System.out.println ("Proprietaire = " + proprio ) ;
> uid = Integer.parseInt(proprio) ;// conversion ASII-
</APPLET> INT
</BODY> }
</HTML> }
Affichage sur la console :
Fichier = f.dat
Proprietaire = 250
10.3 Restrictions dune applet

un certain nombre de manipulations sont interdites l'applet :
1.accs au systme de fichier local
2.lancement de tche au moyen de exec()
3.chargement de librairies
4.accs au System.getProperty() donnant des informations sur
l'utilisateur, la machine locale.
5.modification des proprits systme
6.accs un autre groupe de thread.
7.changement de ClassLoader, SocketImplFactory, SecurityManager,
ContentHandlerFactory, URLStreamHandlerFactory
8.ouvrir une connexion rseau vers une autre machine que celle dont elle
provient
9.accepter des connexions.
Il existe des gestionnaires de scurit qui prennent en compte la notion

dapplet certifie
10.4 Transformation dune application en applet
10.4a Actions
1) Supprimer main() ,
2) Transformer lobjet JFrame (cre en gnral par main()) en un objet driv
de JApplet. Eviter de doter cette classe de constructeur et confier ce travail
la mthode init(),
3) Supprimer les fonctions de dimensionnement (setSize(), setBounds()) et de
commentaires (setTitle()) de fentre,
4) Editer le fichier HTML de lapplet,
10.4b Exemple Transformation de lex. de dessin 9.3.2 en applet

// Applet3.html private JPanel p ;
<HTML> }
<BODY> class Panneau extends JPanel
<APPLET { public void paintComponent(Graphics g)
CODE = "Applet3.class" { super.paintComponent(g) ;
WIDTH = 250 g.drawLine(40,80,80,20); g.drawRect (30, 90, 70, 10) ;
HEIGHT = 100 g.setColor(Color.GREEN);
> g.fillOval (100, 20, 50, 30) ; g.fillOval (10, 20, 50, 30);
</APPLET> }}/*
</BODY> public class dessins
</HTML> { public static void main (String args[])
// Applet3.java { Fenetre f = new Fenetre() ;
import javax.swing.* ; f.setVisible(true) ;
import java.awt.* ; }
/* }*/
class Fenetre extends JFrame
{ Fenetre ()
{ setTitle ("Dessins ...") ;
setSize (300, 150) ;*/
public class Applet3 extends JApplet
{public void init ()
{
p = new Panneau() ;
getContentPane().add(p) ;
}
11. LES FLUX (STREAMS)

11.1. Def. : Ce sont des canaux de transmission dune suite doctets partir d'une source ou vers une
destination (fichier, priphrique, emplacement mmoire, connexion un site distant). Les flux sont unidirectionnels.
On distingue les flux accs squentiel et les flux accs direct.
11.2. Catgories
On en distingue :
- flux binaires (les images, vidos, sons, )
- flux texte (fichiers issus de traiteur de textes).
11.3 Classes utilises

paquetage java.io contient une cinquantaine de classes.
On distingue quatre classes principales dont toutes les autres hritent des reprsentations et
comportements propre chaque famille.
java.io.InputStream (flot binaire en lecture),
java.io.OutputStream (flot binaire en criture),
java.io.Reader (flot texte en lecture),
java.io.Writer (flot texte en criture).
11.4 Flux binaire en sortie accs squentiel

Exemple :Fichier binaire dentiers ls au clavier
import java.io.* ; System.out.println("f.dat est complet !

public class bin_seq_out ") ;
throws IOException }
{
int n ; //information saisie // Rsultats :
DataOutputStream f= new Saisir un entier : 1
Saisir un entier : 2
DataOutputStream
Saisir un entier : 45
(new FileOutputStream ("f.dat")) ; Saisir un entier : 5
do { System.out.print ("Saisir un entier : Saisir un entier : 0
") ; f.dat est complet !
n = Clavier.lireInt() ;
if (n != 0)
{ f. writeInt (n) ;
} OutputStream(Classe abstraite)
FileOutputStream (Classe manipulant les flux
}
en sortie)
while (n != 0) ; OutputStream(Classe abstraite)
f.close () ; DataOutputStream (Classe manipulant les flux
en sortie avec formatage)
11.5 Flux binaire en entre accs squentiel

Exemple :
Fichier binaire dentiers ls dans un fichier
import java.io.* ; catch (EOFException e)
public class bin_seq_in { eof = true ;
{ public static void main (String args[]) throws }
IOException if (!eof) System.out.println (n) ;
{ String f = "f.dat" ; } //while
int n = 0 ; entree.close () ;
System.out.println ("fin du fichier : " + f );
DataInputStream entree = new }
DataInputStream }
( new FileInputStream (f)) ; // Rsultats dexcution
System.out.println ("valeurs lues dans le fichier valeurs lues dans le fichier f.dat :
" + f + " :") ; 1
boolean eof = false ; // sera mis a true par 2
exception EOFile 45
while (!eof) 5
{ try fin du fichier : f.dat
{ n = entree.readInt () ;
}
11.6 Flux binaire en entre accs direct

Exemple :
Accs direct dans fichier binaire dentiers
import java.io.* ; n = e.readInt() ;
public class bin_dir_in System.out.println (" valeur = " + n) ;
IOException while (i != 0) ;
{
String f; e.close () ;
int n, i ; System.out.println ("fin de la recherche dans
RandomAccessFile e ; " +f);
System.out.print ("Nom du fichier : ") ; }
f = Clavier.lireString() ; }
e = new RandomAccessFile (f, " ") ; // Rsultats dexcution
Nom du fichier : f.dat
do Numro de l'entier recherch : 3
{ System.out.print ("Numro de l'entier valeur = 45
recherch : ") ; Numro de l'entier recherch : 0
i = Clavier.lireInt() ; fin de la recherche dans f.dat
if (i == 0) break ;
e.seek (4*(i-1)) ;
11.7 Flux texte en sortie

Exemple : Cration dun fichier texte
import java.io.* ; System.out.println ("fin creation fichier " + f);

public class txt_seq_out }
IOException
{ // Rsultats dexcution
String f ; Nom du fichier a creer : t.txt
int n ; Saisir un entier : 1
System.out.print ("Nom du fichier a creer : ") ; Saisir un entier : 2
f = Clavier.lireString() ; Saisir un entier : 3
PrintWriter s = new PrintWriter (new Saisir un entier : 45
FileWriter (f)) ; Saisir un entier : 0
fin creation fichier t.txt
do
{ System.out.print ("Saisir un entier : ") ; //Contenu du fichier t.txt
n = Clavier.lireInt() ; 1 a pour carre 1
if (n != 0) 2 a pour carre 4
{ s.println (n + " a pour carre " + n*n) ; 3 a pour carre 9
} 45 a pour carre 2025
}
while (n != 0) ;
s.close () ;
11.8 Flux texte en entre

Exemple : Cration dun fichier texte
import java.io.* ; }
public class txt_seq_in
{ public static void main (String args[]) throws // Rsultats dexcution
IOException Donnez le nom du fichier a lister : t.txt
{ 1 a pour carre 1
String f ;
String ligne ; 2 a pour carre 4
int n ;
System.out.print ("Donnez le nom du fichier a 3 a pour carre 9
lister : ") ;
f = Clavier.lireString() ; 45 a pour carre 2025
BufferedReader entree = new BufferedReader
(new FileReader (f)) ; fin fichier t.txt
do
{ ligne = entree.readLine() ;
if (ligne != null) System.out.println (ligne) ;
}
while (ligne != null) ;
entree.close () ;
System.out.println ("fin fichier " +f);
}
12 LES COLLECTIONS
L'interface Collection reprsente la racine de la hirarchie des collections

Java.
Une collection reprsente un groupe d'objets, dnomm lments pour les
listes (List) ou les ensembles (Set).
L'interface Collection possdent trois sous-interfaces List, Set et SortedSet.

Les implmentations de l'interface Collection sont AbstractCollection,
AbstractList, AbstractSet, ArrayList, HashSet, LinkedHashSet, LinkedList,
TreeSet et Vector.
12.3 concepts des collections

Une collection peut contenir des lments de type diffrents. A ces lments peuvent tre appliqus
plusieurs oprations :
- positionnement (mthode set()),

- interrogation (mthode get()),
- parcours (mthodes next() , previous), procures par linterface iterator. Le parcours est ddi un
objet iterator
- comparaison (mthode compareTo()),
- ajout (add(element)),
- suppression (remove(element)),
-
Des mthodes applicables des collections :
- Fusion ( collection1.addAll(collection2)),
- Suppression (collection1.removeAll(collection2)), - supprime de collection1 tous les lments trouvs
dans collection2,
- Suppression (collection1.retainAll(collection2)), - supprime de collection1 tous les lments non
trouvs dans collection2,
-
12.4 Exemple Liste chane if (ch.equals ("b"))

{ it.remove() ; // et on le supprime
import java.util.* ; break ;
public class Liste1 }
{ LinkedList l = new LinkedList() ; //def. de la liste System.out.print ("Liste en E : ") ; affiche (l) ;
chaine
}
System.out.print ("Liste en A : ") ; affiche (l) ; public static void affiche (LinkedList l)
l.add ("a") ; l.add ("b") ; // ajouts en fin de liste { ListIterator iter = l.listIterator ();
System.out.print ("Liste en B : ") ; affiche (l) ; while (iter.hasNext()) System.out.print (iter.next() +
" ") ;
ListIterator it = l.listIterator () ; System.out.println () ;
it.next() ; // on se place sur le premier lement }
it.add ("c") ; it.add ("b") ; // et on ajoute deux }
elements
System.out.print ("Liste en C : ") ; affiche (l) ; //Rsultats
Liste en A :
it = l.listIterator() ;
it.next() ; // on progresse d'un element Liste en B : a b
it.add ("b") ; it.add ("d") ; // et on ajoute deux
elements Liste en C : a c b b
System.out.print ("Liste en D : ") ; affiche (l) ;
Liste en D : a b d c b b
it = l.listIterator (l.size()) ; // on se place en fin de
liste Liste en E : a b d c b
while (it.hasPrevious()) // on recherche le dernier b
{ String ch = (String) it.previous() ;
12.4 Exemple Vecteurs dynamiques

v.add (2, new Integer (100)) ;
import java.util.* ; v.add (2, new Integer (200)) ;
public class Array1 System.out.println ("En D : contenu de v = " + v)
{ public static void main (String args[]) ;
{ ArrayList v = new ArrayList () ; /* modification d'elements de position donnee
System.out.println ("En A : taille de v = " + */
v.size() ) ; v.set (2, new Integer (1000)) ; // modification
/* on ajoute 10 objets de type Integer */ element de rang 2
for (int i=0 ; i<10 ; i++) v.add (new Integer(i)) ; v.set (5, new Integer (2000)) ; // modification
System.out.println ("En B : taille de v = " + element de rang 5
v.size() ) ; System.out.println ("En D : contenu de v = " + v)
/* affichage du contenu, par acces direct (get) a ;}
chaque element */ }
System.out.println ("En B : contenu de v = ") ; /*
for (int i = 0 ; i<v.size() ; i++) En A : taille de v = 0
System.out.print (v.get(i) + " ") ; En B : taille de v = 10
System.out.println () ; En B : contenu de v =0 1 2 3 4 5 6 7 8 9
/* suppression des elements de position donnee En C : contenu de v = [0, 1, 2, 4, 5, 8, 9]
*/ En D : contenu de v = [0, 1, 200, 100, 2, 4, 5, 8, 9]
v.remove (3) ; En D : contenu de v = [0, 1, 1000, 100, 2, 2000, 5,
v.remove (5) ; 8, 9]
v.remove (5) ;
System.out.println ("En C : contenu de v = " + v) */
;
/* ajout d'elements a une position donnee */
13. Enoncs des TDs et des TPs
TD1 : Notions de classe et de mthodes 32.4 puissance -2 = 9.525986892242037E-4 Cette mthode permet de lire une chane termine par
Exercice 1 : ENTER saisie au clavier(System.in)
//execution pour n=0 et la convertir en double.
crivez une classe en Java appele Calcul $ java Puissance.class 0
12.0 puissance 0 = 1 Q.2) une mthode permettant de traduire la moyenne en
effectuant la somme et la moyenne des lments du -5.3 puissance 0 = 1 une mention selon :
tableau t dfini ainsi : 0.0 puissance 0 = Pas dfini
int[] t = {12, 24, 12, -4, 6, 99, 22} ; 32.4 puissance 0 = 1 Note moyenne Mention
dans la fonction main qui se charge dappeler les */ note >= 18, Excellent
deux mthodes statiques somme et moyenne et Note : Il ne sagit pas dutiliser une classe pr existante 18 > note >= 16, TresBien
dafficher les rsultats. dans les packages java mais crire votre propre classe. 16 > note >= 14, Bien
Ces deux mthodes ont pour prototypes : Exercice 3 : 14 > note >= 12, AssezBien
public static int somme(int[] tab) On appelle palindrome un mot pouvant se lire 10 >=note < 12, Passable
public static int moyenne(int[] tab) indiffremment dans les deux sens : par exemple note < 10. Ajourn
Laval, elle, ici, Plus formellement, un mot de
longueur l est un palindrome si pour tout indice i<l, Le prototype de cette mthode est :
Exercice 2 : static String traduction(double moyenne)
le caractre la position i est gal au caractre la
crire une classe en Java appele Puissance effectuant la position l-i-1.
puissance des lments du tableau t dfini ainsi dans la Des exemples de rsultats sont fournis ci-dessous :
Il sagit dcrire une classe en Java appele $ java Mention.class
mthode main :
Palindrome constitue de : Entrez votre moyenne et tapez ENTER : 16.56
double [] t = {12, -5.3, 0, 32.4} ;
Cette classe calcule et affiche la valeur de x^n (lire x Votre mention est : TresBien
puissance n) o x est un rel (lment du tableau t) et n 1. Une mthode statique appele palindrome
un entier introduit comme argument de la ligne de prenant en argument un tableau de $ java Mention.class
commande. Pour une excution du programme, n est caractres s et renvoyant un boolen Entrez votre moyenne et tapez ENTER : 11.89
unique et sera appliqu tous les lments du tableau t. indiquant si le tableau est un palindrome. Votre mention est : Passable
Ci-deesous sont indiqus des exemples dexecution du Le prototype de cette dernire est :
programme Puissance.class. $ java Mention.class
public static boolean palindrome(String s) Entrez votre moyenne et tapez ENTER : 9.5
/* EXEMPLES DE RESULTATS Votre mention est : Ajourn
2. La mthode statique main permettant de
//execution pour n=2
$ java Puissance.class 2 tester cette fonction. La chane de
12.0 puissance 2 = 144.0 caractres tester sera rcupre par main
-5.3 puissance 2 = 28.09 sur la ligne de commande.
0.0 puissance 2 = 0.0
32.4 puissance 2 = 1049.76 Exercice 4 :
Ecrire une classe JAVA, nomm Mention, permettant
//execution pour n=-2 d'afficher la mention obtenue en fonction de la note
$ java Puissance.class -2 moyenne saisie au clavier.
12.0 puissance -2 = 0.006944444444444444 Cette classe doit contenir :

-5.3 puissance -2 = 0.0355998576005696 Q.1)une mthode de saisie de la moyenne de prototype :
0.0 puissance -2 = Pas dfini public static double saisieDouble()
TD2 : Notions de tableaux }
Exercice 4 : Exercice 5 :
Quel est le rsultat affich par le programme ci-aprs ?
Quel est le rsultat affich par le programme ci-aprs ?
Quel est son rle ?
Quel est son rle ?
public class TabArg1
public class Tab2Ind1
{ final int N = 4 ;
{ int [] [] t = new int [3][] ;
int t1[] = new int [N] ;
for (int i=0 ; i<3 ; i++)
int t2[] = new int [N] ;
{ t[i] = new int [i+1] ;
for (int i=0 ; i<N ; i++) t1[i] = i+1 ;
for (int j=0 ; j<t[i].length ; j++)
for (int i=0 ; i<N ; i++) t2[i] = 2*i+1 ;
t[i][j] = i+j ;
// affichage des valeurs de t1 et de t2
}
System.out.print ("t1 = ") ; affiche (t1) ;
for (int i=0 ; i<3 ; i++)
{ System.out.print ("tableau numero " + i + " = ") ;
t1 = t2 ;
for (int j=0 ; j<t[i].length ; j++)
t1[0] = 10 ; t2[1] = 20 ; t1[2] = 30 ; t2[3] = 40 ;
System.out.print (t[i][j] + " ") ;
// affichage des valeurs de t1 et de t2
System.out.println () ;
}
}
}
}
static void affiche (int [] t)
{ for (int i=0 ; i<t.length ; i++)
System.out.print (t[i] + " ") ;
System.out.println () ;
}
TD3 : Notions de classes et dhritage Anglais(){ }
Exercice 1 : super();} }
Il s'agit d'analyser le programme Java suivant ,
et de rpondre aux diffrentes questions. Anglais(boolean masc){ Q. 1- Que signifie la prsence de "abstract" dans la
super(masc);}
abstract class Homme{ dfinition de la classe "Homme" ?
protected int age; public void direBonjour(){
protected boolean masculin; System.out.println("Good morning ");}
Q. 2- Que signifie la prsence de "abstract" dans la
} //fin classe Anglais
dfinition de la mthode "direBonjour" de la classe
Homme(){
"Homme" ?
age = 20; class Hollandais extends Homme{
Q. 3-Quel est l'affichage produit par l'excution de
masculin = false;} Hollandais(){
ce programme ?
super();}
Q. 4-Quel intrt prsente une classe abstraite ?
Homme(boolean masc){
age = 20; Hollandais(boolean masc){
if (masc){ super(masc);} Exercice 2 : Indiquer le cas chant le numro de
masculin = true;} la ou des lignes provoquant une erreur de
else { public void direBonjour(){ compilation. Prciser lorigine de lerreur et
masculin = false;}} System.out.println("Goeie dag ");} justifier votre rponse.
} //fin classe Hollandais 1. class A {
abstract public void direBonjour(); 2. }
public int getAge(){ class Bonjour{ 3. class B extends A {
return age;} public static void main(String[] argv){ 4. }
Homme personnes[] = new Homme[3]; 5. public class Main {
public boolean getMasc(){ personnes[0] = new Anglais(); 6. public static void main(String args[]) {
return masculin;} personnes[1] = new Hollandais(false); 7. A a=new A();
} // fin classe Homme personnes[2] = new Francais(true); 8. B b=new B();
for (int i = 0; i < 3; i++){ 9. A a1=b;
class Francais extends Homme{ personnes[i].direBonjour(); 10. a1=(B)b;
Francais(){ System.out.println("J'ai " + 11. b=(B)a;
super();} personnes[i].getAge() + " ans."); 12. }
Francais(boolean masc){ System.out.print("Je suis "); 13. }
super(masc);} if (personnes[i].getMasc()){
System.out.println("un homme."); Exercice 3 : quel est le rsultat affich par
public void direBonjour(){ } lexcution de ce programme. Justifier votre
System.out.println("Bonjour");} else{ rponse.
} //fin classe Francais System.out.println("une femme.");
} 1. class A {
class Anglais extends Homme{ } 2. public boolean equals(A obj) {
3. System.out.println("A equals"); 11. try { 8. for (int i=0;i<9;i++) {
4. return true; 12. Thread.sleep(1); 9. j=j+i;
5. } 13. } catch (InterruptedException e) { 10. }
6. } 14. return; 11. System.out.println(j);
15. }
7. class B extends A { 12. }
16. System.out.println("Run : Thread numero " +
8. public boolean equals(B obj) { numero + " termine." ); 13. }
9. System.out.println("B equals"); 17. } 14. class Main3
10. return true; 15. {
11. } 18. public static void main(String args[]) { 16. public static void main(String args[]) {
12. } 19. System.out.println("Main : Programme demarre.."); 17. for (int i=0;i<4;i++) {
13. class Main2 { 20. for (int i=0; i < 3; i++) { 18. new
14. public static void main(String args[]) { 21. Thread unThread = new Threads(); Somme("Somme"+Integer.toString(i)).start();
15. B b=new B(); 22. unThread.start(); 19. }
23. }
16. A a=b; 20. }
24. System.out.println("Main : Programme principal
17. Object o=a; termine."); 21. }
18. System.out.println(b.equals(b)); 25. }
19. System.out.println(b.equals(a)); 26. } Q2 : Lajout de linstruction sleep(j) aprs la
20. System.out.println(a.equals(b)); ligne 11 engendre une erreur. Laquelle ?
21. System.out.println(o.equals(b));
1 Combien de threads ce programme permet il Proposez une modification du programme pour
22. }
d'engendrer ? permettre linsertion de cette instruction dans le
23. }
2 quel est le rle de la ligne 12 ? programme.
3 Quel est l'affichage produit par l'excution de ce
Exercice 5:
programme ?
Il s'agit d'analyser le programme Java suivant , et de
4 Quel est le nouveau affichage produit par l'excution de
rpondre aux diffrentes questions.
ce programme, si les lignes 11-15 sont supprimes?
1. public class Threads extends Thread {
2. private static int nbThreads = 0; // nb de threads Exercice 4:

crees Q1 :Quel est le rle du programme suivant et
3. private int numero; // numro du thread quaffiche t il suite son excution ? Justifier votre
4. Threads () { rponse.
5. numero = nbThreads;
6. nbThreads = nbThreads + 1; 1. class Somme extends Thread {
7. System.out.println("Threads : Thread numero " + 2. Somme(String s) {
numero + " cree." );
3. super(s);
8. }
4. System.out.println(s);
9. public void run() { 5. }
10. System.out.println("Run : Thread numero " + 6. public void run() {
numero + " demarre." ); 7. int j=0;
TD4 Java programmation graphique Exo 2 : Fentre de dialogue { FenDialog fen = new FenDialog() ;
Exo 1 : Champs de texte Il s'agit de complter le programme Java suivant , et de fen.setVisible(true) ;
Soit linterface graphique suivante : rpondre aux diffrentes questions. }
et ci dessous le code Java correspondant incomplet . }
import javax.swing.* ; class CopyTexte extends import javax.swing.* ;
Jframe{ import java.awt.* ; Ce programme consiste crer une fentre
private JtextField rightTextField ; private Jbutton import java.awt.event.* ; principale intitule "Essai boite de dialogue"
copyButton ; private JtextField lefTextField ; class FenDialog extends JFrame implements contenant un composant "Bouton" intitul
public CopyTexte() { lefTextField = new JtextField() ; ActionListener "Lancement dialogue".
copyButton = new Jbutton() ; rightTextField = new { public FenDialog () L'action sur ce bouton permet d'afficher une fentre
JtextField() ; lefTextField.setEditable(false) ; //Ajout { setTitle ("Essai boite de dialogue") ; secondaire de la classe JDialog dont un aperu de la
rightTextField.setEditable(false) ; //Ajout setSize (400, 200) ; documentation est fournie ci-aprs :
getContentPane().setLayout(new FlowLayout()) ; lanceDial = new JButton ("Lancement dialogue")
setTitle( Recopie Texte ) ; ; // Partie A - complter "public JDialog(Frame owner,String title)
getContentPane().add(lefTextField) ;
Creates a non-modal dialog with the specified title
copyButton.setText( RECOPIE ) ; and with the specified owner frame. If owner is null,
getContentPane().add(copyButton) ;
getContentPane().add(rightTextField) ; pack() ; a shared, hidden frame will be set as the owner of
the dialog."
}

} public class A {
Comme JFrame, la classe JDialog hrite de la
}
public static void main(String args[]) { new Component qui contient les mthodes setSize et
CopyTexte().setVisible(true) ; setVisible.
}
Sachant que linterface dcoute des vnements de . 5.1 : Complter la partie A indique qui doit
type ActionEvent dclenchs par un clic sur un ; // partie B - complter permettre de crer le bouton de la fentre principale
bouton et de prparer l'action sur ce dernier.
est ActionListerner et est dfinie comme suit :
public interface ActionListener {public void 5.2 : Complter la partie B indique qui doit
actionPerformed(ActionEvent e) ; permettre de prendre en compte l'action sur le
} bouton et d'afficher la fentre secondaire.
Donner ci dessous les ajouts que vous apporteriez au
code prcdent pour que lorsque lutilisateur clique sur
le bouton RECOPIE le contenu du champ texte de
gauche soit recopi dans le champ texte de droite
(mthodes String getText() pour rcuprer et .
setText(String s)pour affecter une valeur un private JButton lanceDial ;
JtextField). }
public class Dialog1
TP2 java programmation graphique
Programmation graphique
Sujet :
Le sujet se trouve dans le repertoire :
ens-unix $ /export/home/mmallem/ii74/tp2
Question 1 :
Le programme " boutons.java " donn comme base, et tudi en cours, permet de crer deux boutons,
en utilisant la librairie swing de java 2 et de mettre en place un couteur sur ces derniers.
Il s'agit d'tudier, de comprendre et de commenter ce programme d'une part et de le modifier d'autre

part. La modification consiste le gnraliser afin de crer plusieurs boutons(quatre comme exemple), de les
identifier, de les dsactiver suite chaque clic sur chacun d'eux.
Vous pouvez constater le resultat attendu en executant le fichier " bouttons2.class ".
Question 2 :
Le programme " cases1.java " donn comme base permet de crer une case cocher et d'installer
l'couteur correspondant et un bouton donnant l'tat de la case cocher.
part. La modification consiste le combiner avec votre programme, solution de la question 1. En effet la case
cocher, l'tat " true ", servira rendre actifs tous les boutons quelque soit leur tat.
Vous pouvez constater le resultat attendu en executant le fichier " case_bouttons.class ".
Question 3 :
Le programme " dessins.java " donn comme base, et tudi en cours, permet de crer des dessins 2D
en java 2.

part. La modification consiste le combiner avec votre programme, solution de la question 2. En effet les
bouttons serviront reprsenter des ordres d'un dessin 2D pre existant et de saisie de texte.
Vous pouvez constater le resultat attendu en executant le fichier " case_bouttons_dessins.class ".
N.B. : Etudier la classe JTextField utilisant les interfaces ActionListener et FocusListener
Question 4 :
Il s'agit de modifier votre programme, solution de la question 3. En effet les bouttons serviront
reprsenter des ordres d'un dessin 2D pre existant, de saisie de texte et de dessin de primitives 2D parametrables.
Vous pouvez constater le resultat attendu en executant le fichier " case_bouttons_dessiner.class ".
N.B. : Etudier notamment les classes :

JMenuBar,JMenu,JMenuItem,JCheckBoxMenuItem,JPopupMenu,couleurSurg,JToolBar et ActionCouleur.
TP3 java : Programmation graphique et Applet
Sujet :
Le sujet se trouve dans le repertoire :
ens-unix $ /export/home/mmallem/ii74/tp3
Question 1 :
Il s'agit de modifier l'application Boutons2.java ralise dans le TP prcdent (q1tp2) en une applet
JAVA (Boutons_Applet.java) en utilisant la librairie JApplet de swing ainsi que les mthodes de bases
init(), start(), stop() et destroy() grant la vie dune applet.
1.1 Construisez un fichier index1.html ncessaire pour le chargement de lapplet Boutons2_Applet

(cette classe tant fournie pour constater le rsultat attendu).
1.2 Excutez appletviewer index1.html et utilisez galement votre Navigateur WEB pour charger
le fichier index1.html. Commentez le rsultat.
1.3 Transformez lapplication Bouton2.java en une applet Boutons_Applet.java puis la compiler.
Excutez appletviewer index1.html aprs avoir apport les modifications ncessaires.
1.4 Surchargez les mthodes init(), start(), stop() et destroy() en affichant des messages prouvant leur
implications dans le cycle de vie de lapplet. Vous pouvez le vrifier en utilisant les diffrentes
possibilits offertes par le menu de votre appletviewer une fois lanc (Arrter, Recharger, Fermer
etc.)
Notes : Le fichier Boutons2_Applet.class n'est pas excut par l'interprteur java.exe (lequel
appelle toujours la mthode principale main()). C'est l'interprteur Java intgr dans le navigateur
(ou dans un visualisateur dapplet tel que appletviewer ) qui prend en charge l'excution en chargeant
le fichier repr dans la balise <APPLET > et qui doit se trouver obligatoirement dans l'attribut
CODE (ventuellement en le cherchant l'URL indique par CODEBASE) dans le fichier index1.html.
Question 2 :
Il sagit de transformez lapplication case_boutons.java (ralise dans la question 2 tu TP2)

en une applet JAVA et dutiliser le passage de paramtres entre le fichier HTML et le programme
java.
2.1 Construisez un fichier index2.html ncessaire pour le chargement de lapplet case_bouton_Applet

(cette classe tant fournie pour constater le rsultat attendu).
Ajoutez les balises permettant de dfinire 3 paramtres INIT, START et STOP ayant comme valeur
II34, POO et IHM respectivement.
2.2 Excutez appletviewer index2.html et commentez le rsultat.
2.3 Lobtention des paramtres souhaits se fera par une mthode que vous ajouterez qui sous la forme
(public String Obtenir_Parametre(String s) ). En entre, vous lui donnerez le nom du paramtre et elle
vous retourne la valeur de ce paramtre.
Question 3 :
Poursuite du TP2 et Transformation de lapplication case_bouttons_dessins en applet
JAVA
Question 4 :
Poursuite du TP2 et Transformation de lapplication case_bouttons_dessiner en applet
JAVA
Annexe
/* Explications sur les mthodes de la classe JApplet
Une applet possde un comportement standard, un "cycle de vie" par dfaut.
Ceci grce 4 mthodes prdfinies init(), start(), stop() et destroy().
Ces mthodes standard, automatiquement appliques un objet qui hrite de
la classe Applet ou JApplet permettent de contrler son excution.
Ces mthodes peuvent tre adaptes (surcharges) par le programmeur.
****Initialisation de l'applet : public void init() { ..}

Le navigateur lance cette mthode au chargement de l'applet (tat construit).
Cette mthode a pour rle de rcuprer des informations telles que images ou sons,
ainsi que les valeurs des paramtres passs dans la balise <applet ...>.
Ainsi, la mthode init() joue souvent le rle de constructeur. L'applet se trouve
ensuite dans l'tat initialise.
****Dmarrage : public void start() {...}

Aprs avoir t initialise, l'applet est dmarre, grce la mthode start(), et
se trouve alors dans l'tat actif Alors que l'initialisation n'a lieu qu'une fois
dans la vie d'une applet, il peut y avoir des appels rpts la mthode start().
En effet, une applet est redmarre aprs avoir t stoppe par la mthode stop().
****Arrt : public void stop() {...}

Cette mthode est appele lorsque la page HTML n'est elle-mme plus active; l'applet
se trouve alors dans l'tat inactif.Par exemple, parce que l'utilisateur a quitt la page
qui contient l'applet ou l'a redimensionne..A noter que la redfinition de stop() est
ncessaire pour permettre de suspendre l'excution des threads.
****Destruction : public void destroy() {...}

L'applet est dtruite lorsque l'on sort du navigateur, ou avant que l'applet ne soit
recharge. L'applet passe d'abord par l'tat inactif par stop(), avant d'tre dtruite.
*/

EC923-Programmation Objet

Transféré par

Informations du document

Titre original

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

EC923-Programmation Objet

Transféré par

Droits d'auteur :

Formats disponibles

_______________________

UFR S&T, ,40 Rue du Pelvoux F-91020 Evry Cedex Tl :+33-1-69 47 75 15

2.SPECIFICITES DE JAVA .................................................................................................................................................................................................................................. 10

3.CLASSES ET OBJETS ........................................................................................................................................................................................................................................ 16

6. HERITAGE ET POLYMORPHISME ............................................................................................................................................................................................................. 37

9. PROGRAMMATION GRAPHIQUE ............................................................................................................................................................................................................... 66

11. LES FLUX (STREAMS) ................................................................................................................................................................................................................................... 93

12 LES COLLECTIONS ...................................................................................................................................................................................................................................... 100

13. ENONCES DES TPS ....................................................................................................................................................................................................................................... 104

1996, Java(Sun Microsystems Joy et Gosling) -

Projet Oak appliqu WWW.

Java combine les caractristiques des langages :

1 programme = objets +messages

1 programme = objets + interfaces

1.2 Machine Virtuelle Java

1.3 Caractristiques de Java

2.2 Mots cls

En souligns les nouveauts par rapport au C++

2.3 Types de base

Priorit Oprateur(s) Associativit

En gras les nouveauts par rapport au C++

Exemple dun tableau 2 dimensions :

// Exemple 3.2 : l'instanciation d'un objet System.out.println ("(2) : nbre objets =

3.3 Notion de constructeur

Si une classe ne dispose pas de constructeur, Java fait appel un

// Exemple 3.4b surdefinition de constructeurs, un constructeur ss arguments appelant un

// Exemple 3.4c : surdfinition de constructeurs (suite)

//Exemple 3.4d : Surdefinition de public class _Surdef2

// Exemple 3.4e : appel du constructeur par recopie

3.5 Champs dun objet

Tout champ doit tre initialis !

Exemple [cf. exemple 3.2]

B b1 = new B(), b2 = new B() ;

3.8 Passage de paramtres entre mthodes

Exemple 1 : Passage dun objet en paramtre sans modification du paramtre

Exemple 2 : Passage dun objet en paramtre avec modification du paramtre

3.9 Classe interne

3.10 Classe enveloppe

(cf. paquetage : java.lang)

3.11 Classe String

Classe standard permettant dinstancier des objets non modifiable.

Tableau de chane de caractres

(Illustrer par le programme args.java)

La classe StringBuffer permet de manipuler des chanes de caractres modifiables.

3.12 Classe abstraite

4.2 Remarques sur les interfaces

Une interface hrite de toutes les mthodes et constantes de sa super-interface.

//4.2 Interfaces { public static void main (String[] args)

6.2 : Hritage simple en Java

Lobjet de la classe Derivee peut accder aux membres publiques de

6.3 Droits daccs aux classes et interfaces

// 6.2.1. Heritage simple avec appel public class _HerSimple

6.3 Droits daccs pour les membres et classes internes

6.4 Drivations successives

class D extends B extends A A

Mot cl final : permet de figer limplmentation dune classe,

//6.6.3a polymorphisme1 : f() redfinie this.f() ; (3)

//6.6.3b - polymorphisme :2 fonctions {public void test() // test() redfinie

//6.6.3c polymorphisme 3 : f() et public void test(int i) //test() surdfinie

//6.6.3d polymorphisme 4 : f() surdfinie {public void test(int i)

//6.6.3e polymorphisme 5 : f() { public void test(int i)

6.7 Super classe Object

Considre comme un objet