View
111
Download
1
Category
Preview:
Citation preview
Présentation de POO-Java - p. 1Philippe Canalda
Présentation du cours de Conception et de
Programmation Orientée Objet - Java
Philippe CanaldaMaster 1 PSM – Montbéliard – Conception et
Programmation Avancée MultiMédia
UFR STGI / LiFC FRE CNRS 2661Philippe.Canalda@univ-fcomte.fr
http://src.pu-pm.univ-fcomte.fr/public/staff/canalda
Octobre 2006
Présentation de POO-Java - p. 2Philippe Canalda
En préambule
• Organisation – En groupe de 4 au sein de votre groupe de TP– Nomination du 1er groupe prenant les notes dans ce
cours et chargé de délivrer• À la fin de la journée, un cr
• À la fin de la semaine une version corrigée/étendue
matériel utilisé : tous les matériaux de ce cours : src présentation, codes src, corrections d’exercices, etc.intégration du travail d’autrui
Présentation de POO-Java - p. 3Philippe Canalda
1ère intervention CM : prises de notes : F. Schulzendorf +
J.Roden• Organisation de l’enseignement• 1ère illustration d’une application intégrant une caméra, un mur
d’écran, un service (architecture serveur ou C/S) • qui détermine les groupes d’étudiants de 4 éléments (complétion à moins) au sein
des sous-groupes A, B et C– Affichage des visages à inter changer afin de placer le sous-groupe formé aux places de
la salle où se trouvent assis tous les sous-groupes déjà formés.
• Déroulement de l’algorithme de tri par insertion et constitution des groupes d’étudiant
• Présentation <orale> des applications multimédia et les challenges des nouveaux services : prise en compte des handicaps, des nouveaux usages (mobilité intérieur ou extérieur), des réseaux de capteurs
• Présentation du projet, contraintes, fonctionnalités, méthode, diagramme de GANT
Présentation de POO-Java - p. 4Philippe Canalda
1ère intervention TD
• 1er jet cdc du projet inspiré de FrozenBubble
• Présentation succinct de tous les projets au sein du TD
• 1er jet conception avec exposé des RI (Représentations Informatiques) nécessaires, 1ères fonctionnalités
Présentation de POO-Java - p. 5Philippe Canalda
1ère intervention TP : prise de notes
• TP1 E. Dietrich + François Welker
• TP2 S. Armessen + J. Pascau
• TP 3 – Conception et réalisation des principales fonctions de votre projet (au
– 2 fonctionnalités)
• Calcule des boules qui sont en contact d’une boule initiale
Présentation de POO-Java - p. 6Philippe Canalda
Plan
• Présentation de ce qui vous attend
• Bibliographie
• Programmation objet
• Le langage Java
• Algorithmique 1 (rappel) et 2
• ...
Présentation de POO-Java - p. 7Philippe Canalda
Plan
• ...
• Notions d’UML : les 7 (sur 12) diagrammes de conception et de développement
• Les classes fondamentales
• La programmation concurrente
• Les flots
• Les composants awt de java
• Introduction à Swing
• Réseau
• JDBC
• Java Xml
Présentation de POO-Java - p. 8Philippe Canalda
Bibliographie
Livre de référence• Hortsmann et Cornell, Au coeur de Java 1
et 2, CampusPress.• Gilles Roussel, Etienne Duris, Java et
Internet : concepts et programmation, Vuibert 2002
Transparents de Marie-Pierre Béal, et Jean Berstel.
Présentation de POO-Java - p. 9Philippe Canalda
Bibliographie
Autres ouvrages sur Java• Patrick Niemeyer, Joshua Peck (Traduction de Eric
Dumas), Java par la Pratique, O'Reilly International Thomson, 1996.
• Matthew Robinson and Pavel Vorobiev, Swing, Manning Publications Co., december 1999.
Sur les design Pattern• Erich Gamma, Richard Helm, Ralph Johnsons, John
Vlissides, Design Patterns, Addison-Wesley, 1995. Traduction française chez Vuibert (1999).
Présentation de POO-Java - p. 10Philippe Canalda
Bibliographie
Sur l’UML
• Michael Blaha & James Rumbaugh, Modélisation et Conception orientées objet avec UML2, 2ème édition, Pearson Education,2005.
• Craig Larman, UML2 et les Design Patterns, 3ème édition, Pearson Education, 2005.
• Martin Fowler, UML 2.0, Campus Press, 2004.
Présentation de POO-Java - p. 11Philippe Canalda
Bibliographie
Site Web :– http://java.sun.com : Site officiel Java (JDK et doc.)
– http://www.javaworld.com : Info sur Java
– http://www.developer.com/java/: applications, applets, packages, ...
– http://java.developpez.com/– http://www.jars.com : idem
– http://www.blackdown.com : Java pour linux
– ...
Présentation de POO-Java - p. 12Philippe Canalda
Travail demandéContrôle de Connaissances
– Sur 6 semaines :
• Un projet inspiré de FrozenBubble– En TP, puis à la maison
• Une participation/évaluation prises de notes– En CM– TD– Et TP
• L’examen final de 1ère et de 2ème session
Présentation de POO-Java - p. 13Philippe Canalda
1- Programmation objet
• 1. Styles de programmation
• 2. Avantages du style objet
• 3. Un exemple
• 4. Héritage et composition
• 5. Exemple : disques et anneaux
Présentation de POO-Java - p. 14Philippe Canalda
1.1 Styles de programmation
Style applicatif
• Fondé sur l’évaluation d’expressions, où le résultat ne dépend que de la valeur des arguments (et non de l’état de la mémoire)
• Donne des programmes courts faciles à comprendre
• Usage intensif de la récursivité
• Langage typique Lisp, Caml
Présentation de POO-Java - p. 15Philippe Canalda
1.1 Styles de programmation
Style impératif
• Fondé sur l’exécution d ’instructions modifiant l ’état de la mémoire
• Utilise une structure de contrôle et des structures de données
• Usage intensif de l ’itération
• Langage typique Ada, C, Pascal, Fortran, Cobol
Présentation de POO-Java - p. 16Philippe Canalda
1.1 Styles de programmation
Style objet• Un programme est vu comme une communauté de
composants autonomes (objets) disposant de ses ressources et de ses moyens d’interaction
• Utilise des classes pour décrire les structures et leur comportement
• Usage intensif de l’échange de messages (métaphore)• Langage typique Simula, Smalltalk, C++, Java, Ocaml
Présentation de POO-Java - p. 17Philippe Canalda
1.2 Avantages du style objet
Facilite la programmation modulaire• La conception par classe conduit à des composants
réutilisables• Un composant offre des services et en utilise d ’autres• Il « expose » ses services à travers une interface• Il cache les détails d ’implémentations (encapsulation
ou data-hiding)• Tout ceci le rend ré-u-ti-li-sa-ble
Présentation de POO-Java - p. 18Philippe Canalda
1.2 Avantages du style objet
Facilite l ’abstraction• L’abstraction sépare la définition de son implémentation• L ’abstraction extrait un modèle commun à plusieurs
composants• Le modèle commun est partagé par le mécanisme
d ’héritage• L ’abstraction est véhiculée par une méthodologie qui
conduit à la réutilisabilité
Présentation de POO-Java - p. 19Philippe Canalda
1.2 Avantages du style objet
Facilite la spécialisation• La spécialisation traite des cas particuliers • Le mécanisme de dérivation rend les cas particuliers
transparents
Présentation de POO-Java - p. 20Philippe Canalda
1.3 Un exemple
class Point {
private int x;
private int y;
public Point (int x, int y) {
this.x = x; this.y = y;
}
public int getX() {
return x; // équivalent à ‘ return this.x ’
}
public int getY() {
return y;
}
public int setX(int x) {
return this.x = x;
}
...
Présentation de POO-Java - p. 21Philippe Canalda
1.3 Un exemple
class Point {
private int x; private int y;
public Point (int x, int y) { … }
public int getX() { … } public int getY() { … }
public int setX(int x) { … }
public int setY(int y) {
return this.y = y;
}
public void deplace(int dx, int dy){
this.x += dx;
this.y += dy;
}
public String toString() {
return (thix.x + «, » + this.y);
}
...
Présentation de POO-Java - p. 22Philippe Canalda
1.3 Un exemple
class Point {
private int x; private int y;
public Point (int x, int y) { … }
public int getX() { … } public int getY() { … }
public int setX(int x) { … }
public int setY(int y) { … }
public void deplace(int dx, int dy){ … }
public String toString() { … }
public static void main(String[] args) {
Point a = new Point(3,5); // déclare l ’objet a et instancie ses a.setY(6); // a = (3, 6) coordonnées
a.deplace(1,1) ; // a = (4,7)
System.out.println(a);
}
}
Présentation de POO-Java - p. 23Philippe Canalda
1.4 Héritage et composition
Par la composition, une classe utilise un autre service• Un composant est souvent un attribut de la classe utilisatrice
• L ’exécution de certaines tâches est déléguée au composant le plus apte
• Le composant a la responsabilité de la bonne exécution
• Facilite la séparation des tâches en modules spécialisés
Présentation de POO-Java - p. 24Philippe Canalda
1.5 Exemple : disques et anneauxclass Disque {
protected Point centre ; // composition
protected int rayon ;
public Disque(int x, int y, int rayon) {
this.centre=new Point(x,y) ; // identique à super(x,y)
this.rayon = rayon ;
}
public String toString() {
return this.centre.toString() + «, » + rayon ;
}
public void deplace(int dx, int dy) {
this.centre.deplace(dx, dy); // délégation
}
}
Présentation de POO-Java - p. 25Philippe Canalda
1.5 Exemple : disques et anneauxclass Anneau extends Disque { // dérivation
private int rayonInterne ; // composition
public Anneau(int x, int y, int rayon, int rayonInterne){
super(x,y,rayon) ; // identique à this.Disque(x,y)
this.rayonInterne = rayonInterne ;
}
public String toString() {
return super.toString() + « , » + rayonInterne ;
}
}
Présentation de POO-Java - p. 26Philippe Canalda
2.1 Premier exemple
Le fichier TestHelloWorld.java :
Class TestHelloWorld {
public static void main(String[] args) {
System.out.println(« Bonjour! »);
}
}
La compilation : javac TestHelloWorld.java
crée le fichier : TestHelloWorld.class
L ’exécution : java TestHelloWorld
Donne le résultat : Bonjour !
• Il est usuel de donner une initiale majuscule aux classes, et une initiale minuscule aux attributs et aux méthodes
• Le nom du fichier qui contient le code source est en général le nom de la classe suffixé par .java
Présentation de POO-Java - p. 27Philippe Canalda
2.1 Deuxième exemple
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Color;
/** ******\
* Classe affichant une fenêtre de nom « Hello World » contenant « Bonjour »
* @author Canalda
* @version 1.0
\******* */
public class TestHelloWorld extends Frame {
/**
* Constructeur
*/
public TestHelloWorld() {
super(« Hello World ! »);
setSize(200,100);
show();
}
Présentation de POO-Java - p. 28Philippe Canalda
2.1 Deuxième exemple
public class TestHelloWorld extends Frame {
…
/** Méthode de dessin de la fenêtre
* @params graphics contexte d ’affichage
*/
public void paint(Graphics graphics) {
graphics.setColor(Color.black);
graphics.drawString(« Bonjour », 65, 60);
}
/* Méthode principale
* @param args arguments de la ligne de commande
*/
public static void main(String[] args) {
new TestHelloWorld();
}
}
Présentation de POO-Java - p. 29Philippe Canalda
2.1 Deuxième exemple
Création d e la documentation html
javadoc TestHelloworld
visualisation avec un navigateur, comme Netscape
$ls
TestHelloWorld.class
TestHelloWorld.html
HelloWorld.java
…
Questions : Donnez la liste complète des fichiers créés, capturez la fenêtre du navigateur et affichez la documentation html du 2ème exemple traité
Présentation de POO-Java - p. 30Philippe Canalda
2.1 Créer une documentation HTML
Il s ’agit de créer une documentation et non d ’établir les spécifications des classes.• @author : il peut y avoir plusieurs auteurs• @see : pour créer un lien sur une autre documentation Java• @param : pour indiquer les paramètres d ’une méthode• @return : pour indiquer la valeur de retour d ’une fonction• @exception : pour indiquer quelle exception est levée• @version : pour indiquer le numéro de version du code• @since : pour indiquer le numéro de version initiale• @deprecated : indique une méthode ou membre qui ne devrait plus être utilisée. Crée un warning lors de
la compilation.
- exemple :
/**
* @deprecated Utiliser plutôt afficher
* @see #afficher()
*/
Présentation de POO-Java - p. 31Philippe Canalda
2.1 Un exemple
/**
* Classe permettant de manipuler des matrices
* @author Canalda
* @author Fino
* @version 1.0
*/
public class Matrice {
private int n;
private int [][] m;
/** Premier constructeur. Cree une matrice nulle de taille donnee en * parametre.
* @param n un entier pour la taille
* @see Matrice#Matrice(int, int)
*/
...
Présentation de POO-Java - p. 32Philippe Canalda
2.1 Un exemple
public class Matrice {
private int n;
private int [][] m;
/** Premier constructeur. Cree une matrice nulle de taille donnee en * parametre.
* @param n un entier pour la taille
* @see Matrice#Matrice(int, int)
*/
public Matrice(int n){
this.n=n;
this.m=new int [n][n];
}
/** Deuxieme constructeur. Cree une matrice dont la taille et le contenu * sont donnes en parametre.
* @param n un entier pour la taille
* @param x un entier pour le contenu de chaque case
* @see Matrice#Matrice(int)
*/ …
Présentation de POO-Java - p. 33Philippe Canalda
2.1 Un exemple
public class Matrice {
private int n;
private int [][] m;
…
/** Deuxieme constructeur. Cree une matrice dont la taille et le contenu * sont donnes en parametre.
* @param n un entier pour la taille
* @param x un entier pour le contenu de chaque case
* @see Matrice#Matrice(int)
*/
public Matrice(int n, int x){
this.n=n;
this.m=new int[n][n];
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
this.m[i][j]=x;
} …
Présentation de POO-Java - p. 34Philippe Canalda
• Fin 2ème coursprises de notes :
• TD – prises de notes– Td1– Td2
• TP – prises de notes– A– B– C
Présentation de POO-Java - p. 35Philippe Canalda
2.1 Un exemple
public class Matrice {
private int n;
private int [][] m;
…
/** Methode de transposition de matrice
*/
public void transposer(){
for(int i=0; i<n; i++)
for(int j=i+1; j<n; j++) {
int t=this.m[i][j]; this.m[i][j]=this.m[j][i];
this.m[j][i]=t;
}
}
/** Methode d’affichage d ’une matrice
*/
…
Présentation de POO-Java - p. 36Philippe Canalda
2.1 Un exemplepublic class Matrice {
private int n;
private int [][] m;
…
/** Methode d ’affichage d ’une matrice
*/
public String toString(){
StringBuffer sb = new StringBuffer();
for(int i=0; i<n; i++)
for(int j=0; j<n; j++) {
sb.append(m[i][j]);
sb.append(« »);
}
sb.append(« \n»);
}
return sb.toString();
}
/** Methode principale */
…
}
Présentation de POO-Java - p. 37Philippe Canalda
2.1 Un exemple
public class Matrice {
private int n;
private int [][] m;
…
/** Methode principale
* @param args arguments de la ligne de commande
*/
public static void main(String[] args){
Matrice a = new Matrice(3,12);
System.out.print(a);
Matrice b = new Matrice(3);
System.out.print(b);
}
Question : Générez la documentation HTML et visualisez-la au moyen de votre navigateur préféré.
Présentation de POO-Java - p. 38Philippe Canalda
2.1 FractalesPrincipe : objets définis récursivement.
Exemple : la courbe du dragon de Heighway, qui est donnée par l ’applette suivante :import java.awt.*;
import java.applet.*:
public class Dragon extends Applet {
public void paint(Graphics g) {
g.setColor(Color.red);
drawDragon(g,20,100,100,200,200);
}
private void drawDragon(Graphics g, int n, int x, int y, int z, int t) {
int u,v;
if (n==1)
g.drawLine(x, y, z, t);
else {
u = (x + z + t - y) / 2;
v = (y + t - z + x) / 2
drawDragon(g, n-1, x, y, u, v);
drawDragon(g, n-1, z, t, u, v);
}
}
}
Présentation de POO-Java - p. 39Philippe Canalda
2.1 Exécution d ’une appletteOn crée un fichier DessinDragon.html contenant :
<HTML>
<HEAD>
<TITLE> Courbe du dragon </TITLE>
</HEAD>
<BODY>
<APPLET CODE=« Dragon.class » WIDTH=400 HEIGHT=400> </APPLET>
</BODY>
</HTML>
On ouvre ensuite ce fichier sous Netscape ou bien directement par
appletviewer DessinDragon.html
Présentation de POO-Java - p. 40Philippe Canalda
2.1 Le dragon documentéimport java.awt.*;import java.applet.*:public class Dragon extends Applet {
/** * Methode de dessin du dragon. * </BR> * On obtient le dessin suivant : * </BR> * <APPLET> CODE=« Dragon.class » WIDTH=300 HEIGHT=300> </APPLET> */public void paint(Graphics g) {
g.setColor(Color.red);drawDragon(g,20,100,100,200,200);
}private void drawDragon(Graphics g, int n, int x, int y, int z, int t) {
int u,v;if (n==1)
g.drawLine(x, y, z, t);else {
u = (x + z + t - y) / 2;v = (y + t - z + x) / 2drawDragon(g, n-1, x, y, u, v);drawDragon(g, n-1, z, t, u, v);
}}
}
Présentation de POO-Java - p. 41Philippe Canalda
2.2 Le langage Java
Java est dérivé de Kawa. Créé en 1995, la version actuelle est la 1.5
Java
• est fortement typé
• est orienté objet
• est compilé-interprété
• intègre des threads ou processus légers
• est sans héritage multiple MAIS avec implémentation multiple d’interfaces
• offre DORENAVANT de la généricité à la manière des templates de C++ (classes paramétrées)
Compilation - Interprétation
• Source compilé en langage intermédiaire (byte code) indépendant de la machine cible
• Byte code interprété par une machine virtuelle Java dépendant de la plate-forme
Présentation de POO-Java - p. 42Philippe Canalda
• Notes élaborées par David et Dhaya
• 1h30
Présentation de POO-Java - p. 43Philippe Canalda
2.2 Le langage Java
Avantages :
+ L ’exécution peut se faire en différé et/ou ailleurs, par téléchargement
+ Plus de mille classes prédéfinies qui encapsulent des mécanismes de base :
• structures de données : vecteurs, listes, ensembles ordonnés, arbres, tables de hachage, grands nombres
• outils de communication, comme les url, client-serveur
• facilités audiovisuelles, pour images et son
• des composants d ’interface graphique
• traitements de fichiers
• accès à des bases de données
Présentation de POO-Java - p. 44Philippe Canalda
2.3 Structure d ’1 programme
class HelloWorld {
public static void main(String[] args) {
System.out.println(« Hello World ! »);
}
}
Programme Java : constitué d ’un ensemble de classes
• groupées en paquetage (packages)
• réparties en fichier
• chaque classe compilée est dans son propre fichier (un fichier dont le nom est le nom de la classe suffixée par .class)
Un fichier source java comporte :
• des directives d ’importation commeimport java.io.*;
• des déclarations de classes
…
Présentation de POO-Java - p. 45Philippe Canalda
Une classe est composée de :
• déclaration de variables (attributs) // appelées parfois variables de classe
• définition de fonctions (méthodes)
• déclaration d ’autres classes (nested classes)
• les membres sont– des membres de classe (static)
– des membres d ’objet (ou d ’instance)
Une classe a 3 rôles :
1- de typage, en déclarant de nouveaux types
2- d ’implémentation, en définissant la structure et le comportement d ’objet
3- de moule pour la création de leurs instances
Une méthode se compose :
• des déclarations de variables locales ;
• d ’instructions
Les types des paramètres et le type de retour constituent la signature de la méthode.
Static int pgcd(int a, int b) {
return (b==0) ? a : pgcd(b, a%b);
}
Présentation de POO-Java - p. 46Philippe Canalda
Point d ’entrée : Une fonction spéciale est appelée à l ’exécution .
Elle s ’appelle toujours main et a toujours la même signature :
public static void main(String[] args) { … }
Toute méthode, toute donnée fait partie d ’une classe (pas de variables globales). L ’appel se fait par
déréférencement d ’une classe ou d ’un objet d ’une classe, de la façon suivante :
• Méthodes ou données de classe : par le nom de la classe.Math.cos() Math.PI
• Méthodes ou données d ’un objet : par le nom de l ’objet.Pile P;int x=2;…p.push(x);
• L ’objet courant est nommé this et peut-être sous-entendu s ’il n’y a pas d ambiguïté de visibilité.public void setX(int x) { this.x=x;}
• La classe courante peut-être sous-entendue pour des méthodes statiques.System.out.println()avec out, un membre statique de la classe System, et également un objet de la classe PrintStreamavec println, une méthode d ’objet de la classe PrintStream.
Présentation de POO-Java - p. 47Philippe Canalda
2.4 Expressions, types, variablesToute expression a une valeur et un type. Les valeurs sont :
• les valeurs de base
• les références, à des tableaux ou à des objets
Un objet ne peut être manipulé en Java, que par une référence.
Une variable est le nom d ’un emplacement mémoire qui peut contenir une valeur. Le type de la variable décrit la
nature des valeurs de la variable.
• Si le type est un type de base, la valeur est de ce type.
• Si le type est une classe, la valeur est une référence à un objet de cette classe, ou d ’une classe dérivée.
Exemple :Point p;
déclare une variable de type Point, susceptible de contenir une référence à un objet de cette classe.
P=new Point(4,6);
L ’évaluation de l ’expression new Point(4,6) retourne une référence à un objet de la classe Point. Cette référence est affectée à p.
Présentation de POO-Java - p. 48Philippe Canalda
Passage de paramètresToujours par valeur, ou bien par référence implicite.
Exemple : soit la méthode
static int plus(int a, int b) {
return a+b;
}
A l ’appel de la méthode, par exemple int c=plus(a+1,7), les paramètres sont évalués, des variables formelles (locales à la méthode-fonction) sont initialisées avec les valeurs des paramètres-expressions réels. Des occurrences des paramètres formels sont ainsi remplacées par des variables locales correspondantes.
Par exemple,
int aLocal=a+1;
int bLocal=7;
int résultat=aLocal+bLocal;
Attention ! Les objets ou tableaux sont manipulés par des références. Un passage par valeur d ’une référence est donc comme un passage par référence. Si la valeur-référence ne sera pas modifiée, les valeurs membres de l ’objet référencé peuvent, elles, être modifiées et cela impacte le programme appelant.
Exemple :
static void incrementer(Point a){ a.x++; a.y++}
Après l ’appel de incrementer(b), les coordonnées du point b sont incrémentées.
Présentation de POO-Java - p. 49Philippe Canalda
2.5 Types de base (primitifs)
A noter :
• Les caractères sont codés sur 2 octets en unicode.
• Les types sont indépendants du compilateur et de la plate-forme.
• Tous les types numériques sont signés sauf les caractères.
• Un booléen n ’est pas un nombre
• Les opérations sur les entiers se font modulo et sans erreur :byte b = 127;b += 1; // b = -128
Nom Taille ExemplesByte 8 1, -128, 127
Short 16 2, 300
Int 32 234569876
Long 64 2L
Float 32 3.14, 3.1E12, 2e12
Double 64 0.5d
Boolean 1 True ou false
Char 16 ‘a’, ‘\n’, ‘\u0000’
Présentation de POO-Java - p. 50Philippe Canalda
Une variable se déclare en donnant d ’abord son type.
int i, j =5;
float re, im;
boolean termine;
static int numero;
static final int N = 12;
A noter :
• Une variable peut-être initialisée
• Une variable static est un membre de classe.
• Une variable final est une constante.
• Tout attribut de classe est initialisé par défaut, à 0 pour les variables numériques, à false pour les booléennes, à null pour les références.
• Dans une méthode, une variable doit être déclarée avant utilisation. Elle n ’est pas initialisée par défaut.
• Dans la définition d ’une classe, un attribut peut-être déclaré après son utilisation.
Présentation de POO-Java - p. 51Philippe Canalda
ExpressionsComme en C ou C++ :
radians = (degres/180) * Math.PI // conversion de degrés en radians
« Bonjour » + « Monde »; // string
(i != 0) && (i % 2 == 0) // boolean, entier non null paire
x = x +1;
++i i++ --j j--
j += 2; // j = j+2
j += j; // j = j + j
max = (a > b) ? a : b;
(x % 2 == 1)? 3*x+1 : x/2;
Présentation de POO-Java - p. 52Philippe Canalda
TableauxC ’est un objet particulier. L ’accès se fait par référence et la création par new. Un tableau :
• se déclare,
• se construit (s ’alloue et s ’initialise)
• et s ’utilise.
L ’identificateur de type tableau se déclare par :int[] a; // vecteur d ’entiers
double[][] m; // matrice de doubles
-> La déclaration des tableaux comme en C ou C++ est acceptée :int a[]; double m[][];
Construction d ’un tableau par new :a = new int[n];
m = new double [n][p]; // n lignes, p colonnes
Utilisation traditionnelleint i, j;
m[i][j]=x; // ligne i, colonne j
for(i = 0; i < a.length; i++)
System.out.print( a[i] );
Présentation de POO-Java - p. 53Philippe Canalda
Utilisation traditionnelleint i, j = 45;
m[i][j]=x; // ligne i, colonne j
int [] a = new int[j];
for(i = 0; i < a.length; i++)
System.out.print( a[i] );
Tout tableau a un attribut length qui donne sa taille à la création.
Distinguer :
• la déclaration, qui concerne la variable dont le contenu sera une référence sur un tableau,
• de la construction, qui crée l ’espace mémoire du tableau et retourne une référence sur cet espace mémoire de ce tableau.
On peut fusionner déclaration et construction par initialisation énumérative :String[] jours = {«Lundi», «Mardi», «Mercredi», «Jeudi», «Vendredi», «Samedi»,
«Dimanche»};
Les instructions suivantes provoquent toujours une exception de la classe ArrayIndexOutOfBoundsException :a[a.length],
a[-1];
Présentation de POO-Java - p. 54Philippe Canalda
Exercice prise en main du langage
• Syntaxe– i) Ecrire 2 façons de déclarer et d’initialiser 1 tableau
contenant les 10 premiers entiers– ii) Ecriture du programme qui manipulera a et b et qui
affichera leurs contenus.
Présentation de POO-Java - p. 55Philippe Canalda
Exercice prise en main du langage
• i) public class Test {– public static void main(String [] args){
int [] a={1,2,3,4,5,6,7,8,9,10};int [] b=new int[10];for(int i=0; i < b.length;i++){ b[i]=i+1;}}
Présentation de POO-Java - p. 56Philippe Canalda
Exercice prise en main du langage
• ibis) // autre manière plus capilo-tractéePublic class Test {– Public static void main(String [] args){
int [] a={1,2,3,4,5,6,7,8,9,10};int [] b=new int[10];for(int i=0; i < b.length;){ b[i]=++i;}}
Présentation de POO-Java - p. 57Philippe Canalda
Exercice prise en main du langage• ii) // Dans Test.java
public class Test { Public static void main(String [] args){ int [] a={1,2,3,4,5,6,7,8,9,10}; int [] b=new int[10]; for (int i=0; i < b.length;){ b[i]=++i; } /* l’affichage dans le cas ou a et b sont de la même taille */ for (int i=0; i<a.length;i++){ System.out.println(‘’a[‘’+ i + ‘’] =’’ + a[i] + ‘’;’’); } }}
Présentation de POO-Java - p. 58Philippe Canalda
Exercice prise en main du langage• ii-bis) // Dans Test.java
public class Test { Public static void main(String [] args){ int [] a={1,2,3,4,5,6,7,8,9,10}; int [] b=new int[10]; for (int i=0; i < b.length;){ b[i]=++i; } /* l’affichage dans le cas ou a et b ne sont pas forcément de la même taille */ for (int i=0; i< (a.length<b.length?b.length:a.length);i++){ if (i<a.length){System.out.println(a[i])} if (i<b.length){System.out.println(b[i])}
} }}
Présentation de POO-Java - p. 59Philippe Canalda
Exercice surcharge
– Modifier la classe Array, de façon à ce que l’on affiche le contenu d’1 tableau t simplement par l’appel de :
System.out.println(t);
Présentation de POO-Java - p. 60Philippe Canalda
Exercice surcharge– public class Array {
// tout un ensemble d’attr privés : exemple la collection des éléments // si Array a=new Array(type, taille); // j’y accède par a[i] … … public int length; // contient la taille de l’instance de ce tableau … public Array(Object o, int taille){ this.collection=new o.classname [taille]; // il faut faire un eval de la commande précédente,
// seulement un éval d’une commande n’est pas triviale à réaliser en java (plus aisé en javascript, actionScript, // ou tout autre langage interprété) } public String toString(){ StringBuffer sb = new StringBuffer(); for (int i=0; i<this.length;i++){ sb.append(this.collection[i].toString()); } return sb.toString(); }
}
Présentation de POO-Java - p. 61Philippe Canalda
Rmq - Exercice surcharge
– Comment réaliser la surcharge ?• Par des design pattern qui réalisent l’introspection et la modification dynamique
des classes et composants des classes (attr ou primitives) ;
• Dansla version Tigre du langage, et tigre désigne la prochaine version du langage Java, il y aura la généricité et les macros.Ce n’est pas hasardeux de retrouver ces 2 évolutions majeures au sein d’une même version. En fait la macro permet de réaliser l’eval(nouvelle expression);. Ce faisant on réalise alors la généricité. Généricité étant le concept auquel nous nous sommes attaqués au travers de l’exercice ARRay précédent ;)
Présentation de POO-Java - p. 62Philippe Canalda
MatricesLes tableaux sont dynamiques dans toutes les dimensions (la mémoire peut -être allouée dynamiquement ).
/**
* Classe permettant de manipuler des matrices
* @author Canalda
* @version 1.0
*/
public class Matrice {
private int[][]m;
/**
* Creation d ’une matrice nulle dont la taille est donnee en parametre.
* @param n taille de la matrice
* @see Matrice#Matrice(int,int)
*/
public Matrice(int n){
this.m = new int[n][n]; // de façon equivalente this(n,0)
};
Présentation de POO-Java - p. 63Philippe Canalda
/** * Creation d ’une matrice dont la taille et le contenu sont donnes en parametre.
* @param n taille de la matrice
* @param x valeur de chaque coefficient
* @see Matrice#Matrice(int)
*/
public Matrice(int n, int x){
this.m = new int[n][n];
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
this.m[i][j]=x;
};
/**
* Transposition de matrice
*/
void Transposer(){
int n = m.length;
for(int i=0; i<n; i++) {
for(int j=i+1; j<n; j++) {
int t = m[i][j];
m[i][j] = m[j][i];
m[j][i] = t;
}
}
}
Présentation de POO-Java - p. 64Philippe Canalda
/** * Affichage d ’une matrice.
*/
public String toString(){
int n = m.length;
StringBuffer sb = new StringBuffer();
for(int i=0; i<n; i++){
for(int j=0; j<n; j++)
sb.append(m[i][j] + « »);
sb.append(« \n »);
};
return sb.toString;
};
/**
* Methode principale
* @param args arguments de la ligne de commande
*/
public static void main(String[] args){
Matrice a = new Matrice(3,12);
System.out.print(a);
Matrice b = new Matrice(3);
System.out.print(b);
}
}
On obtient :$java Matrice12 12 1212 12 1212 12 120 0 00 0 0 0 0 0
Présentation de POO-Java - p. 65Philippe Canalda
InstructionsAffectation, instructions conditionnelles, aiguillages, itérations usuelles.
Affectation :x = 1; y = x = x+1;
Instructions conditionnellesif (C) S;
if (C) S; else T;
Itérations :while (C) S;
do S while (C);
for(E;C;G) S;
Une instruction break; fait sortir du bloc où elle se trouve.
Présentation de POO-Java - p. 66Philippe Canalda
Traitement par cas :
switch(C) {
case ‘ ’:
nEspaces++; break;
case ‘0’: case ‘1’: case ‘2’: case ‘3’: case ‘4’: case ‘5’: case ‘6’: case ‘7’: case ‘8’: case ‘9’:
nChiffres++; break;
default :
nAutres++;
}
Blocs à étiquettesun: while (...){
…
deux: for(){
…
trois: while (…){
…
if (…) continue un; // reprend while extérieur
if (…) break deux; // quitte boucle for
continue: // reprend while intérieur
}
}
}
Présentation de POO-Java - p. 67Philippe Canalda
• Mathieu Brousse à pris les notes du CM5
Présentation de POO-Java - p. 68Philippe Canalda
Question : Dans le cas d’1 for intégrant un continue, y-a-til reprise à l’itération courante ou bien à l’itération suivante ?
Ecrire un petit programme qui vous permet de le vérifier
Attention, il pourrait y avoir des risques de boucles infinies ?
Présentation de POO-Java - p. 69Philippe Canalda
MéthodesChaque classe contient une suite non emboîtée de méthodes. Mais si on ne peut pas définir des méthodes à
l ’intérieur de méthodes, on pourra définir des classes à l’intérieur des classes.
static int next(int n){
if (n % 2 == 1) // n est impair
return 3*n +1;
// n est pair
return n/2;
}
static int pgcd(int a, int b){
return (b == 0) ? A : pgcd(b, a%b);
}
Une méthode qui ne retourne pas de valeur a pour type de retour le type void.
Présentation de POO-Java - p. 70Philippe Canalda
SurchargeOn distingue :
• Profil : le nom + la suite des types des arguments
• Signature : le type de retour + le profil
• Signature complète : signature + la visibilité (private, protected, public ou rien).
• Signature étendue : signature complète + les exceptions
Un même identificateur peut désigner des méthodes différentes pour autant que leurs profils soient distincts.
static int fact(int n, int p){
if (n == 0) // condition d ’arrêt du prg récursif
return p;
else // mot clef facultatif
return fact(n-1, n*p);
};
static int fact(int n){
return fact(n,1);
}
Il n ’y a pas de valeurs par défaut. Il faut donc autant de définitions qu’il y a de profils.
Présentation de POO-Java - p. 71Philippe Canalda
Visibilité des attributs et méthodesLes membres (attributs ou méthodes) d ’une classe ont une visibilité définie par défaut et ont des modificateurs de
visibilité :• public• protected• private
Par défaut, une classe a ses données ou méthodes accessibles dans le répertoire, plus précisément dans le paquetage (cf. + loin).
Un attribut (donnée ou méthode) • public est accessible dans tout code où la classe est accessible.• protected est accessible dans le code des classes du même paquetage et dans les classes dérivées de la
classe.• Private n ’est accessible que dans le code de la classe.
La méthode main doit être accessible de la machine virtuelle, elle doit donc être public.
Présentation de POO-Java - p. 72Philippe Canalda
ConstructeursLes objets sont instanciés au moyen de constructeurs. Toute classe a un constructeur par défaut, sans argument. Lors de la
construction d ’un objet, l ’opérateur new réserve la place mémoire pour l ’objet et initialise les attributs à leur valeur par défaut.
Le constructeur• exécute le corps de la méthode,• et retourne la référence de l ’objet créé.
Exemple avec seulement le constructeur par défaut :
class Pixel{
int x, y;
}
Utilisation :
class TestPixel{
public static void main(String[] args){
Pixel p; // p est déclaré, mais indéfini
p = new Pixel(); // p != null, p.x = p.y = 0
p.x = 4;
p.y = 5;
…
}
}
Présentation de POO-Java - p. 73Philippe Canalda
Exemple avec un constructeur particulier :class Pixel{
int x, y;
Pixel(int x, int y){
this.x=x; this.y=y;
};
public static void main(String[] args){
Pixel p, q; // p et q sont déclarés, mais indéfinis, p = q = null
p = new Pixel(2,3); // p != null, p.x=2, p.y=3
q = new Pixel(); // erreur
…
};
}
La définition explicite d ’un constructeur fait disparaître le constructeur par défaut implicite. Si on veut garder le constructeur par défaut, il faut alors le déclarer explicitement :class Pixel{
int x, y;
Pixel(){};
Pixel(int x, int y){
this.x=x; this.y=y;
};
public static void main(String[] args){
Pixel p, q; // p et q sont déclarés, mais indéfinis, p = q = null
p = new Pixel(2,3); // p != null, p.x=2, p.y=3
q = new Pixel(); // OK
…
}
}
Présentation de POO-Java - p. 74Philippe Canalda
Les données d ’un objet peuvent être des (références d ’) objets.class Segment{
Pixel debut, fin;
}
Utilisation : public static void main(String[] args){
Segment s; // s indéfini
s = new Segment(); // s != null, s.debut = s.fin = null
…
}
Plusieurs constructeurs pour la même classe :class Segment{
Pixel debut, fin;
Segment(){};
Segment(Pixel d, Pixel f){
this.debut=d; this.fin=f;
}
Segment(int dx, int dy, int fx, int fy){
this.debut=new Pixel(dx,dy); this.fin=new Pixel(fx,fy);
}
}
Noter que
• dans le 2ème constructeur, on affecte à debut et à fin les références d ’objets existants
• dans le 3ème constructeur, on crée des objets à partir de données de base, et on affecte leurs références.
Présentation de POO-Java - p. 75Philippe Canalda
Exemples d ’emploi :
public static void main(String[] args){
Segment s; // s indéfini
s = new Segment(); // s.debut = s.fin = null
s.debut = new Pixel(2,3);
s.fin = new Pixel(5,8);
Pixel p = new Pixel(2,3); Pixel q = new Pixel(5,8);
Segment t = new Segment(p,q);
Segment tt = new Segment(new Pixel(2,3), new Pixel(5,8));
Segment r = new Segment(2,3,5,8);
}
Présentation de POO-Java - p. 76Philippe Canalda
Membres et méthodes statiquesLes attributs peuvent être
• des attributs de classe (static),
• des attributs d ’objets (ou d ’instance).
Les attributs de classe static sont partagés par tous les objets de la classe. Il n ’en existe qu’un par classe au lieu de un pour chaque instance ou objet d ’une classe lorsqu’il s ’agit de membre d ’objets.
Exemple d ’attributs static :
• un compteur du nombre d ’objets (instances) de la classe,
• un élément particulier de la classe, par exemple une origine.
class Point{
int x, y;
static Point origine = new Point(0,0);
}
Les méthodes peuvent aussi être ou ne pas être static.
Les méthodes static sont invoquées en donnant le nom de la classe ou bien le nom d ’une instance de classe. Une méthode static ne peut pas faire référence à this.
Elles sont utiles pour fournir des services (helper).
Méthodes de la classe Math.
Présentation de POO-Java - p. 77Philippe Canalda
Exemples 1
public class Chrono{
private static long start, stop;
public static void start(){
start = System.currentTimeMillis();
}
public static void stop(){
stop = System.currentTimeMillis();
}
public static long getElapsedTime(){
return stop - start;
}
Et on s ’en sert de la manière suivante :
class TestChrono{
public static void main(String[] args){
Chrono.start();
for(int i=0;i<100000;i++)
for(int j=0;j<100000;j++);
Chrono.stop();
System.out.println(«Duree = » + Chrono.getElapsedTime());
}
}
Présentation de POO-Java - p. 78Philippe Canalda
Exemples 2
class User{
String nom;
static int nbUsers;
static User[] allUsers = new User[10];
User(String nom){
this.nom = nom;
allUsers[nbUsers++] = this;
}
void send(String message, User destinataire){
destinataire.handleMessage(message, this);
};
void handleMessage(String message, User expediteur){
System.out.println(expediteur.nom + « dit » + message + « à » + this.nom);
};
void sendAll(String message){
for(int i=0; i<nbUsers;i++){
if (allUsers[i] != this) send(message, allUsers[i]);
};
…
Présentation de POO-Java - p. 79Philippe Canalda
Exemples 2 (suite)
class User{
…
public static void main(String[] args){
User a=new User(« Pierre »), b=new User(« Anne »),
c=new User(« Alex »), d=new User(« Paul »);
a.send(« Bonjour », b);
b.senAll(« Hello »);
a.sendAll(« Encore moi »);
}
}
Donne à l ’exécution :
Pierre dit « Bonjour » à Anne
Anne dit « Hello » à Pierre
Anne dit « Hello » à Alex
Anne dit « Hello » à Paul
Pierre dit « Encore moi » à Anne
Pierre dit « Encore moi » à Alex
Pierre dit « Encore moi » à Paul
Présentation de POO-Java - p. 80Philippe Canalda
Chapitre « Les concepts objets »
• Passage vers l ’objet
Présentation de POO-Java - p. 81Philippe Canalda
Données de base
• Descriptionun type : entier, chaîne de car., réel, etcune valeur (12, « mon texte », 7.28)
• Inconvénientsensemble de types limitétypage statiquepas de notion de sous-typage
Type d ’une donnée = Ensemble des valeurs possiblespour cette donnée
Présentation de POO-Java - p. 82Philippe Canalda
Les produits cartésiens
• Principe– définir les données comme produit cartésien d ’autres données
ex : entier x entier x chaine
– un Prod_Cart (ou enregistrement) = 1 n-upletex : (10, 20, « rose ») représente un point de l ’écran ((« Durand », « Paul »), (« Durand », « Anne »)) représente un couple
• Réutilisation– utilisation d ’un constructeur de type produit cartésien
• un nom pour le type
• ensemble de champs nommés et typés
Présentation de POO-Java - p. 83Philippe Canalda
Produits cartésiens : exemple
• Introduction d ’un type « livre »TYPE t_livre = PROD_CART ( titre: chaine auteur : chaine éditeur : chaîne année de parution : date nombre de page : entier prix : réel)
• Utilisation– si RefProlog donnée de type livre, alors RefProlog.titre désigne son titre
(et vaut « The Art of Prolog »)
Présentation de POO-Java - p. 84Philippe Canalda
Notion de classe et d’objet
• Comparaison : – type => classe– Donnée/variable => Objet
(instance d ’un type) (instance d ’une classe)
– champ => champ et une fonction est éligible à être un champ
• Exemple :– RefProlog serait un objet de classe livre
Présentation de POO-Java - p. 85Philippe Canalda
Classes et types : premières différences• Type
– point de vue statique => les champs
• Classe :– Point de vue statique : état
• les champs (avec valeur par défaut éventuelle)
• les propriétés ou contraintes
– Point de vue dynamique : changements d ’états• les méthodes (définies au niveau de la classe, mais
s ’appliquent sur les objets de cette classe), avec d ’éventuelles pré-conditions et post- conditions
Présentation de POO-Java - p. 86Philippe Canalda
Classes : un exemple
Personne
Nom : chaînePrénom : chaîneDateDeNaissance : t_dateSituationDeFamille : TYPE enuméré = (‘ célibataire ’, …)Sexe : (‘ M ’, ‘ F ’)
créer(nom,prénom,date,sexe) // surchargecréer(nom,prénom,date,sexe,situation)ModifierSituation(NouvelleSituation)
Sexe=‘ M ’ ou ‘ F ’ Nom <> « »
Rmq: si toto est un objet de classe personne, Modifier la situation de toto se fait par toto.ModifierSituation(« Marié »)
Présentation de POO-Java - p. 87Philippe Canalda
Vie et mort d ’un objet
• Un objet :– naît– vie– meurt
• Par classe 3 types de méthodes :– constructeurs– destructeurs– … les autres
=> rien n’est possible sur un objet non créé=> rien n’est possible sur un objet détruit
Présentation de POO-Java - p. 88Philippe Canalda
Persistance d ’un objet
• Mort d ’un objet classique :– appel de son destructeur
– arrêt du système qui l’a créé
• Inconvénients :– panne
– maintenance
– évolution=> Notion d ’objet persistant Un objet persistant est on objet dont l’existence continue après l ’arrêt du système qui l ’a créé
Présentation de POO-Java - p. 89Philippe Canalda
Variables et méthodes de classe
• Cas général :– champs propre à un objet
– impossibilité à des objets d’une même classe de partager des données
• => variables d ’une classe– même donnée pour tous les objets de la classe
• => méthodes de classe– ne s ’appliquent pas particulièrement à un objet
=> à voir comme des fonctions de bibliothèques
Présentation de POO-Java - p. 90Philippe Canalda
Vers la réutilisabilité
• => Comment factoriser les parties communes ?
Elève
Nom Prénom
créer(nom,prénom)
Personnel
Année d’étude
créer(nom,prénom,annéeEtude)changerAnnéeDEtude(année)
Nom Prénom
créer(nom,prénom)
Fonction
créer(nom,prénom,fonc)changerFonction(fonc)
Parties différentes
Parties communes
Présentation de POO-Java - p. 91Philippe Canalda
Héritage : introduction
• Vocabulaire :• Elève hérite/est une sous-classe/est une spécialisation de Personne
• Personne est une généralisation/super-classe d’Elève
• On emploie aussi les termes de classe mère et de classe fille
Elève : Personne Personnel : Personne
Année d’étude
créer(nom,prénom,annéeEtude)changerAnnéeDEtude(année)
Fonction
créer(nom,prénom,fonc)changerFonction(fonc)
Personne
Nom Prénom
créer(nom,prénom)
Représentations possibles
Présentation de POO-Java - p. 92Philippe Canalda
Héritage et sous-typage
• Autre lecture de la relation d ’héritage :• un objet d ’une classe fille est un objet de la classe mère
=> Tout objet d’un type d’une classe fille peut-être utilisé à la place d’un objet du type d’une classe mère
• Sur l ’exemple : créer peut s ’appliquer pour un élève ou pour le personnel
! La réciproque n ’est pas vraie
Présentation de POO-Java - p. 93Philippe Canalda
Redéfinition et liaison dynamique• Principe de la liaison dynamique :
La méthode périmètre de la classe Quadrilatère est redéfinie dans Losange.
Soit P de type Parallélogramme, L de type Losange et Q de type Quadrilatère :
Q <- P.Périmètre() calcule l1+l2+l3+l4
Q <- L.Périmètre() calcule 4*l1
Parallélogramme : Quadrilatère Losange:Quadrilatère
périmètre() {Périmètre=4*l1}
Quadrilatère
l1, l2, l3, l4 : réels
périmètre() { périmètre=l1+l2+l3+l4}créer(p1,p2,p3,p4)
Présentation de POO-Java - p. 94Philippe Canalda
Classes et méthodes abstraites
• Une classe abstraite C est une classe dont les seuls objets qui peuvent en être membres sont membres d’une sous-classe de C.
• Corollaire : il n ’est pas possible de créer un objet de classe C si C est une classe abstraite
• Une méthode abstraite est une méthode dont la définition n’est pas donnée dans la classe courante mais devra l’être dans des classes filles
• Toute classe contenant au moins une méthode abstraite est une classe abstraite
Présentation de POO-Java - p. 95Philippe Canalda
Classes et méthodes abstraites
• Exemple :– Classe abstraite Point {
privé x, y : ENTIER Point(){}; Point(Valx, Valy : ENTIER) { // constructeur à 2 this.x <- Valx ; // paramètres this.y <- Valy; } public procédure setX(Valx : ENTIER); // deux méthodes public procédure setY(Valy : ENTIER); // abstraites};
Présentation de POO-Java - p. 96Philippe Canalda
Héritage : disjonction ou recouvrement
• Si un même objet ne peut pas être membre de plusieurs sous-classes d ’une même classe, on parle d ’héritage disjoint
ŒUVRE d ’art
Tableau Morceau de musique
Présentation de POO-Java - p. 97Philippe Canalda
Héritage : disjonction ou recouvrement
• Sinon on parle d ’héritage avec recouvrement
Bâtiment
Professionnel Habitation
Présentation de POO-Java - p. 98Philippe Canalda
Héritage multiple
• Il y a héritage multiple si une classe peut hériter de plusieurs autres classes
impossible avec Java
ŒUVRE d ’art
Livre auteur texte
Morceau de musique compositeur partition
Présentation de POO-Java - p. 99Philippe Canalda
Héritages propriétés
• Transitivité• Si A hérite de B et B hérite de C alors A hérite de C
• Non réflexif• Une classe ne peut pas hériter d’elle même
• Non symétrique• Si A hérite de B alors B ne peut pas hériter de A
• Corollaire• Un cycle dans une relation d ’héritage est impossible. Les relations
d’héritages forment un DAG (Graphe dirigé acyclique)
Présentation de POO-Java - p. 100Philippe Canalda
Classes et méthodes terminales
• Une classe terminale est une classe dont aucune classe ne peut hériter.
• Une méthode terminale est une méthode qui ne peut pas être redéfinie.
• Un champ terminal d’une classe est une constante.
Présentation de POO-Java - p. 101Philippe Canalda
Liens entre classe
• Comment ?• Par les champs,
en déclarant un champ de classe A dans une classe B
• Dans les méthodes,en déclarant une variable de classe A dans une méthode de la classe B
• Par la définition explicite d’une relationexemple :
Enseignant Matière
nom prénom
nom volume horaire
Présentation de POO-Java - p. 102Philippe Canalda
Agir sur un objet d’une classe liée• Actions possibles
• lire la valeur d ’un champ : – destination <- nom_objet.nom_champ
• modifier un champ– nom_objet.nom_champ <- nouvelle_valeur
• exécuter une méthode– [résultat <- ] nom_objet.nom_méthode([paramètre d ’entrée]*)
• Remarques• le symbole d ’affectation est ici <-• le texte entre crochet est optionnel et * signale 0 itération
ou n itérations
Présentation de POO-Java - p. 103Philippe Canalda
Actions sur objet : constat
• Rôle des méthodes– factoriser du code commun
– avoir un typage plus fort (ne s’applique que sur les objets de la classe C dans laquelle elle est définie, ou d’une classe héritant de C)
– n’autoriser que certains changements d’états sur un objet
• Mais– possibilité d’intervenir directement depuis l’« extérieur » sur un
champ d’une méthode (annule le dernier point)
– n’est pas adapté à la réutilisabilité lorsque la représentation des données doit être modifiée (ex: ensemble de car ou d ’entiers)
Présentation de POO-Java - p. 104Philippe Canalda
Gestion des droits d ’accès
• Conséquence du constat précédent– pour chaque champ et chaque méthode, possibilité de définir des
droits d’accès pour les autres classes
DROIT dans C Dans lesclasses filles
Dans les au-tres classes
Public Oui Oui Oui
Privé Oui Non Non
Protégé Oui Oui Non
Présentation de POO-Java - p. 105Philippe Canalda
Encapsulation
• Définition : – modifier les champs d ’un objet n ’est possible que par
l ’intermédiaire des méthodes définies directement ou par héritage dans la classe de cet objet
• Principe :– les champs sont tous privés
– les méthodes mises à la disposition des autres classes sont déclarées publiquesNB : si la classe a vocation à être utilisée comme une classe mère, certains champs et méthodes pourront être protégés
Présentation de POO-Java - p. 106Philippe Canalda
Encapsulation
• Avantages :• n’autoriser que certains changements d’états pour un objet
• possibilité de modifier la représentation interne d ’une classe (les champs) sans devoir refaire tous les projets ou programmes qui utilisent la classe
• Conséquences : pour diffuser au public une classe, préciser :
• nom et rôle de la classe
• profiles et rôles des différentes méthodes publiques
• si nécessaire, rôle des champs et méthodes protégées
Présentation de POO-Java - p. 107Philippe Canalda
Réutilisation des structures de données• Problème
– liste d ’entiers• ajouter un élément(entier);
• enlever le premier élément;
• donner la longueur de la liste;
• trier numériquement les éléments de la liste ;
– liste de caractères• ajouter un élément(caractère);
• enlever le premier élément;
• donner la longueur de la liste;
• trier alphabétiquement les éléments de la liste ;
Parties différentes=>héritage inutilisable ...
Présentation de POO-Java - p. 108Philippe Canalda
Interface
• Définition• une interface est un ensemble nommé de profils de
méthodes
• Implantation• une classe implante une interface si elle :
• le déclare
• implante toutes les méthodes spécifiées dans l ’interface
• Utilisation• si une classe est reliée à un type d’interface donné, elle
peut être reliée à toute classe implantant cette interface
Présentation de POO-Java - p. 109Philippe Canalda
Généricité
• Principe : paramétrer une classe par une autre
=> Définition d ’un objet A : Liste <ENTIER>
• Généricité contrainte– but permettre l’utilisation d ’une fonction de la classe paramètre
Liste <OBJECT>ajouter un élémentenlever le premier élémentcalculer la longueur de la liste
ENTIER
Présentation de POO-Java - p. 110Philippe Canalda
Généricité contrainte : exemple
– A : Liste <booléen> impossible
– B : Liste <entier> possible, B.ordonner() trie numériquement
– C : Liste <chaîne> possible, C.ordonner() trie alphabétiquement
Liste <OBJECT -> ordre >ajouter un élémentenlever le premier élémentcalculer la longueur de la listeordonner la liste = faire un tri à bulle en utilisant la méthode
comparer définie sur les éléments
Booléenx : booléen
ENTIERx: entierbooléen comparer(y:entier)
CHAINEx:chainebooléen comparer(y:chaine)
Présentation de POO-Java - p. 111Philippe Canalda
2.6 Héritage : généralitésL ’héritage consiste à faire profiter tacitement une classe dérivée D des attributs et des méthodes d ’une classe de
base B.
• La classe dérivée possède les attributs de la classe de base (et peut y accéder sauf s ’ils sont privés).
• La classe dérivée possède les méthodes de la classe de base (même restriction).
• La classe dérivée peut déclarer de nouveaux attributs, et déclarer et définir de nouvelles méthodes
• La classe dérivée peut redéfinir des méthodes de la classe de base. La méthode redéfinie masque alors la méthode de la classe de base.
• Dérivation par extends• Toute classe dérive, directement ou indirectement de la classe Object.
• L ’arbre de dérivation est visible dans les fichiers créés par javadoc.
• La relation d ’héritage est transitive.
D
B
Présentation de POO-Java - p. 112Philippe Canalda
• Prises de notes CM6 : Foued, Huu Hoaï
Présentation de POO-Java - p. 113Philippe Canalda
class Base {
private int p=2;
int x=3, y=5;
public String toString(){return «B »+p+« »+x+« »+y;};
int somme(){return x+y;};
}
class Der extends Base{
int z=7;
public String toString(){return «D» »+p+« »+x+« »+y+« »+z;};
}
public class TestBase{
Base b=new Base();
Der d=new Der();
System.out.println(b);
System.out.println(b.somme());
System.out.println(d);
System.out.println(d.somme());
}
Le résultat est :$java TestBaseB 2 3 58D 2 3 5 78
Présentation de POO-Java - p. 114Philippe Canalda
UsagesUne classe dérivée représente
• une spécialisation de la classe de base.Mammifère dérive de vertébré, matrice symétrique dérive de matrice.
• un enrichissement de la classe de base.Un segment coloré dérive d ’un segment. Un espace vectoriel normé dérive d ’un espace vectoriel. Un article a un prix, un vêtement est un article qui a une taille. Un aliment est un article qui a une date de péremption.
Une classe de base représente des propriétés communes à plusieurs classes. Souvent c ’est une classe abstraite, c ’est à dire sans réalité propre, i.e. sans instance possible.
• une figure est une abstraction d ’un rectangle et d ’une ellipse.
• Un sommet est un nœud interne ou une feuille.
• Les mammifères eux-mêmes sont une abstraction.
• Un type abstraite de données est une abstraction d ’une structure de données.
Point épais : exemple de dérivation
class Point{
…
Présentation de POO-Java - p. 115Philippe Canalda
Point épais : exemple de dérivation
class Point{
private int x,y;
Point(int x,y){
this.x=x; this.y=y;
};
void translater(int dx, int dy) {
this.x+=dx; this.y+=dy;
};
public String toString(){
return(this.x+«, »+this.y);
}
}
class PointEpais extends Point{
int epaisseur;
PointEpais(int x, int y, int e){
super(x,y);
this.epaisseur=e;
}
...
...
public String toString(){
return super.toString()+«, »\ +this.epaisseur;
}
void epaissir(int i){
this.epaisseur+=i;
}
public static void main(String[]\ args)
{
PointEpais a=new \
PointEpais(3, 5, 1);
System.out.println(a); //3,5,1
a.translater(5,-2);
System.out.printl(a); //8,3,1
a.epaissir(5);
System.out.printl(a); //8,3,6
}
Présentation de POO-Java - p. 116Philippe Canalda
Dans l ’exécution d’un constructeur, le constructeur de la classe de base est exécuté en premier. Par défaut, c ’est le constructeur sans argument de la classe de base. On remonte récursivement jusqu’à la classe mère terminale Object.
L ’appel d ’un autre constructeur de la classe de base se fait au moyen de super(…). Cette instruction doit être la première dans l ’écriture du constructeur de la classe dérivée. En d ’autres termes, si cette instruction est absente, c est l ’instruction super() qui est exécutée en premier.
This et super• this et super sont des références sur l ’objet courant.
– Super désigne l ’objet courant avec le type père. Il indique que la méthode invoquée ou bien le membre d ’objet désigné doit être recherchée dans la classe de base.Il y a des restrictions d ’usage comme : f(super) qui est interdit, i.e. on ne peut pas passer cette fonctionnalité par paramètre.
– L ’usage de this et super sont spéciaux dans les constructeurs.
Présentation de POO-Java - p. 117Philippe Canalda
Destruction des objetsLa destruction des objets est effectuée :
• soit implicitement et automatiquement par le ramasse-miettes, de façon asynchrone, avec un processus léger (Thread) de basse priorité ;
• soit explicitement par la spécification et l ’invocation de la méthode finalize() qui permet de spécifier des actions à effectuer au moment de la destruction de l ’objet (opérations de nettoyage, fermeture des fichiers, etc.).
L ’appel au ramasse-miettes peut être forcé par l ’appel System.gc();
class Disque{
finalize(){
System.out.println(« Disque détruit »);
}
}
Présentation de POO-Java - p. 118Philippe Canalda
Délégationclass Point{
private int x,y;
Point(int x,y){
this.x=x; this.y=y; };
void translater(int dx, int dy) {
this.x+=dx; this.y+=dy;};
public String toString(){
return(this.x+«, »+this.y);}
}
class Disque{
Point centre;
int rayon;
Disque(int x, int y, int rayon){
this.centre=new Point(x,y);
this.rayon=rayon;
}
public String toString(){
return centre.toString+« ,»+rayon;
}
void translater(int dx, int dy){
centre.translater(dx,dy);//délégation
}
finalize(){
System.out.println(« Disque détruit »);
}
}
class TestDisque{
public static void main(String[] args){
Disque d =new Disque(3,5,1);
System.out.println(d);//3,5,1
d.translater(5,-2);
System.out.println(a);//8,3,1
}
}
Présentation de POO-Java - p. 119Philippe Canalda
RedéfinitionUne méthode redéfinie est une méthode d ’une classe dérivée qui a même signature que la méthode mère, i.e.
même :
• nom;
• suite des types de paramètres;
• type de retour.
De plus :
• Les exceptions levées doivent aussi être levées par la méthode de la classe mère, et être au moins aussi précise (règle logicielle);
• la visibilité de la méthode doit être au moins aussi bonne que celle de la méthode de la classe mère (pas de restriction de visibilité).
En cas de redéfinition, la méthode invoquée est déterminée dynamiquement en fonction du type de l ’objet à la création. Ce mécanisme est appelé liaison tardive. (exemple de la location de voitures et de camions).
En cas de redéfinition, la méthode de la classe de base n ’est plus accessible à partir de l ’objet appelant : la méthode de la classe de base est masquée.
Présentation de POO-Java - p. 120Philippe Canalda
Exemple :
public class Alpha{
void essai(Alpha a){
System.out.println(« alpha »);}
}
public class Beta extends Alpha{
void essai(Beta b){
System.out.println(« beta »);}
public static void main(String[]\
args){
Beta b=new Beta();
Alpha c=new Alpha();
b.essai(c);
}
}
public class Gamma extends Beta{
void essai(Alpha a){
System.out.println(« gamma »);}
public static void main(String[]\ args)
{
Beta d=new Gamma();
Alpha e=new Gamma();
d.essai(e);
}
}
On obtient :
$java Beta
alpha
$java Gamma
gamma
Présentation de POO-Java - p. 121Philippe Canalda
Le transtypageLe transtypage
• modifie le type de la référence à un objet;• n ’affecte que le traitement des références, c ’est-à-dire qu’il ne change jamais le type de l’objet ;
• est implicite ou explicite.
Principe de base :
Point s = new PointEpais(5,7,1);
Commentaires :
• cette règle fonctionne aussi si B est une interface et D implémente B;
• la relation est transitive;
• cette règle s’applique aussi aux paramètres d ’une méthode :pour C f(B b){…}l ’appel f(d) est possible si d est de classe D (qui dérive de B) ;
• cette règle s’applique également aux valeurs de retour d ’une méthode :pour r = f(b);si r est d ’une superclasse de C.
Présentation de POO-Java - p. 122Philippe Canalda
Le transtypage explicite d’une référence n’est valide que si l’objet sous-jacent est d’une classe dérivée :
Point s = new PointEpais(5,7,1);
PointEpais t;
t=s; // Erreur
t=(PointEpais) s; // Ok
Types et classes ne sont pas la même chose :
• « Variables have type, objects have class »;
– un objet ne change jamais de classe
– les références peuvent changer de type
• la vérification des types est statique (à la compilation);
• la détermination de la méthode à invoquer est dynamique (à l ’exécution).
Intérêt du transtypage
Si une variable x de type B contient une référence à un objet d’une classe dérivée D de B, seuls les attributs et les méthodes dont le nom est connu dans la classe B sont accessibles par la variable x.
Si m est une telle méthode, l’appel de x.m() invoque la méthode m telle qu’elle est définie dans la classe de l’objet référencé par x. Ici, la méthode m telle qu’elle est définie dans D : c ’est le polymorphisme.
Le transtypage permet:
• l’encapsulation, en rendant inaccessible les détails de D;
• l ’abstraction, en utilisant des méthodes génériques qui sont spécialisées dans les classes dérivées.
Présentation de POO-Java - p. 123Philippe Canalda
Héritage : interfacesUne interface
• n ’a que des méthodes abstraites et tacitement publiques;
• et n ’a que des données static immuables (final).
Une interface sert à spécifier des méthodes qu’une classe doit avoir, sans indiquer comment les réaliser.
C’est le point ultime de l’abstraction.
C’est un style de programmation à encourager :
Program to Interfaces
Exemple : une classe rectangle,
class Rectangle{
double largeur, hauteur;
Rectangle(double largeur, double hauteur){
this.largeur = largeur; this.hauteur = hauteur;}
double getAire(){
return largeur * hauteur;}
public String toString() {
return «Aire =»+getAire();}
}
Présentation de POO-Java - p. 124Philippe Canalda
Et une classe ellipse donnée par,
class Ellipse{
double largeur, hauteur;
Ellipse(double largeur, double hauteur){
this.largeur = largeur; this.hauteur = hauteur;}
double getAire(){
return largeur * hauteur * Math.PI/4;}
public String toString() {
return «Aire =»+getAire();}
}
Comme nous l’avons déjà vu, notamment avec l’exemple de la location de voitures et de camions, nous devons déterminer une abstraction commune en terme de membre et de méthodes. Aujourd’hui nous allons plus loin en rajoutant un niveau d’abstraction. Ces 2 classes ont alors une abstraction commune qui :
• définit les méthodes de même implémentation;
• déclare les méthodes communes et d ’implémentation différentes.
L’ interface Form
interface Form{
double getAire();
String toString();
}
Présentation de POO-Java - p. 125Philippe Canalda
La classe abstraite AbstractForm définit l’implémentation des membres et des méthodes à la déclaration et la définition commune, i.e. les membres largeur et hauteur, ainsi que la méthode toString() et la méthode du constructeur :
abstract class AbstractForm implements Form{
double largeur, hauteur;
AbstractForm(double largeur, double hauteur){
this.largeur = largeur; this.hauteur = hauteur;}
public String toString() {
return «Aire = »+getAire();}}
Les méthodes abstraites (déclarées dans l’interface et non définies dans l ’implémentation) sont implémentées dans chaque classe concrète :
class Rectangle extends AbstractForm{
Rectangle(double largeur, double hauteur){
super(largeur,hauteur);}
public double getAire(){
return largeur * hauteur;}}
et class Ellipse{
Ellipse(double largeur, double hauteur){
super(largeur,hauteur);}
double getAire(){
return largeur * hauteur * Math.PI/4;}}
Présentation de POO-Java - p. 126Philippe Canalda
On se sert de ces classes dans :
…
AbstractForm r=new Rectangle(6,10);
Form c=new ellipse(3,5);
System.out.println(r);
System.out.println(c);
…
ou bien dans :
…
Form[] a= new Form[5];
a[0]=new Rectangle(6,10);
a[1]=new ellipse(3,5);
for(int i=0;i<a.length;i++;)
System.out.printl(a[i]);
…
0 1 2 3 … n
Présentation de POO-Java - p. 127Philippe Canalda
InstanceofDans l’exemple précédent, lorsque une référence peut pointer sur des types différents (c ’est le cas de a[i] qui
peut référencer un objet de classe Ellipse ou bien Rectangle), on peut tester le type d ’un objet à l ’aide de instanceof :
…
Form f=new Rectangle(6,10);
if (f instanceof Rectangle) {…}; // vrai
if (f instanceof Ellipse) {…}; // faux
…
l ’opérateur instanceof est sous-jacent au concept de polymorphisme. Il s ’agit, dans certains traitements liés à une variable polymorphe de connaître le type instantané associé afin d ’invoquer une méthode ou adresser un membre disponible.
Il ne faut pas abuser de instanceof, autant que faire se peut.
Présentation de POO-Java - p. 128Philippe Canalda
Exemple d ’interface : exerciceOn se propose de faire 2 implémentations des matrices générales et des matrices symétriques. Elles doivent
autoriser des constructions (au moins 2 distinctes), un affichage, une affectation d ’élément, une addition de 2 matrices, une transposition.
Pour vous aider dans votre quête je vous rappelle l ’implémentation que nous avons déjà réalisée par le passé :
public class Matrice {
int n;
int [][] m;
public Matrice(int n){
this.n=n;
this.m=new [n][n];
}
public Matrice(int n, int x){
this.n=n;
this.m=new int[n][n];
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
this.m[i][j]=x;
}
public void transposer(){
for(int i=0; i<n; i++)
for(int j=i+1; j<n; j++) {
int t=m[i][j]; m[i][j]=m[j][i]; m[j][i]=t;
}
}
public String toString(){
StringBuffer sb = new StringBuffer();
for(int i=0; i<this.n; i++)
for(int j=0; j<this.n; j++) {
sb.append(m[i][j]);
sb.append(« »);
}
sb.append(« \n»);
}
return sb.toString();
}
}
Présentation de POO-Java - p. 129Philippe Canalda
Exemple d ’interface : exerciceOn se propose de faire 2 implémentations des matrices générales et des matrices symétriques. Elles doivent
autoriser des constructions (au moins 2 distinctes), un affichage, une affectation d ’élément, une addition de 2 matrices, une transposition.
Pour vous aider dans votre quête je vous rappelle l ’implémentation que nous avons déjà réalisée par le passé :
public class Matrice {
int n;
int [][] m;
public Matrice(int n){
this.n=n;
this.m=new [n][n];
}
public Matrice(int n, int x){
this.n=n;
this.m=new int[n][n];
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
this.m[i][j]=x;
}
public void transposer(){
for(int i=0; i<n; i++)
for(int j=i+1; j<n; j++) {
int t=m[i][j]; m[i][j]=m[j][i]; m[j][i]=t;
}
}
public String toString(){
StringBuffer sb = new StringBuffer();
for(int i=0; i<this.n; i++)
for(int j=0; j<this.n; j++) {
sb.append(m[i][j]);
sb.append(« »);
}
sb.append(« \n»);
}
return sb.toString();
}
}
Présentation de POO-Java - p. 130Philippe Canalda
Interface Matrice{//Matrice d ’entiers
Matrice add(Matrice a);
void setAt(int i, int j, int valeur);
void transposer();
}
Deux implémentations, à savoir des matrices générales et des matrices symétriques se partagent une classe abstraite commune
public abstract class AbstractMatrice implements Matrice{
int[][] m;
AbstractMatrice(int n){
this.n=n;
this.m=new [n][n];
}
AbstractMatrice(int n, int x){
this.n=n;
this.m=new int[n][n];
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
m[i][j]=x;
}
(à suivre)
(suite)
public String toString(){
StringBuffer sb = new StringBuffer();
for(int i=0; i<n; i++)
for(int j=0; j<n; j++) {
sb.append(m[i][j]);
sb.append(« »);
}
sb.append(« \n»);
}
return sb.toString();
}
}
Présentation de POO-Java - p. 131Philippe Canalda
Les classes spécifiques se contentent d’implémenter les autres méthodes :
public class GenMatrice extends AbstractMatrice{
GenMatrice(int n){
super(n);}
GenMatrice(int n, int x){
super(n,x);}
public Matrice add(Matrice a){
int n=m.length;
Matrice r=new GenMatrice(n);
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
r.setAt(i,j,m[i][j]+a.m[i][j]);
return r;
}
public void setAT(int i, int j, int valeur){
m[i][j]=valeur; }
public void transposer(){
int n=m.length;
Matrice r=new GenMatrice(n);
for(int i=0;i<n;i++)
for(int j=i+1;j<n;j++){
(à suivre)
(suite)
int t=m[i][j];
m[i][j]=m[j][i];
m[j][i]=t;
} //end for(int j…
} //end transposer
}
Présentation de POO-Java - p. 132Philippe Canalda
public class SymMatrice extends AbstractMatrice{
SymMatrice(int n){
super(n);}
SymMatrice(int n, int x){
super(n,x);}
public Matrice add(Matrice a) throws UnsupportedOperationException {
if (! (a instanceof SymMatrice))
throw new UnsupportedOperationException();
int n=m.length;
SymMatrice sa=(SymMatrice) a;
Matrice r=new SymMatrice(n);
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
r.setAt(i,j,m[i][j]+sa.m[i][j]);
return r;
}
public void setAT(int i, int j, int valeur){
m[i][j]=m[j][i]=valeur;}
public void transposer(){}
public static void main(Strings[] args){
...
(à suivre)
(suite)
…
Matrice a=new SymMatrice(3,12);
System.out.print(a);
Matrice b=new SymMatrice(3);
b.setAt(1,2,4);
System.out.print(b);
Matrice c=b.add(b);
System.out.print(c);
}
} On obtient :$java SymMatrice12 12 1212 12 1212 12 120 0 00 0 4 0 4 00 0 00 0 80 8 0
Présentation de POO-Java - p. 133Philippe Canalda
Autre exemple : application d ’une méthode à tous les éléments d ’un conteneur / passage d’une interface en paramètre (à défaut de pouvoir passer une fonction en paramètre).
• On encapsule une méthode dans une interface :
interface Function{
int applyIt(int n);}• On encapsule la fonction mapcar dans une autre interface :
interface Map{
void map(Function f);}• Une classe qui peut réaliser un map inplémente cette interface :
class Tableau implements Map{
int[] a;
Tableau(int n){
a=new int[n];
for(int i=0; i<a.length;i++)
a[i]=i+1;
}
}
public void map(Function f){
for(int i=0; i<a.length;i++)
a[i]=f.applyIt(a[i]);
}
public String toString(){...}
}
• Un exemple de fonction:
class Carre implements Function{
public int applyIt(int n){
return n*n;}
}• Un exemple d ’utilisation :
public class TestMap{
public static void main(String[] args){
Tableau t=new Tableau(10);
Function square = new Carre();
System.out.print(t);
t.map(square);
System.out.print(t);
}
}On obtient :$java TestMap1 2 3 4 5 6 7 8 9 101 4 9 16 25 36 49 64 81 100
Présentation de POO-Java - p. 134Philippe Canalda
• Notes prises par Amandine Revel et Christophe Vouaux
Présentation de POO-Java - p. 135Philippe Canalda
ExceptionsVoici une classe pile, implémentée par un tableau
public class Pile{
private static final int maxP=4;
private int hauteur=0;
private int[] contenu=new int[maxP];
public boolean isEmpty(){
return (this.hauteur==0);}
public boolean isFull(){
return (this.hauteur==maxP);}
public void push(int x){
this.contenu[this.hauteur++]=x;}
public int top(){
return (this.contenu[this.hauteur-1]);}
public void pop(){
this.hauteur--;
}
}
Présentation de POO-Java - p. 136Philippe Canalda
Il y a débordement lorsque l ’on fait :• top pour une pile vide;• pop pour une pile vide;• push pour une pile pleine.
Une pile ne peut pas proposer de solution en cas de débordement, mais elle doit signaler (et interdire) le débordement. Cela peut se faire par des conditionnels, des assert(), ou bien encore par des exceptions.
Une exception est un objet d’une classe qui étend la classe Exception. La classe Exception dérive de Throwable. La classe Throwable a une autre classe dérivée, la classe Error.
Pour les piles on peut définir
class PileException extends Exception{}
En cas de débordement, on lève une exception, par l ’instruction throw.
On doit signaler la possible levée d ’une exception au cours de l’exécution d ’une instruction d ’une méthode en signalant cette possible levée au niveau de la déclaration de cette méthode. Par exemple :
void push(int x) throws PileException{
if this.isFull() throw new PileException(« Pile pleine »);
this.contenu[this.hauteur++]=x;
}
L ’effet de la levée est :
• la propagation d ’un objet d ’une classe d ’exceptions qui est en général créé par new;
• la sortie immédiate de la méthode;
• la remontée dans l‘arbre d ’appel à la recherche d ’une méthode qui capture l ’exception.
Présentation de POO-Java - p. 137Philippe Canalda
La capture se fait par un bloc try / catch. Par exemple
…
Pile p=new Pile();
try {
System.out.println(«top = »+p.top());
} catch (PileException e) {
System.out.println(e.getMessage());
}
…• Le bloc try lance une exécution contrôlée.
• En cas de levée d ’exception dans le bloc try, ce bloc est quitté immédiatement, et l ’exécution se poursuit par le bloc catch.
• Le bloc catch reçoit en argument l ’objet créé lors de la levée d’exception.
• Plusieurs catch sont possibles, et le premier dont l ’argument est du bon type est exécuté (à la manière d ’un case au sein d ’un switch). Les instructions du bloc finally sont exécutées dans tous les cas.
try {…}
catch {Type1Exception e) { … }
catch {Type2Exception e) { … }
catch {Exception e) { … } // cas par défaut, capture les exceptions non
// traitées plus haut
finally { … } // toujours exécuté
Présentation de POO-Java - p. 138Philippe Canalda
Exemple :
…
try {…}
catch {Exception e) { … }
catch {PileException e) { … } // jamais exécuté
Une levée d ’exception se produit lors d ’un appel à throw ou d ’une méthode ayant levé une exception. Ainsi l ’appel à une méthode pouvant lever une exception doit :
• ou bien être contenu dans un bloc try / catch pour capturer l ’exception ;• ou bien être dans une méthode propageant cette classe d ’exception (avec throws).
Les exceptions de la classe RuntimeException n ’ont pas à être capturées.
Voici une interface de pile d ’entiers, et deux implémentations.
Interface Pile{
boolean isEmpty();
boolean isFull();
void push(int x) throws PileException;
int top() throws PileException;
void pop() throws PileException;
}
class PileException extends Exception{
PileException(String s){super(s);}
}
Présentation de POO-Java - p. 139Philippe Canalda
Implémentation par tableau
public class ArrayPile implements Pile{
static final int maxP=4;
private int hauteur=0;
private int[] contenu=new int[maxP];
public boolean isEmpty(){
return (this.hauteur==0);}
public boolean isFull(){
return (this.hauteur==maxP);}
public void push(int x) throws PileException{
if isFull() throw new PileException(« Pile pleine »);
this.contenu[this.hauteur++]=x;}
public int top() throws PileException{
if this.isEmpty() throw new PileException(« Pile vide »);
return this.contenu[this.hauteur-1];}
public void pop() throws PileException{
if this.isEmpty() throw new PileException(« Pile vide »);
this.hauteur--;
}
}
Présentation de POO-Java - p. 140Philippe Canalda
Implémentation par liste (classe interne liste et empilement par appel du constructeur)
public class ListPile implements Pile{
private List tete = NULL;
class List{
int cont;
List suiv;
List(int c, List s) {
this.cont=c; this.suiv=s;}
}
public boolean isEmpty(){
return (this.tete==NULL);}
public boolean isFull(){
return false;}
public void push(int x) throws PileException{
this.tete=new List(x, this.tete);}
public int top() throws PileException{
if this.isEmpty() throw new PileException(« Pile vide »);
return this.tete.cont;}
public void pop() throws PileException{
if this.isEmpty() throw new PileException(« Pile vide »);
this.tete=this.tete.suiv;
}
}
Présentation de POO-Java - p. 141Philippe Canalda
Usage:public class TestPile {
public static void main(String[] args){
Pile p=new ArrayPile(); // par table
try{
p.push(2);p.pop();
p.pop(); // erreur -> exception levée
p.pop(); // jamais atteint !
} catch (PileException e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
Pile q=new ListPile(); // par liste
try{
q.push(2); q.push(5);
q.pop(); q.pop();
System.out.println(q.top()); // erreur -> exception levée
} catch (PileException e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}
Présentation de POO-Java - p. 142Philippe Canalda
Pattern de création : les fabriquesUne fabrique est une classe dont les méthodes ont en charge la construction d ’objets d ’une autre classe.
Réalisation : une méthode
chose createChose() {return new Chose();}
Exemple, on cherche une méthode testVersion() qui permet de remplacer le corps de la méthode main de l ’exemple précédent par deux appels. En voici quelques variantes.public static void testVersion1(Pile p){
try{
p.push(2);p.push(5);
p.pop(); p.pop();
System.out.println(p.top());
} catch (PileException e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
Utilisé avec
testVersion1(new ArrayPile());
testVersion1(new ListPile());
Présentation de POO-Java - p. 143Philippe Canalda
Si l ’on veut créer des choses, non pas au moment de l’appel, mais à l ’intérieur de la méthode de test :public static void testVersion2(boolean version){
Pile p;
if version p=new ArrayPile();
else p=new ListPile;
…
}
Utilisé avec
testVersion2(true);
testVersion2(false);
On peut délocaliser la création en une méthode de fabrique :public static void testVersion3(boolean version){
Pile p=createPile(version);
…
}
Utilisé avec
testVersion3(true);
testVersion3(false);
On peut enfin transmettre un descripteur de classe :
...
Présentation de POO-Java - p. 144Philippe Canalda
On peut enfin transmettre un descripteur de classe :public static void testVersion4(Class classPile)
throws IllegalAccessException, instanciationException {
Pile p;
p=(Pile) classPile.newInstance();
…
}
La méthode newInstance de la classe Class est une méthode de fabrique. On utilise cette méthode avec
try {
testVersion4(ArrayPile.class);
testVersion4(ListPile.class);
} catch(IllegalAccessException e){}
catch(InstanciationException e){}
catch(ClassNotFoundException e){}
Présentation de POO-Java - p. 145Philippe Canalda
PaquetagesLe paquetage (package) est un mécanisme de groupement de classes.
• Les classes d’un paquetage sont dans un même répertoire décrit par le nom du paquetage.
• Le nom est relatif aux répertoires de la variable d’environnement CLASSPATH.
• Les noms de paquetage sont en minuscule.
Par exemple, le paquetage java.awt.event se trouve dans le répertoire $(CLASSPATH)/java/awt/event (les classes java sont zippées dans les archives).
Importer java.awt.event.* signifie que l’on peut nommer les classes dans ce répertoire par leur nom local, à la place du nom absolu. Cela ne concerne que les fichiers .class et non les répertoires contenus dans ce répertoire.
Exemple:
class MonAplette extends Applet // non trouvée
class MonAplette extends java.applet.Applet // ok
import java.applet.Applet;
class MonAplette extends Applet // ok
import java.applet.*;
class MonAplette extends Applet // ok
Présentation de POO-Java - p. 146Philippe Canalda
Pour faire son propre paquetage, on ajoute la ligne
package nomrepertoire;
en début de chaque fichier java qui fait partie de ce package. Le fichier .java doit se trouver dans un répertoire
ayant pour nom nomrepertoire.
Par défaut, le paquetage est sans nom (unnamed), et correspond au répertoire courant.
Si une même classe apparaît dans 2 paquetages importés globalement, la classe utilisée doit être importée explicitement.
Visibilité et paquetagesUne classe ou une interface qui est déclarée public est accessible en dehors du paquetage.
Si elle n’est pas déclarée public, elle est accessible à l’intérieur du même paquetage, mais cachée en dehors.
=> il faut donc déclarer publiques les classes utilisées par les clients utilisant le paquetage et cacher les classes donnant les détails d’implémentation.
Ainsi, quand on change l’implémentation, les clients ne sont pas concernés par les changements puisqu’ils n’y
ont pas accès.
Présentation de POO-Java - p. 147Philippe Canalda
Programmation des listesUne liste est une suite d ’objets.
• Comme séquence (a1, … an), elle se programme itérativement. (déjà vu)
• Comme structure imbriquée (a1, (a2, (… (an, ()) … )), elle se définit récursivement.
Une liste récursive se définit comme suit. Une liste est alors :
• soit une liste vide ;
• soit un cons d’un objet et d’une liste.
A ce niveau il reste à concevoir la hiérarchie de classes puis déclarer les composants de ces classes (attributs, méthodes, visibilité, ...). La conception est orientée interface.
Question subsidiaire : Comment concevoir une interface lorsque plusieurs sortes d’instance de classes sont utilisables ?
Présentation de POO-Java - p. 148Philippe Canalda
Programmation des listes
Ceci conduit à une interface pour les listes avec 3 interfaces, une pour le cons et une pour la liste vide, plus une interface qui déclare les méthodes communes.
public interface Liste{
int length();
}
public interface Cons extends Liste{
Object getElem();
void setElem(Object o);
Liste getSuiv();
void setSuiv(Liste tail);
}
public interface Nil extends Liste{};
Présentation de POO-Java - p. 149Philippe Canalda
L ’implémentation se fait naturellement :
public class ConcreteCons implements cons{
private Object o;
private Liste suiv;
public ConcreteCons(Object o, Liste suiv) {
this.o=o;
this.suiv=suiv;
}
public Object getElem(){
return o;}
public void setElem(Object o){
this.o=o; }
public Liste getSuiv(){
return this.suiv;}
public void setSuiv(Liste suiv){
this.suiv=suiv;}
public int length(){
return this.suiv.length()+1;}
}
public class ConcreteNil implements Nil{
public int length(){
return 0;}
}
Usage :public class TestListe{
public static void main(String[] args){
Liste l;
l=new ConcreteCons(new Integer(1),
new ConcreteCons(new Integer(2),
new ConcreteNil()));
System.out.println(«Liste de longueur»+ \
l.length());
}
}
Plusieurs appels à ConcreteNil() créent des liste nulles différentes. Pour éviter cela, on modifie :
public class ConcreteNil implements Nil{
private static Liste nulle=new ConcreteNil();
private ConcreteNil(){}
public static Liste getNil(){
return nulle;}
public int length(){ return 0;}
}
Avec : l=newConcreteCons(new Ineger(1),
new ConcreteCons(new Integer(2,
ConcreteNil.getNil()));
Présentation de POO-Java - p. 150Philippe Canalda
Pattern de création : singletonUne classe singleton est une classe qui ne peut avoir qu’une seule instance.
Réalisation :
• un attribut privé statique instance désignant l’instance;
• une méthode publique de création qui teste si l’instance existe déjà;
• un constructeur privé.
Exemple :public class ConcreteNil implements Nil{
private static ConcreteNil instance = null; private ConcreteNil(){}
public static Liste getNil(){
if (instance==null)
instance=new ConcreteNil();
return instance;
}
public int length(){ return 0;}
}
Présentation de POO-Java - p. 151Philippe Canalda
Partie IV Java et les classes
Fondamentales
Présentation de POO-Java - p. 152Philippe Canalda
4. Les classes fondamentales1- Présentation des API
2- Les enveloppes des types de base
3- La classe java.lang.Object, mère de toutes les classes
4- Les chaînes de caractères
5- Ensembles structurés, itérateurs et comparateurs
6- Introspection
Présentation de POO-Java - p. 153Philippe Canalda
4.1 Les APILes API (Application Programming Interface) forment l’interface de programmation,
c’est-à-dire l’ensemble des classes livrées avec Java.
Java.lang classes de base du langage
java.io entrées/sorties
java.util ensemble d ’outils : les classes très « utiles »
java.net classes réseaux
java.applet classes pour les appliquettes
java.awt interfaces graphiques (Abstract Windowing Toolkit)
… et de nombreuses autres
Présentation de POO-Java - p. 154Philippe Canalda
Les enveloppes des types de base
• Une instance de la classe enveloppe encapsule une valeur du type de base correspondant.
• Chaque classe enveloppe possède des méthodes pour extraire la valeur d’un objet. Par exemple intValue() renvoie un int. Les noms varient d’une classe à l’autre.
• Un objet enveloppant est immutable : mais la valeur contenue peut-être modifiée.(c ’est-à-dire qu’un objet de type boolean restera toujours du même type mais la valeur contenue pourra être modifiée et issue de la conversion d’un objet d ’un autre type)
• Pour palier à cela, on exploite la hiérarchie d’interfaces et de classes. On transforme souvent une valeur en objet pour utiliser une méthode manipulant ces objets.Ainsi, la programmation objet rejoint la programmation à-la-actionScript ou à la javascript ou une variable peut changer de type. Mais le programmeur contrôle complètement ce qu’il manipule (du moins il est censé le faire).
boolean java.lang.Booleanchar java.lang.Characterbyte java.lang.Byteshort java.lang.Shortint java.lang.Integerlong java.lang.Longfloat java.lang.Floatdouble java.lang.Double
Présentation de POO-Java - p. 155Philippe Canalda
• Les notes du CM7 ont été prises par
• Aurélien Seguin
Présentation de POO-Java - p. 156Philippe Canalda
Présentation de POO-Java - p. 157Philippe Canalda
Le clonageLe clonage est la construction d’une copie d’un objet.
La classe Object contient une méthode Object clone().• Lorsque cette méthode est appelée sur un objet d’une classe qui implémente l’interface Cloneable, elle crée une copie
de l’objet du même type. La copie est superficielle de l’objet : les attributs de l’objet sont alors recopiés.
• Lorsqu’elle est appelée sur un objet d’une classe qui n’implémente pas l’interface Clonable, elle lève l’exception CloneNotSupportedException.
• La classe Object n’implémente pas l’interface Cloneable
Exemple 1/2 :
public class Point implements Cloneable {
private int x, y;
public Point(int _x, int _y){
this.x=_x;this.y=_y; }
public String toString(){
return this.x+«, »+this.y; }
public static void main(String[] args) throws CloneNotSupportedException{
Point a=new Point(5,3);
Point b=(Point) a.clone();//méthode clone() de Object
b.x=a.x+1;
System.out.println(a); //3, 5
System.out.println(b); //4, 5}
}
Présentation de POO-Java - p. 158Philippe Canalda
Le clonageExemple 2/2 :
public class Point implements Cloneable {
public int x, y;
public Point p;
public Point(int _x, int _y){
this.x=_x;this.y=_y; }
public Point(int _x, int _y, Point _p){
this.x=x; this.y=y; this.p=_p}
public String toString(){
return « Premier niveau ok : \t » + this.x+«, »+this.y+ « \n Deuxième niveau pas cloné : \t »+this.p.x;+«, »+this.p.y }
public static void main(String[] args) throws CloneNotSupportedException{
Point a=new Point(3,5,new Point(1,1));
Point b=(Point) a.clone();//méthode clone() de Object
System.out.println(a); //Premier niveau ok : 3,5
//Deuxième niveau pas cloné : 1,1
b.x=a.x+1; b.p.x=a.p.x+1;
System.out.println(a); //3, 5 2,1
System.out.println(b); //4, 5 2,1
}
}
Présentation de POO-Java - p. 159Philippe Canalda
Si on veut une classe « clonable » et une classe dérivée « non clonable », la classe dérivée implémente Cloneable mais on lève une exception dans l’écriture (de la surcharge) de clone().
Exemple de clonageSi le clonage par défaut est superficiel, celui-ci ne le sera pas en surchargeant la méthode clone() :
public class Pile implements Cloneable {
private int hauteur;
private int[] contenu;
public Pile(int maxP){
this.hauteur=0;
this.contenu=new int[maxP];}
public void push(int val){
this.contenu[hauteur++]=val;}
public int pop(){
return this.contenu[this.hauteur--];}
public Object clone(){
Pile nouvelObject=(Pile) super.clone();
nouvelObject.contenu=(int[])contenu.clone();
return nouvelObject;
}
}
Présentation de POO-Java - p. 160Philippe Canalda
Public class TestPile{
public static void main(String[] args){
Pile f=new Pile(2);
f.push(5); f.push(6);
try {
Pile g=(Pile) f.clone();
System.out.println(g.pop()); // 6
System.out.println(g.pop()); // 5
} catch (CloneNotSupportedException e) {}
}
}
Remarquer l ’utilisation de super.clone(), qui appelle clone() de Object, et qui crée toujours un objet du bon type. Si l’on souhaite clone un objet d’une classequi dérive d’autres classes, il convient de définir la surcharge de clone à chaque niveau. Sinon, l’appel à clone() sur un objet d’une classe dérivée de Pile serait incorrect. Si l’on n’est pas rigoureux, il faut alors faire appel à new Pile(). La 1ère méthode est la plus rigoureuse à-la-manière de toString(). Choisissons donc de redéfinir la fonction clone() pour la classe dérivée :
Exemplepublic class DPile extends Pile{
private int cout;
public DPile(int maxP){
super(maxP);
this.cout=0;}
public Object clone() throws CloneNotSupportedException{
DPile nouvelObject=(DPile) super.clone();
nouvelObject.cout=cout;
return nouvelObject;
}
}
Présentation de POO-Java - p. 161Philippe Canalda
Egalité entre objetsLa methode equals() de la classe Object détermine si deux objets sont équivalents. Par défaut, deux objets sont
équivalents s’ils sont accessibles par la même référence. Une classe peut redéfinir la méthode equals().
class Rectangle extends Forme{
private int largeur, hauteur;
Rectangle(int l, int h){
this.largeur=l;
this.hauteur=h; }
public boolean equals(Object arg){
if (!(arg instanceof Rectangle) return false;
Rectangle rarg=(Rectangle) arg;
return ((this.largeur==rarg.largeur) && (this.hauteur==rarg.hauteur))}
…
}
Remarquer que l’argument est de type Object. Si l’argument était Rectangle, la méthode ne serait pas redéfinie mais surchargée. Elle serait alors ignorée lors d’un appel avec un argument de type Forme qui référence un Rectangle. La comparaison entre les 2 rectangles serait alors incorrecte.
Présentation de POO-Java - p. 162Philippe Canalda
Les chaînes de caractèresLa classe java.lang.String :
• la classe String est Final (c’est-à-dire qu’elle ne peut pas être dérivée).
• Elle utilise un tableau de caractères qui est un membre privé de la classe.
• Un objet de la classe String ne peut-être modifié. (On doit créer un nouvel objet).String nom=«toto»+ «tata»;
System.out.println(nom.length()); // 8
System.out.println(nom.charAt(2)); // t
On peut construire un objet String à partir d’un tableau de caractères :char [] tableau={‘t’,‘o’,‘t’,‘o’};
String s=new String(tableau);
et inversement :char[] tableau=«toto».toCharArray();
Conversion d’un entier en chaîne de caractères :String un=String.valueOf(1); //méthode statique qui appelle toString()
et inversement :int i=Integer.valueOf(«12»).intValue();
// ou bien
int i=Integer.parseInt(«12»);
Comparaison des chaînes de caractères : on doit utiliser la méthode equals()String s=«toto»;
String t=«toto»;
if (s.equals(t)) … // true
Présentation de POO-Java - p. 163Philippe Canalda
La méthode compareTo() est l ’équivalent du strcmp() du C.
La méthode trim() supprime tous les espaces blancs :String s=« toto »;
s=s.trim; // s=« toto »
La classe java.lang.StringBuffer• permet de créer des buffers de caractères de taille extensible.StringBuffer sb=new StringBuffer(« le »);
sb.append(« petit »);
sb.append(« prince »);
On récupère un String à partir d’un StringBuffer (sans recopie) :String mot=sb.toString;
Ces classes sont sécurisées au niveau des thread (cf. plus tard).
La classe java.util.StringTokenizer permet d’effectuer de l’analyse lexicale simple.
String texte=«Le petit prince»;
StringTokenizer st=new StringTokenizer(texte);
while (st.hasMoreTokens()) {
String mot=st.nextTokens();}
La classe StringTokenizer implémente l’interface java.util.Enumeration. Les délimiteurs par défaut sont les espaces, les retours chariots et les tabulations. On peut spécifier les délimiteurs :
String texte=«http://lifc.univ-fcomte.fr/~canalda»;
StringTokenizer st=new StringTokenizer(texte,«/:~»);
if (st.countTokens()<=2) … // mauvaise url
String protocole=st.nextToken();
String host=st.nextToken();
String login=st.nextToken();
Présentation de POO-Java - p. 164Philippe Canalda
Outils mathématiquesOn peut trouver des outils mathématiques dans les 2 classes et le paquetage qui suivent :• java.lang.Math• java.lang.Random• java.math (pour le travail sur les entiers longs et sur les flottants)
Exemple : int maximum=Math.max(3,4);
Exemple : tirer au hasard un nombre entre 100 et 1000 (bornes comprises)int maximum=100+(int) (Math.random()*900);
• Une instruction arithmétique sur les entiers peut lever l’exception ArithmeticException :try {
int i=1/0;
} catch (ArithmeticException e){...};
• Une instruction arithmétique sur les flottants ne lève pas d’exception. Une expression flottante peut prendre 3 valeurs particulières :
POSITIVE_INFINITY 1.0/0.0
NEGATIVE_INFINITY -1.0/0.0
NaN 0.0/0.0
Présentation de POO-Java - p. 165Philippe Canalda
Collection
Ensembles structurés, itérateurs, comparateurs
ArrayList LinkedList Vector hashSet
TreeSet
SortedSet
SetList
HashMap TreeMap
SortedMap
Map
Hashtable
Présentation de POO-Java - p. 166Philippe Canalda
Exemple :
• java.util.ArrayList :
• java.util.Iterator :
Présentation de POO-Java - p. 167Philippe Canalda
Vue d ’ensembleDeux interfaces :• Collection : pour les ensembles d’objet,• Map pour les tables, c-à-d les ensembles de couples (clé, valeur), où la clé et la valeur sont des objets.
Des itérateurs sur les collections :• Iterator : interface des itérateurs,• ListIterator : itérateur sur les séquences,• Enumeration : ancienne forme des itérateurs.
De plus, deux classes d’utilitaires• Collections : avec algorithmes de tris, …• Arrays : avec algorithmes spécialisés sur les tableaux.
Les opérations principales sur une collection :• add : pour ajouter un objet,• remove : pour enlever un objet,• contains : test d’appartenance,• size : pour obtenir le nombre d’éléments,• isEmpty : pour tester si l’ensemble est vide
Comme les éléments sont des objets, ne pas écrire c.add(2) mais c.add(new Integer(2)).
Présentation de POO-Java - p. 168Philippe Canalda
Sous-interfaces spécialisées de Collection :• List spécifie les séquences, avec les méthodes
– int indexOf(Object o) position de o,
– Object get(int i) retourne l’objet à la position i,
– Object set(int i, Object o) remplace l’élément en position i, et retourne l’élément qui s ’y trouvait précédemment.
• Set spécifie les ensembles sans duplication,• SortedSet sous-interface de Set pour les ensembles ordonnés:
– Object first() retourne le premier objet,
– Object last() retourne le dernier objet,
– SortedSet subset(Object initial, Object final) retourne une référence vers le sous-ensemble des objets >= initial et < final.
Opérations ensemblistes sur les ensembles• boolean containsAll(Collection c) : pour tester l’inclusion• boolean addAll(Collection c) : pour la réunion• boolean removeAll(Collection c) : pour la différence• boolean retainAll(Collection c) : pour l’intersection
Les 3 dernières méthodes retournent true si elles ont modifié la collection.
Présentation de POO-Java - p. 169Philippe Canalda
Implémentation d’une collectionPour les collections :• ArrayList (recommandée, par tableau), et LinkedList (par liste doublement chaînée) implémentent
List.• Vector est une vieille classe (JDK 1.0) « relookée » qui implémente aussi List. Elle a des méthodes
spécifiques.• HashSet (recommandée) implémente Set,• TreeSet implémente SortedSet.
Le choix de l’implémentation résulte de l’efficacité recherchée : par exemple, l’accès indicé est un temps constant pour les ArrayList, l’insertion entre 2 éléments est un temps constant pour les LinkedList.
Discipline d’abstraction :
• les attributs, paramètres, variables locales sont déclarés avec, comme type, une interface (List, Set)
• les classes d’implémentation ne sont utilisées que par leur constructeurs.
Exemple :
List l=new ArrayList();
Set s=new HashSet();
Présentation de POO-Java - p. 170Philippe Canalda
Exemple :
Programme qui détecte une répétition dans les chaînes de caractères d’une ligne.
Import java.util.Set;
import java.util.HashSet;
class TestSet{
public static void main(String[] args){
set s=new HashSet();
for(int i=0; i<args.length;i++)
if !(s.add(args[i]))
System.out.println(«Déjà vu : » + args[i]);
System.out.println(s.size()+« distincts : »+s);
}
}
$ java TestSet a b c a b d
Déjà vu : a
Déjà vu : b
4 distincts : d c b a
Présentation de POO-Java - p. 171Philippe Canalda
ItérateursL ’interface Iterator définit les itérateurs.
Un itérateur permet de parcourir l’ensemble des éléments d’une collection.
Java propose 2 schémas, l’interface Enumeration et l’interface Iterator.
L ’interface java.util.Iterator a 3 méthodes :• boolean hasNext() qui teste si le parcours contient encore des éléments;• Object next() qui retourne l’élément suivant si un tel élément existe, (et lève une exception sinon);• void remove() qui supprime le dernier élément retourné par next().
L ’interface java.util.Enumeration a 2 méthodes :• boolean hasMoreElements() qui teste si l’énumération contient encore d’autres éléments ;• Object nextElements() qui retourne l’élément suivant s’il existe (une exception sinon).
Exemple :
import java.util.*;
public class Personne{
private String nom;
private int age;
public Personne(String nom, int age){this.nom=nom; this.age=age;}
public String toString(){return «Nom: »+this.nom+«, age : »+this.age);}
}
class TestHashSet{ ...
Présentation de POO-Java - p. 172Philippe Canalda
class TestHashSet{
public static void printAll(Collection c){
for(Iterator i=c.iterator();i.hasNext();)
System.out.println(i.next());
}
public static void main(String[] args){
Set s=new HashSet();
s.add(new Personne(«Philippe»,38));
s.add(new Personne(«Ines»,5));
s.add(new Personne(«Erwan»,2));
s.add(«Université»);
s.add(«pu-pm»);
printAll(s);
Set t=(Set) ((HashSet) s).clone();
System.out.println(s.size());
printAll(t);
Iterator i=t.iterator();
while (i.hasNext())
if (i.next() instanceof Personne) i.remove();
printAll(t);
}
}
On obtient :$java testHashSetNom : Philippe, age : 38pu-pmNom : Erwan, age : 2UniversiteNom : Ines, age : 55Nom : Philippe, age : 38pu-pmNom : Erwan, age : 2UniversiteNom : Ines, age : 5pu-pmUniversite
Observez le désordre
Présentation de POO-Java - p. 173Philippe Canalda
Détails sur les itérateurs.
• La méthode iterator() de la collection positionne l’itérateur au début,
• la méthode hasNext() teste si l’on peut progresser,
• la méthode next() avance d’un pas dans la collection, et retourne l’élément traversé,
• la méthode void remove() supprime l’élément référencé par next(), en conséquence de quoi il ne peut pas y avoir de remove() sans next()
|A B C iterator(), hasnext()=true
A|B C next()=A, hasnext()=true
A B|C next()=B, hasnext()=true
A B C| next()=C, hasnext()=false
Iterator i=c.iterator();
i.remove(); // non
i.next();
i.next();
i.remove(); // oui
i.remove(); // non
Présentation de POO-Java - p. 174Philippe Canalda
Exemple de tableauOn désire créer un tableau de références sur des objets de type Forme qui peuvent être Rectangle ou Ellipse.
import java.util.ArrayList;
import java.util.Iterator;
public abstract class Forme{
public abstract double getAire(); // à définir
public String toStringAire(){
return «Aire = »+getAire();} // commune
}
class Rectangle extends Forme {…};
class Ellipse extends Forme{…};
class TestForme{
public static void main(String[] args){
Forme r1=new Rectangle(6,10);
Forme r2=new Rectangle(5,10);
Forme e1=new Ellipse(3,5);
List l=new ArrayList();
l.add(r1);
l.add(r2);
l.add(1,e1); // on obtient r1, e1, r2
for(Iterator it=l.iterator(); it.hasnext();)
System.out.println(((Forme) it.next()).toStringAire());
}
}
0 1 2 3 … n
Présentation de POO-Java - p. 175Philippe Canalda
Itérer sur les listesLes listes sont des séquences. Un itérateur de listes implémente l’interface ListIterator. Il a des méthodes
supplémentaires :• Object previous() qui permet de faire un parcours arrière (reculer);• boolean hasPrevious qui retourne true s’il y a un élément qui précède;• void add(Object) qui ajoute l’élément juste avant l’itérateur ;• void set(Object o) qui substitue o à l’objet référencé par next().
Exemple :
import java.util.*;
class TestLinkedList{
public static void printAll(Collection c){ … }
public static void main(String[] args){
List l=new LinkedList();
l.add(«A»);l.add(«B»);l.add(«C»);
printAll(l); // A B C
ListIterator itl=l.listIterator();
System.out.println(itl.next()); // A|B C -> A
System.out.println(itl.hasPrevious()); // true
System.out.println(itl.previous()); // | A B C -> A
itl.add(«X»); printAll(l); // X | A B C
}
}
Présentation de POO-Java - p. 176Philippe Canalda
ComparaisonJava exprime que les objets d’une classe sont comparables si cette classe implémente l’interface Comparable.
L’interface Comparable déclare une méthode int compareTo(Object o) telle que a.compareTo(b) est :• négatif, si a < b• nul, si a=b• positif si a>b
Exemple, la comparaison de « noms » :import java.util.*;
class Nom implements Comparable{
private String nom;
private int age;
public Nom(String n, int a){
this.age=a; this.nom=n;}
public int compareTo(Object o){
Nom n=(Nom) o;
int comp=this.nom.compareTo(n.nom);
return (comp!=0) ? comp : n.age - this.age;} // à nom égal le - âgé est supérieur
}
class TestComparaison{
public static void main(String[] args){
Collection c=new TreeSet();
c.add(new Nom(«Paul», 21));c.add(new Nom(«Paul», 25));c.add(new Nom(«Anne», 25));
for(Iterator it=c.iterator(); it.hasNext();)
System.out.println(it.next());
}
}
On obtient :$java TestComparaisonAnne 25Paul 25Paul 21
Présentation de POO-Java - p. 177Philippe Canalda
ComparateurUn comparateur est un objet qui permet la comparaison. En java, l’interface Comparator déclare une méthode
int compare(Object a, Object b).
On se sert d’un comparateur dans :• un constructeur d’un ensemble ordonné;• dans les algorithmes de tris fournis par Collections.
Exemple, deux comparateurs de « noms » :import java.util.*;
class NomComparator implements Comparator{
public int compare(Object oa, Object ob){
Nom a=(Nom) oa; Nom b=(Nom) ob;
int comp=a.getNom().compareTo(b.getNom());
if (comp==0) comp=a.getAge()-b.getAge(); // à nom égal, le plus âgé est supérieur
return comp;
}
}
class AgeComparator implements Comparator{
public int compare(Object oa, Object ob){
Nom a=(Nom) oa; Nom b=(Nom) ob;
int comp=b.getAge()-a.getAge();
if (comp==0) comp=a.getNom().compareTo(b.getNom()); // à âge égal, l’ordre alphabétique
return comp; // du nom fait la différence
}
}
Présentation de POO-Java - p. 178Philippe Canalda
ComparateurUne liste de noms pour pouvoir trier sans peine :
public static void main(String[] args){
List c=new ArrayList();
c.add(new Nom(«Paul», 21));c.add(new Nom(«Paul», 25));c.add(new Nom(«Anne», 25));
printAll(c);
Collections.sort(c,new NomComparator());
printAll(c);
Collections.sort(c,new AgeComparator());
printAll(c);
}
On obtient :
Anne : 25 Paul : 21 Paul : 25 // ordre sur NomsAnne : 25 Paul : 25 Paul : 21 // ordre sur AgesPaul : 21 Paul : 25 Anne : 25 // ordre d ’insertion
Présentation de POO-Java - p. 179Philippe Canalda
TablesL ’interface Map spécifie les tables, qui sont des ensembles de couples (clé, valeur). Les clés ne peuvent pas être
dupliquées, et au plus une valeur est associée à une clé.• Object put(Object key, Object value) insère l’association (Object key, Object value) dans la
table et retourne l’object précédemment associé à la clé ou bien null ;• boolean containsKey(Object key) retourne vrai s’il y a une valeur associée à cette clé ;• Object get(Object key) retourne l’objet associé à la clé dans la table;• Object remove(Object key) supprime l’association de clé key. Retourne l’objet précédemment
associé. Retourne null si null était l’objet précédemment associé ou bien encore si key n’est pas une association de la table.
La sous-interface SortedMap spécifie les tables dont l’ensemble des clés est ordonné.
Implémentation d’une tablePour les tables :• HashMap (recommandée) implémente Map ;• HashTable est une vieille classe (jdk 1.0) qui implémente aussi Map. Elle a des méthodes personnelles ;• TreeMap implémente SortedMap.
La classe TreeMap implémente les opérations avec des arbres rouge-noir.
Un TreeMap stocke les références de ces objets de telle sorte que les opérations s’exécutent en temps O(log(n)), pourvu que l’on définisse un bon ordre. Et c’est java.util.Comparator qui permet de spécifier un comparateur des clés.
Présentation de POO-Java - p. 180Philippe Canalda
Formes nomméesOn associe un nom à chaque forme. Le nom est la clé de la forme. L’interface Forme, et les classes Rectangle et
Ellipse restent inchangées.
import java.util.*;
public class FormeMapTest{
public static void main(String[] args){
Forme r2=new Rectangle(6,10);
Forme r1=new Rectangle(5,10);
Forme e1=new Ellipse(3,5);
TreeMap arbrel=new TreeMap();
arbre1.put(«R2»,r2);
arbre1.put(«R1»,r1);
arbre1.put(«E1»,e1);
System.out.println(((Forme) arbre1.get(«R1»)).toStringAire());
}
}
On obtient :$java FormeMapTestaire = 50.0
E1
R1
R2
Présentation de POO-Java - p. 181Philippe Canalda
Si l’on désire trier les clés en ordre inverse, on change le comparateur.
La classe java.util.TreeMap possède un constructeur qui permet de changer le comparateur :
public java.util.TreeMap(java.util.Comparator);
Le programme devient :import java.util.*;
public class OppositeComparator implements Comparator{
public int compare(Object oa, Object ob){
return -((comparable) oa).compareTo(ob); //ordre inverse
}
}
Cette méthode lève une exception NullPointerException si oa est null. Le reste de la vérification est déléguée à
compareTo.
class TestForme{
public static void main(String[] args){
Forme r2=new Rectangle(6,10);
Forme r1=new Rectangle(5,10);
Forme e1=new Ellipse(3,5);
Comparator c=new OppositeComparator();
TreeMap arbrel=new TreeMap(c);
arbre.put(«R2»,r2);
arbre.put(«R1»,r1);
arbre.put(«E1»,e1);
System.out.println(arbre.firstKey()+ « » + arbre.lastKey()); // «R2» «E1»
}
}
Présentation de POO-Java - p. 182Philippe Canalda
Itérer dans les tablesLes tables (map) n’ont pas d’itérateurs.
Trois méthodes permettent de voir les tables comme des ensembles :• keySet() retourne l’ensemble (Set) des clés ;• values() retourne la collection des valeurs associées aux clés ;• entrySet() retourne l’ensemble des couples (clé, valeur).
Map m=…;
Set clés = m.keySet();
Set couples = m.entrySet();
Collection valeurs = m.values();
On peut ensuite itérer sur ces ensembles :for(Iterator i=clés.iterator();i.hasNext();){
System.out.println(i.next());}
for(Iterator i=couples.iterator();i.hasNext();){
System.out.println(i.next());}
for(Iterator i=valeurs.iterator();i.hasNext();){
Map.Entry e = (Map.Entry) i.next();
System.out.println(e.getKey() + « -> » + e.getValue());
}
Présentation de POO-Java - p. 183Philippe Canalda
Exemple de construction d’un indexOn part d’une suite d’entrées formées d’un mot et d’un numéro de pages :
22, «Java»
23, «Iterateur»
25, «Java»
25, «Map»
25, «Java»
29, «Java»
Nous souhaitons obtenir l’index suivant :
Iterateur [23]
Java [22, 25, 29]
Map [29]
Chaque mot apparaît une fois,
dans l’ordre alphabétique,
et la liste des numéros de pages, où le mot est indexé,
est donnée dans l’ordre croissant
et sans répétition
Présentation de POO-Java - p. 184Philippe Canalda
/** Etape_1 */
class TestIndex{ // indépendante de l’implémentation
public static void main(String[] args){
/** Constitution de l’indexation */
Index index = makeIndex();
/** Impression de l’indexation constituée */
index.print();
}
}
Présentation de POO-Java - p. 185Philippe Canalda
/** Etape_2 */
class TestIndex{ // indépendante de l’implémentation
public static Index makeIndex(){
Index l_index = new Index();
l_index.put(22, «Java»);
l_index.put(23, «Iterateur»);
l_index.put(25, «Java»);
l_index.put(25, «Map»);
l_index.put(25, «Java»);
l_index.put(29, «Java»);
return l_index;
}
public static void main(String[] args){
/** Constitution de l ’indexation */
Index index = makeIndex();
/** Impression de l ’indexation constituée */
index.print();
}
}
Présentation de POO-Java - p. 186Philippe Canalda
/** Etape_3 */
import java.util.*;
class Index extends TreeMap{ // implementation dependant
public void put(int page, String mot){
...
}
public void print(){
Set clef = this.keySet();
for(Iterator i = clef.iterator(); i.hasNext(); ){
String c = (String) i.next();
System.out.println(c + « » + this.get(c));}
}
}
Présentation de POO-Java - p. 187Philippe Canalda
/** Etape_4 */
import java.util.*;
class Index extends TreeMap{ // implementation dependant
public void put(int page, String mot){
Set numeros = (Set) this.get(mot);
if (numeros == null) { // le mot n’est pas déjà référencé dans l’index
numeros = new TreeSet()
this.put(mot,numeros); // c’est l’appel à la vraie méthode put
}
numeros.add(new Integer(page));
}
public void print(){
Set clef = this.keySet();
for(Iterator i = clef.iterator(); i.hasNext(); ){
String c = (String) i.next();
System.out.println(c + « » + this.get(c));}
}
}
Présentation de POO-Java - p. 188Philippe Canalda
/** SOLUTION AGGREGEE */
import java.util.*;
class Index extends TreeMap{ // implementation dependant
public void put(int page, String mot){
Set numeros = (Set) this.get(mot);
if (numeros == null) { // le mot n’est pas déjà référencé dans l’index
numeros = new TreeSet()
this.put(mot,numeros); // c’est l’appel à la vraie méthode put
}
numeros.add(new Integer(page));
}
public void print(){
Set clef = this.keySet();
for(Iterator i = clef.iterator(); i.hasNext(); ){
String c = (String) i.next();
System.out.println(c + « » + this.get(c));}
}
}
Présentation de POO-Java - p. 189Philippe Canalda
/** SOLUTION AGGREGEE */
class TestIndex{ // indépendante de l’implémentation
public static Index makeIndex(){
Index l_index = new Index();
l_index.put(22, «Java»);
l_index.put(23, «Iterateur»);
l_index.put(25, «Java»);
l_index.put(25, «Map»);
l_index.put(25, «Java»);
l_index.put(29, «Java»);
return l_index;
}
public static void main(String[] args){
/** Constitution de l’indexation */
Index index = makeIndex();
/** Impression de l’indexation constituée */
index.print();
}
}
Présentation de POO-Java - p. 190Philippe Canalda
Algorithmes de CollectionsLes classes Collections et Arrays fournissent des algorithmes dont la performance et le comportement sont garantis. Toutes
les méthodes de ces classes sont statiques (ce sont donc des méthodes de classe).
Collections :
• min, max, dans une collection d’éléments comparables;
• sort pour trier des listes (tri-fusion);List a;…Collections.sort(a);
• binarySearch recherche dichotomique dans les listes ordonnées ;
• copy copie de listes :List source = …;List dest;Collections.copy(dest,source);
• synchronizedCollection pour « synchroniser » une collection : elle ne peut pas être modifiée durant l’exécution d’une méthode.
Présentation de POO-Java - p. 191Philippe Canalda
Algorithmes de ArraysArrays :• binarySearch recherche dichotomique dans les tableaux ;• equals teste l’égalité des contenus de 2 tableaux :
int[] a, b …;boolean b=Arrays.equals(a,b);
• sort() trie un tableau (quicksort) :int a[];…Arrays.sort(a);
Exemple : Le Tirage du Loto
import java.util.*;
class Loto {
public static void main(String[] args){
List boules = new ArrayList(49);
for(int i=0; i<49; i++)
boules.add(new Integer(i));
Collections.shuffle(boules); // mélange
List tirage = boules.subList(0,5); // les 6 premières
Collections.sort(tirage); // tri
System.out.println(tirage); //affichage du tirage
}}
On obtient :$java Loto[13, 18, 27, 28, 35, 39]$java Loto[2, 8, 12, 27, 33, 49]$java Loto[2, 3, 5, 28, 30, 31]
Présentation de POO-Java - p. 192Philippe Canalda
IntrospectionLa classe java.lang.Class• permet de manipuler les classes et interfaces comme des objets;
• offre des possibilités d’introspection (c.-à-d. exploration des méthodes et constructeurs d’une classe).
On peut ensuite récupérer un objet « méthode ». Les classes de ces objets sont définies dans java.lang.reflect :
String s = « toto »;
Class c = s.getClass();
interface I {};Class c1 = I.class;Class c2 = Class.forName(« I »);Class c3 = Float.class;
Une instance de la classe Class est associée à toutes les classes, interface, tableaux ou types primitifs.
On peut appliquer les méthodes suivantes à un objet c de la classe Class :• getDeclaredMethods() retourne un tableau d’objets de la classe java.lang.reflect.Method, les méthodes
déclarées dans c;• getMethods() retourne aussi les méthodes héritées ;• getMethod(String, Class[] parameterTypes) recherche une méthode en fonction de son profil.
Une méthode de la classe Method peut ensuite être invoquée par invoke().
Présentation de POO-Java - p. 193Philippe Canalda
import java.lang.reflect.*;
import java.util.Date;
public class Test{
public static void main(String[] args) throws Exception{
Class classDate = Class.forName(«java.util.Date»); // ou «Date»// création d’une instance de la classe Date
Object maDate = classDate.newInstance();
// récupération de la méthode toString() de la classe Date
Method maSortie = classeDate.getMethod(«toString», null);
// appel de la méthode toString() sur maDate
System.out.println((String) maSortie.invoke(maDate, null))
Date aujourdhui = new Date();
System.out.println(aujourdhui);
System.out.println(maDate);
}
}
On obtient :$java TestMon Dec 8 12:33:11 CEST 2003Mon Dec 8 12:33:11 CEST 2003Mon Dec 8 12:33:11 CEST 2003
Présentation de POO-Java - p. 194Philippe Canalda
Le chargement des classesUn chargeur de classe (classloader) est une instance d’une sous-classe de la classe abstraite java.lang.ClassLoader. Il
charge le bytecode d’une classe à partir d’un fichier .class et la rend accessible aux autres classes.
Principe du fonctionnement de la méthode loadClass() de la classe ClassLoader :
1- appel à findLoadedClass() pour voir si la classe n’est pas déjà chargée ;
2- demande de chargement de la classe à un chargeur parent obtenu par getParent() ;
3- en cas d’échec, appel de la méthode findClass()
4- levée de l’exception ClassNotFoundException en cas de nouvel échec.
public Class loadClass(String name) throws ClassNotFoundException {
try {
Class c = findLoadedClass(name);
if (c != null) return c;
ClassLoader parent = getParent();try {
c = parent.loadClass(name);if (c != null) return c;
} catch (ClassNotFoundException e) {}
c = findClass(name);if (c != null) return c;
} catch (Exception e) {thow new ClassNotFoundException(name)}
}
Présentation de POO-Java - p. 195Philippe Canalda
La méthode findClass() appelle une méthode defineClass() qui est la méthode de base de tout chargeur de classes. Elle :
• crée une instance de la classe Class
• et stocke la classe dans le chargeur.
La signature de defineClass() : Class defineClass(String name, byte[] b, int off, int len) throws ClassFormatError
import java.io.*; import java.lang.ClassLoader;
public class VerboseClassLoader extends ClassLoader {
public VerboseClassLoader(){ super(getSystemClassLoader()); /* chargeur parent en paramètre */ }public Class loadClass(String name) throws ClassNotFoundException {
System.out.println(« Chargement de » + name );try{ byte[] b = loadClassData(new File(name + «.class»));
return defineClass(name, b, 0, b.length)} catch (Exception e) { return getParent().loadClass(name)}
}private byte[] loadClassData(File f) throws IOException{
FileInputStream entree = new FileInputStream(f);int length = (int) f.length();int offset = 0; int nb;byte[] tableau = new byte[length];while (length != 0) {
nb = entree.read(tableau, offset, length);length -= nb; offset += nb;
}return tableau;
}
...
Présentation de POO-Java - p. 196Philippe Canalda
…
public static void main(String[] args) thows Exception{
VerboseClassLoader cl = new VerboseClassLoader();Class clazz = cl.loadClass(«A»);Object o = clazz.newInstance();System.out.println(« Dans VerboseClassLoader : »);if (o instanceof A)
System.out.println(«o instance de A»);else System.out.println(« o n’est pas instance de A »);System.out.println((o.getClass()).getClassLoader());
A o2 = new A();
System.out.println((o2.getClass()).getClassLoader());
}
}
Pour faire tourner cette exemple, on se donne 3 classes vides
B, C et D, et la classe A suivante :public class A extends B{
C c; D d;public A(){ System.out.println(« nouveau A() »);
d = new D();}public void inutile(){ c = new C();}
}
L’appel à newInstance() crée un objet et charge les classes nécessaires à sa création.o et o2 n’appartiennent pas à la même classe : 2 classes de même nom (ici A) peuvent coexister dans la machine virtuelle si elles n’ont pas le même chargeur de classe. Ceci est extrêmement important pour la programmation réseau (cf. java.net).
On obtient :$java VerboseClassLoaderChargement de AChargement de BChargement de java.lang.ObjectChargement de java.lang.SystemChargement de java.io.PrintStreamnouveau A()Chargement de DDans VerboseClassLoader : o n’est pas instance de AVerboseClassLoader@4acca8anouveau A()sun.misc.Launcher $AppClassLoader@1714ca8a
Présentation de POO-Java - p. 197Philippe Canalda
Partie V La programmation concurrente
Présentation de POO-Java - p. 198Philippe Canalda
La programmation concurrente1- Programmation concurrente
2- Processus légers
3- Les threads et la classe java.lang.Thread
4- Exclusion mutuelle
5- Synchronisation
Présentation de POO-Java - p. 199Philippe Canalda
5.1 Programmation concurrenteDéfinition : La programmation concurrente, c’est l’ensemble des mécanismes permettant
l’exécution concurrente d’actions spécifiées de façon séquentielle.
En java, 2 mécanismes permettent un ordonnancement automatique des traitements :• la concurrence entre commandes du système (processus)• la concurrence entre processus légers de la machine virtuelle
Présentation de POO-Java - p. 200Philippe Canalda
5.2 Processus légersDéfinition : Un processus léger (thread) correspond à un fil d’exécution, c.à-d. une suite
d’instructions en cours d’exécution. Il s’agit d’un processus créé et géré par la machine virtuelle java.
S’il y a plusieurs processus légers, • ils sont associés à un même programme,• et ils s’exécutent dans le même espace mémoire.
Lorsque l’on parle de processus légers en java, il y a 3 notions bien distinctes :• un objet représentant le code à exécuter (la cible), et dont la classe de cet objet
implémente l’interface Runnable ;• un objet qui contrôle le processus léger, et dont la classe dérive de Thread ;• un fil d’exécution, c.-à-d. la séquence d’instructions en cours d’exécution. C’est le
code de la méthode run() de la cible.
Mise en garde : Il ne faut surtout pas confondre Thread (Le contrôleur) et Runnable (le contrôlé). Pour illustrer cela il faut garder à l’esprit que Thread implémente Runnable et peut, par ce fait, s’auto-contrôler.
Présentation de POO-Java - p. 201Philippe Canalda
5.3 La classe java.lang.threadUn objet de la class Thread ne représente pas un processus léger mais un objet de contrôle
du processus léger.
Au lancement d’un programme, la machine virtuelle possède un unique processus léger qui exécute le main() de la classe appelée.
public class MaThread{
public static void main(String[] args) throws Exception{
Thread threadInitiale = Thread.currentThread();
threadInitiale.setName(« Thread initiale »);
System.out.println(threadInitiale);Thread.sleep(1000);
System.out.println(threadInitiale.isAlive());
Thread maThread = new Thread();
maThread.setName(« Ma thread »);
System.out.println(maThread);
System.out.println(maThread.isalive());
}
}
On obtient :$java MaThreadThread[Tread initiale,5,main]trueThread[Ma thread,5,main]false
Chaque processus léger :•appartient à un groupe de processus légers : ici main ;•et a une priorité : ici 5.
Présentation de POO-Java - p. 202Philippe Canalda
Démarrage et terminaison• Démarrage d’un processus léger par la méthode start() du thread• exécution du processus léger par le thread qui appelle la méthode run() de la cible qui
implémente l’interface runnable
La méthode run() se spécifie de 2 manières explicites :• en implémentant la méthode run() de l’interface Runnable ;• en redéfinissant la méthode run() de la classe Thread.
Le processus se termine à la fin du run().
La classe Thread possède 7 constructeurs qui spécifient :• le nom du processus léger, par défaut thread-i,• le groupe du processus léger, un objet de la classe ThreadGroup,• la cible (target) du processus léger : un objet implémentant l’interface Runnable qui
précise la méthode run() à exécuter lors du démarrage du processus léger.
Présentation de POO-Java - p. 203Philippe Canalda
Le lapin et la tortue (Version 1)Classe des lapinspublic class Lapin implements Runnable {
public void run(){
long t = System.currentTimeMillis(), x = t;
for(int i=0; i<5; i++) {
x = System.currentTimeMillis();
System.out.println(« Lapin» + i + « au temps » + (x-t) + « ms.»);
try { Thread.sleep(300); // un peu de repos } catch (InterruptedException e) {}}x = System.currentTimeMillis();System.out.println(« Le lapin est arrivé au temps » + (x-t) + « ms.»);
}
}
Présentation de POO-Java - p. 204Philippe Canalda
Classe des tortuespublic class Tortue implements Runnable {
public void run(){
long t = System.currentTimeMillis(),x = t;
for(int i=0; i<5; i++) {
x = System.currentTimeMillis();
System.out.println(« Tortue» + i + « au temps » + (x-t) + « ms.»);
try { Thread.sleep(500); // beaucoup plus de repos } catch (InterruptedException e) {}}x = System.currentTimeMillis();System.out.println(« La tortue est arrivé au temps » + (x-t) + « ms.»);
}
}
Mise en placepublic class MesThreadVersion1{
public static void main(String[] args){
Runnable tortue = new Tortue(), lapin = new Lapin();
Thread tortueThread = new Thread(tortue), lapinThread = new Thread(lapin);
tortueThread.start();
lapinThread.start();
}
}
Présentation de POO-Java - p. 205Philippe Canalda
On obtient :
Tortue 0 au temps 0 ms.
Lapin 0 au temps 0 ms.
Lapin 1 au temps 301 ms.
Tortue 1 au temps 508 ms.
Lapin 2 au temps 609 ms.
Lapin 3 au temps 919 ms.
Tortue 2 au temps 1017 ms.
Lapin 4 au temps 1224 ms.
Tortue 3 au temps 1535 ms.
Lapin est arrive au temps 1542 ms.
Tortue 4 au temps 2092 ms.
Tortue est arrivee au temps 2557 ms.
Les 2 thread ont la même priorité, donc même accès au processeur (équité au niveau de
l’accès au traitement et de la durée du traitement).
(L’équité d’accès n’est pas assurée sur toutes les implémentations des machines
virtuelles)
0
1
2
3
4
Fin thread lente
01234Fin thread rapide
Présentation de POO-Java - p. 206Philippe Canalda
Le lapin et la tortue (Version 2)Classe des lapins étend Threadpublic class Lapin extends Thread {
public void run(){
// inchangé
}
}
Classe des tortues étend Threadpublic class Tortue extends Thread {
public void run(){
// inchangé
}
}
Mise en placepublic class MesThreadVersion2{
public static void main(String[] args){
Thread tortueThread = new Tortue(), lapinThread = new Lapin();
tortueThread.start();
lapinThread.start();
}
}
Présentation de POO-Java - p. 207Philippe Canalda
Terminaison d ’un processus légerLa terminaison normale d’un processus léger est la fin de la méthode run().
On peut forcer la terminaison d’un processus léger avant la fin du run() en terminant l’application. L’application se termine lorsque :
• RunTime.exit() est appelé par l’un des processus légers ;• tous les processus légers qui n’ont pas été marqués daemon sont terminés.
Un processus léger peut-être user ou daemon. On peut créer des processus légers daemon à l’aide de la méthode setDaemon() de la classe Thread.
Exemple maThread.setDaemon(true);
Priorités d’accès au processeurLes niveaux de priorité d’accès au processeur varient de 1 à 10. Des constantes de la
classe Thread les définissent :
Thread.MAX_PRIORITY 10
Thread.NORM_PRIORITY 5
Thread.MIN_PRIORITY 1
On peut définir et consulter un niveau de priorité en appliquant l’une des méthodes de l’objet de contrôle du processus léger :
• setPriority()• getPriority()• setMaxPriority()
Présentation de POO-Java - p. 208Philippe Canalda
Exclusion mutuelleUne opération atomique est une opération qui ne peut-être interrompue une fois qu’elle a
commencé.• Java garantit l’atomicité de l’accès et de l’affectation des variables de type primitif
(hormis long et double).• Java possède un mécanisme d’exclusion mutuelle entre processus légers. Il garantit
l’atomicité d’exécution de morceaux de code.
Un verrou peut-être associé à une portion de code et permet d’exclure l’accès de 2 processus légers sur cette portion. Pour cela on synchronise une portion de code relativement à un objet en utilisant le mot clef synchronized :
• synchronized, comme modificateur d’une méthode, s’applique au code d’une méthode relativement à l’objet courant.
• synchronized(obj){… portion de code …};
Durant l’exécution d’un processus léger A d’une portion de code synchronized, tout autre processus léger essayant d’exécuter une portion de code synchronized relative au même objet est suspendu. Une fois A terminé, un seul des processus légers en attente est relancé.
Présentation de POO-Java - p. 209Philippe Canalda
Exemple : tableaupublic class Tableau {
private int[] t;
public synchronized int somme(){
int s=0;
for(int i=0;i<tableau.length;i++) s+=t[i];
return s;
}
public synchronized void setElement(int i, int j){ t[i]=j; };
}
Pendant l’exécution d’un x.setElement() ou d’un x.somme() dans un processus P, tout autre
processus Q qui essaie de faire x.setElement() ou x.somme() sur le même x est suspendu.
Exemple : tableau (variante)public class Tableau {
private int[] t;
public synchronized int somme(){
int s=0;
for(int i=0;i<t.length;i++) s+=t[i];
return s;
}
public synchronized void setElement(int i, int j){
if ((i <0) || i>= t.length) throw new IndexOutOfBoundsException();
synchronized(this){t[i]=j;};
}
}
Dans cette version, seule l’affectation est verrouillée.
Présentation de POO-Java - p. 210Philippe Canalda
Sûreté et vivacitéQuelques notions :• sûreté (safety) : rien de faux ne peut se produire. L’exclusion mutuelle règle/gère le
problème de l’accès concurrent en écriture : – R/R pas de problème– W/W problème– mais R/W ou W/R problème d’accès à résoudre
• vivacité (liveness) : tout processus peut s’exécuter.
La non vivacité d’une application ou d’un processus est effective lorsqu’il y a :• famine (contention) : un processus léger est empêché de s’exécuter parce que un, ou
plusieurs, processus plus prioritaire(s) accapare(nt) le processus ;• endormissement (dormancy) : un processus léger est suspendu mais jamais réveillé ;• terminaison prématurée ;• interblocage (deadlock) : plusieurs processus légers s’attendent mutuellement avant de
continuer.
Présentation de POO-Java - p. 211Philippe Canalda
Synchronisation entre processus légersJava propose 2 mécanismes :
• attente / notification avec wait() et notify() :
– wait() appelé sur un objet suspend le processus courant qui attend une notification d’un autre processus via le moniteur de l’objet,
– notify() appelé sur un objet libère un processus léger en attente par wait() sur le moniteur du même objet ;
• attente de terminaison avec join() :
– join() est appelé sur l’objet de contrôle d’un processus léger dont la terminaison est attendue. Le processus courant est alors interrompu jusqu’à la terminaison du processus léger attendu.
Les méthodes wait(), join() et sleep() peuvent être interrompues (et les processus
effectuant leur appel peuvent alors être débloqués). La méthode bloquante lève une
exception InterruptedException qui peut être captée / interceptée.
Présentation de POO-Java - p. 212Philippe Canalda
Exemple : les tourneurs et le compteurCinq processus légers, les tourneurs, veulent faire tourner un compteur (le compteur) qui
compte modulo 5.
La classe du compteur :
public class Compteur {
private int max; // 5 dans l’exemple
private int count = 0; // initialisation importante
public Compteur(int max){this.max=max;};
public int getMax(){return this.max;};
public int getValue(){return this.count;};
public synchronized void increment(){
this.count = (this.count +1) % this.max ; // l’objectif du tourneur
}
}
La règle du jeu : un Tourneur ne peut faire tourner le compteur que s’il est égal à son
numéro identifiant.
Présentation de POO-Java - p. 213Philippe Canalda
La classe du Tourneur :
public class Tourneur extends Thread {
private Compteur c; // le compteur
private int numero; // l’identifiant du tourneur
public Tourneur(int numero, Compteur c){
/* Construction récursive des tourneurs identifiés entre numero et max -1 */
System.out.println(«Tourneur »+numero+ «est créé.»);
this.numero=numero;
this.c=c;
if ((numero + 1) < c.getMax())
new Tourneur(numero +1, c);
System.out.println(« Tourneur » + numero + « démarre.»);
this.start();
}
public void run() {… //définition à venir};
public static void main(String[] args){
Compteur c = new Compteur(5);
new Tourneur(0,c);
}}
On obtient :$java TourneurTourneur 0 est créé.Tourneur 1 est créé.Tourneur 2 est créé.Tourneur 3 est créé.Tourneur 4 est créé.Tourneur 4 démarre....
Présentation de POO-Java - p. 214Philippe Canalda
public void run() {
try{
for(int etape=0; ;etape++){
System.out.println(«Tourneur » + this.numero + « dans l’etape »+etape);
synchronized(this.c){
while (this.numero != this.c.getValue())
this.wait();
// this.c.getValue() == numero du thread Tourneur courant
System.out.println(« Tourneur » + this.numero + « hors de l’etape »+etape);
this.c.increment();
this.notifyAll(); // libère tous les autres thread suspendus
}; // fin de la portion de code de synchronisation
}; // fin du for
} catch(InterruptedException e){}
}
…Tourneur 4 démarreTourneur 4 dans l’etape 0Tourneur 3 démarreTourneur 3 dans l’etape 0Tourneur 2 démarreTourneur 2 dans l’etape 0Tourneur 1 démarreTourneur 1 dans l’etape 0Tourneur 0 démarreTourneur 0 dans l’etape 0Tourneur 0 hors de l’etape 0Tourneur 1 hors de l’etape 0
Tourneur 2 hors de l’etape 0Tourneur 3 hors de l’etape 0Tourneur 4 hors de l’etape 0Tourneur 4 dans l’etape 1Tourneur 3 dans l’etape 1Tourneur 2 dans l’etape 1Tourneur 1 dans l’etape 1Tourneur 0 dans l’etape 1Tourneur 0 hors de l’etape 1Tourneur 1 hors de l’etape 1...
Présentation de POO-Java - p. 215Philippe Canalda
Exemple : maître et esclaveUn esclave « travaille » :
public class Esclave implements Runnable{
private int result;
public int getResult(){return this.result;};
public int durTravail(){return 0;};
public void run(){this.result=durTravail();};
}
}
Le maître fait travailler l’esclave, et attend par join(), la fin du processus esclave.
public class Maitre implements Runnable{
public void run(){
Esclave e = new Esclave();
Thread esclave=new Thread(e);
esclave.start();
// le maître fait quelque chose d’autre …
// puis ensuite il attend la fin du travail de l’esclave
try {
esclave.join(); // attente de la fin du run()
} catch(InterruptedException e) {};
int result=e.getResult();
System.out.println(result);
}
}
Présentation de POO-Java - p. 216Philippe Canalda
Mise en place:
public class TestMaitre {
public static void main(String[] args){
Maitre m=new Maitre();
Thread maitre = new Thread(m);
maitre.start();
}
}
Présentation de POO-Java - p. 217Philippe Canalda
Variables locales à un processus légerOn peut simuler des variables locales à chaque processus léger en :• créant un objet de la classe ThreadLocal ;• y accédant par Object get();• le modifiant par void set(Object o);
Exemple :
public class MaCible implements Runnable{
public ThreadLocal v =new ThreadLocal();
public void run(){
v.set(new Double(Math.random()));
System.out.println(v.get());
}
public static void main(String[] args){
MaCible c=new MaCible();
Thread t1=new Thread(c), t2=new Thread(c);
t1.start(); t2.start();
}
}On obtient :$java MaCible0.834568759030.23545436768897
Présentation de POO-Java - p. 218Philippe Canalda
SHARED MEMORY FOR JAVA THREADS* What variables are shared
- Rule: "All that's visible is shared"
- However:
- Variables created in a method are local (stack)
- Objects are shared (heap?), but in order to be used by other threads, they must be visible to them (e.g. having a visible object that points to them)
- NB: if each thread executes in run():
Toto t = new Toto();
then each thread creates a Toto object, and t points to its copy
(different objects with the same name)
* Putting main thread to do the same work as the others
** Method 1: run() (without start()) called from the main thread
MyThread master = new MyThread();
master.createThreads(); // create P-1 threads
master.run(); // do itself the same work
Présentation de POO-Java - p. 219Philippe Canalda
** Method 2: through a static method
public class MT extends Thread
{
int monid;
MT (int id){
this.monid = id;
}
public void run (){
Work.travail (monid);
}
public static void main (String[] args){
new MT(1).start();
new MT(2).start();
Work.travail(0);
}
}
class Work
{
public static void travail(int id){
// put here all the work to do by each thread
System.out.println ("id = " + id);
}
}
Présentation de POO-Java - p. 220Philippe Canalda
Partie VI Programmation Graphique :
Swing / Awt
Présentation de POO-Java - p. 221Philippe Canalda
La programmation graphiqueObjectif : Comment écrire des programmes (modernes et pages web) avec une GUI (Graphic
User Interface) :
a- spécifier et positionner des composants
b- Gérer des événements
c- ajouter des éléments d’interface
1- Introduction à Swing
2- Les composants Awt : evenments, components, containers, drawing
3- La structure des Jframe, buttons, menus
Présentation de POO-Java - p. 222Philippe Canalda
• Prise de notes du dernier cours par Jérémy Laurent
• Ce cours est le dernier. L’évaluation portera sur toute la partie du cours vue jusqu’à cette partie.
• Pour le projet tout ce qui suit est du bonus.• L’implémentation correcte du projet, si elle intègre
de l’interface, du réseau, du jdbc ou de l’xml, cela augmentera la grille d’évaluation du projet au-delà de 20.
Présentation de POO-Java - p. 223Philippe Canalda
Introduction à SwingSwing est le nom officiel du kit de développement d’interface graphique léger. Swing fait
partie des classes JFC (Java Foundation Class). Les JFC ne se limitent pas à swing en offrant des API d’accessibilité, de dessin 2D et de fonctionnalités drag and drop.
Swing ne remplace pas AWT mais fournit des composants d’interface plus performants.
La gestion d’événements de Swing et de AWT sont identiques et issus de Java 1.1.
Swing est moins dépendant de la plate-forme d’exécution, look and feel.
Mais AWT est plus performant pour les composants lourds, c’est-à-dire les applications qui
utilisent des ressources du système d’exploitation de la machine hôte.
Il est possible d’améliorer un look and feel existant voir en concevoir un nouveau :
cf. http://java.sun.com.products/jfc/tsc/ (rubrique Swing connection)
Présentation de POO-Java - p. 224Philippe Canalda
Partie VI a Les composants awt de Java
Présentation de POO-Java - p. 225Philippe Canalda
Les composants awt de Java(Abstract Windowing Toolkit)
1- Composants et conteneurs
2- Evénements
3- Dessins
Présentation de POO-Java - p. 226Philippe Canalda
Composants et conteneurs• Un composant est un objet de base de l’interface utilisateur de Java. C’est un objet
d’une classe dérivant de la classe java.awt.Component comme :– fenêtres, boutons, zones de dessin, menus, barres de défilement, …
• Un composant est généralement inséré dans un conteneur. Un conteneur est un objet de la classe java.awt.Container qui regroupe des composants.
• Un gestionnaire de placement (Layout Manager) gère la géométrie des composants ainsi que la disposition des composants dans un conteneur
Component
Container
Window
Panel
ScrollPane
Frame
DialogFileDialog
Applet
Présentation de POO-Java - p. 227Philippe Canalda
Gestionnaire de placementLes gestionnaires de placement sont des objets de classes qui implémentent l’interface
LayoutManager. Comme exemples de classes implémentant l’interface LayoutManager nous avons:• FlowLayout,• GridLayout,• BorderLayout,• BoxLayout
Chaque conteneur a un gestionnaire de placement par défaut :• setLayout() de la classe Container pour le modifier :
setLayout(new FlowLayout());• lorsque des objets sont ajoutés dans un conteneur, la mise à jour peut se demander par
la méthode validate() de la classe Component.
Présentation de POO-Java - p. 228Philippe Canalda
EvénementsLes programmes à interfaces graphiques sont pilotés par des événements. Un thread spécial,
nommé EventDispatchedThread, est créé par la machine virtuelle. Il est en charge de
l’interception (lecture) des événements et de la distribution de ces événements.
Un événement correspond à une action simple (enfoncement de la souris, pression d’une
touche, ...). On le désigne parfois par le vocable d’événement élémentaire.
Un événement sémantique consiste en une séquence d’événements élémentaires (clic de
souris, ...) synthétisés en un événement unique.
Le modèle émetteur-auditeur
• Un événement est émis (fired) par un composant.• Un événement est transmis aux auditeurs enregistrés.• Les auditeurs exécutent des méthodes en fonction de l’événement reçu.• Plusieurs auditeurs peuvent être enregistrés pour un événement.• Il existe différentes classes d’auditeurs (listeners) qui ont leurs propres méthodes.
Ces classes sont des interfaces à implémenter.
Exemple : créer des boutons en cliquant sur le premier(Exemple)
Présentation de POO-Java - p. 229Philippe Canalda
Créer des boutons en cliquant sur le premierimport java.awt.*;
import java.awt.event.*;
class BoutonNumerote extends Button {
static int numero = 1;
BoutonNumerote(){ setLabel(« Bouton »+this.numero);
this.numero++; };
}
public class BoutonFrame extends Frame {
public BoutonFrame() {
setTitle(« Création de boutons à la volée »);
Button b = new BoutonNumerote();
add(b);
b.addActionListener(new BoutonListener());
setSize(200,200);
setVisible(true);
}
public static void main(String[] )
new BoutonFrame(); }
}
class BoutonListener implements ActionListener{
public void ActionPerformed(ActionEvent e)(){
add(new BoutonNumerote());
validate();}
}
Présentation de POO-Java - p. 230Philippe Canalda
Version appliquetteimport java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
class BoutonNumerote extends Button {
static int numero = 1;
BoutonNumerote(){ setLabel(« Bouton »+numero);
numero++; };
}
public class BoutonApplet extends Applet {
public void init() {
BoutonNumerote b = new BoutonNumerote();
add(b);
b.addActionListener(new BoutonListener());
}
class BoutonListener implements ActionListener{
public void ActionPerformed(ActionEvent e)(){
add(new BoutonNumerote());
validate();}
}
}
Rmq : la classe BoutonListener est une classe interne (inner class) à BoutonApplet.
Présentation de POO-Java - p. 231Philippe Canalda
Version appliquette + compacteimport java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
class BoutonNumerote extends Button {
static int numero = 1;
BoutonNumerote(){ setLabel(« Bouton »+numero);
numero++; };
}
public class BoutonApplet extends Applet implements ActionListener{
public void init() {
BoutonNumerote b = new BoutonNumerote();
add(b);
b.addActionListener(this);
}
public void ActionPerformed(ActionEvent e)(){
add(new BoutonNumerote());
validate();}
}
Exemple : compter les clics sur les boutons
(exemple)
Présentation de POO-Java - p. 232Philippe Canalda
Compter les clics sur les boutonsimport java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
class BoutonCompteur extends Button {
int compteur = 0; }
String nom;
BoutonCompteur(String s){
super(s);
this.nom=s;};
}
public class Bouton2 extends Applet implements ActionListener{
BoutonCompteur b1,b2;
public void init() {
setLayout(new GridLayout(1,2,1,1));
b1 = new BoutonCompteur(« Nombre de clics ici : »);
b1.addActionListener(this);
b2 = new BoutonCompteur(« Nombre de clics la : »); b2.addActionListener(this);
add(b1); add(b2);
}
public void ActionPerformed(ActionEvent e)(){
BoutonCompteur b = (BoutonCompteur) e.getSource();
b.compteur++;
b.setLabel(b.nom+b.compteur);}
}
Présentation de POO-Java - p. 233Philippe Canalda
Exemple : cases à cocher(insérer capture d’écran)
Sortie :
iup_sesame >
Feminin
Celibataire
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class Cases extends Applet implements ActionListener{
Panel sexePanel, mariePanel, validationPanel;
CheckBoxGroup sexGroup, marieGroup;
public void init() {
setLayout(new GridLayout(3,1,1,1));
sexePanel=new Panel();
sexePanel.setBackGround(Color.green);
sexeGroup=new CheckBoxGroup();
sexePanel.add(new CheckBox(« Feminin »,sexeGroup,false));
sexePanel.add(new CheckBox(« Masculin »,sexeGroup,false));
...
Présentation de POO-Java - p. 234Philippe Canalda
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class Cases extends Applet implements ActionListener{
Panel sexePanel, mariePanel, validationPanel;
CheckBoxGroup sexGroup, marieGroup;
public void init() {
...
mariePanel=new Panel();
mariePanel.setBackGround(Color.orange);
marieGroup=new CheckBoxGroup();
mariePanel.add(new CheckBox(« Marie »,marieGroup,false));
mariePanel.add(new CheckBox(« Celibataire »,marieGroup,false));
validationPanel=new Panel();
validationPanel.setBackGround(Color.yellow);
Button b=new Button(« Valider »);
b.addActionListener(this);
validationPanel.add(b);
add(sexePanel); add(mariePanel); add(validationPanel);
setSize(getPreferredSize());
}
public void ActionPerformed(ActionEvent e)(){
CheckBox c = sexeGroup.getSelectedCheckBox();
CheckBox d = marieGroup.getSelectedCheckBox();
if (c != null) && (d != null)
System.out.println(c.getLabel()+ «\n» + d.getLabel());
}
}
Présentation de POO-Java - p. 235Philippe Canalda
DessinsL’outil de dessin est constitué du contexte graphique, c’est-à-dire un objet de la classe
Graphics. Cet objet encapsule les informations nécessaires pour définir et manipuler une
zone de dessin, parmi lesquelles nous trouvons :• l’objet composant sur lequel on va dessiner;• une translation d’origine;• le rectangle de découpe;• la couleur courante;• la police de caractère courante;• le mode opératoire logique de dessin (XOR ou Paint);• éventuellement la couleur du XOR.
Le contexte graphique ne représente pas le dessin lui-même. On l’obtient :• soit implicitement, dans une méthode paint() ou update() : le contexte graphique
construit est alors passé en paramètre ;• soit explicitement, en copiant un contexte graphique déjà existant ;• soit également explicitement, en faisant un getGraphics() dans un composant ou une
image.
L’acquisition explicite traduit une mauvaise utilisation de paint() ou d’update(). Il
faut alors libérer le contexte graphique explicitement par dispose().
La triplette magique : paint(), repaint() et update()Ce sont des méthodes de la classe Component :• paint(Graphics g) : ne fait rien par défaut, en pratique contient des appels de
méthodes de dessin de la classe Graphics sur g ;• update(Graphics g) : par défaut efface le dessin et appelle paint();• repaint(Graphics g) : appelle update() en lui fournissant un contexte graphique.
Présentation de POO-Java - p. 236Philippe Canalda
Exemple : gribouillageimport java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class Gribouille extends Applet {
int x0, y0, x, y;
public void init() {
addMouseListener(new Appuyeur());
addMouseMotionListener(new Dragueur());
}
public void update(Graphics g){paint(g);};
public void paint(Graphics g){
g.drawLine(this.x0,this.y0,this.x,this.y);
this.x0=this.x; this.y0=this.y;
};
// inner classes : Appuyeur et Dragueur
class Appuyeur implements mouseListener{
public void MousePressed(MouseEvent e) {
this.x0=e.getX(); this.y0=e.getY();
}
public void mouseEntered(MouseEvent e){};
public void mouseClicked(MouseEvent e){};
public void mouseExited(MouseEvent e){};
public void mouseReleased(MouseEvent e){};
}
...
Présentation de POO-Java - p. 237Philippe Canalda
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class Gribouille extends Applet {
int x0, y0, x, y;
...
class Dragueur implements MouseMotionListener{
public void mouseDragged(MouseEvent e){
this.x=e.getX();this.y=e.getY(); repaint();
}
public void mouseMoved(MouseEvent e){}
}
}• L’implémentation d’une interface demande l’écriture de toutes ses méthodes.• Un adapteur est une classe qui implémente une interface avec un comportement par
défaut.• Le paquetage java.awt.event contient un adapteur pour toute interface auditeur qui a au
moins 2 méthodes.
Présentation de POO-Java - p. 238Philippe Canalda
Gribouillage version 2import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class Gribouille2 extends Applet {
int x0, y0, x, y;
public void init() {
addMouseListener(new Appuyeur());
addMouseMotionListener(new Dragueur());
}
public void update(Graphics g){paint(g);};
public void paint(Graphics g){
g.drawLine(this.x0, this.y0, this.x, this.y);
this.x0= this.x; this.y0= this.y;
};
// inner classes : Appuyeur et Dragueur
class Appuyeur extends MouseAdapter{
public void MousePressed(MouseEvent e) {
this.x0=e.getX(); this.y0=e.getY();
}
class Dragueur extends MouseMotionAdapter{
public void mouseDragged(MouseEvent e){
this.x=e.getX(); this.y=e.getY(); repaint();
}
}
}
Présentation de POO-Java - p. 239Philippe Canalda
Gribouillage version 3Import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class Gribouille2 extends Applet {
int x0, y0, x, y;
public void init() {
addMouseListener(new MouseAdapter(){
public void MousePressed(MouseEvent e) {
this.x0=e.getX(); this.y0=e.getY();
}
});
addMouseMotionListener(new MouseMotionsAdapter(){
public void mouseDragged(MouseEvent e){
this.x=e.getX(); this.y=e.getY(); repaint();
}
});
}
public void update(Graphics g){paint(g);};
public void paint(Graphics g){
g.drawLine(this.x0, this.y0, this.x, this.y);
this.x0= this.x; this.y0= this.y;
};
}
Les classes Appuyeur et Dragueur sont devenues anonymes
Présentation de POO-Java - p. 240Philippe Canalda
Annexes• http://www-igm.univ-mlv.fr/~berstel/Cours/CoursJava/1-Composants.pdf
• http://www-igm.univ-mlv.fr/~berstel/Cours/CoursJava/8-Dessin.pdf
• http://igm.univ-mlv.fr/~forax/ens/ig/cours/pdf/*.pdfUI-11-Dessin.pdfUI-12-Menus.pdf...
Présentation de POO-Java - p. 241Philippe Canalda
Partie VI b Introduction à Swing
Présentation de POO-Java - p. 242Philippe Canalda
Introduction à Swing1- Exemples
2- La structure des JFrame
3- Menus
4- Boutons
Présentation de POO-Java - p. 243Philippe Canalda
Premier exemple// Fermeture de Frame Java, il faut redéfinir les listener appropriés
import java.awt.event.*;
import javax.swing.*;
class MyCloseableFrame extends JFrame {
/** Le constructeur d’une fenêtre pouvant se fermer, c.-à-d. tenir compte de l’événement
fermeture */
public MyCloseableFrame(){
super(« Ma Fenêtre »);
setSize(300,200);
addWindowListener(new WindowAdapter(){
public void WindowClosing(WindowsEvent e){
System.exit(0);
}
});
}
}
public class MyCloseableFrameTest{
public static void main(String[] args){
Jframe frame = new MyCloseableFrame();
frame.show();
}
}
Exécutable
Présentation de POO-Java - p. 244Philippe Canalda
Un certains nombres de remarques sont nécessaires :• Nous avons utilisé une classe interne anonyme pour définir l’auditeur;• la méthode show() est une méthode de la classe Window, qui est une classe mère de la
classe Frame. Elle permet d’afficher un composant.• Il n’est pas toujours aisé de savoir si une méthode est définie dans la classe
Component, Window ou Frame. Il faut donc consulter la doc !Exemples de méthodes :– Dans java.awt.Component :
boolean isEnabled();void setEnabled(boolean);void setVisible(boolean);
– Dans java.awt.Window :void toFront();void toBack();
– Dans java.awt.Frame :void setTitle(String);
En Java les cadres sont les conteneurs d’autres composants.
La structure des JFrame
JFrame
rootPane (JRootPane)
glassPane layeredPane (JLayeredPane)
contentPane (JPanel) menuBar (JMenuBar)
Présentation de POO-Java - p. 245Philippe Canalda
La structure des JFrameL’accès à la fenêtre contentPane se fait par la méthode getContentPane() de la classe
JFrame. Lire
JFrame
rootPane
layeredPanemenuBar
contentPane
glassPane
Présentation de POO-Java - p. 246Philippe Canalda
Deuxième exempleOn ne dessine pas ou on n’écrit pas directement dans une Jframe, on passe par son
contentPane qui est un JPanel. Exécutable
// Fermeture de Frame Java, il faut redéfinir les listener appropriés
import java.awt.event.*;
import javax.swing.*;
class MyJFrame extends JFrame {
public MyJFrame(){
super(« Ma fenêtre aimable »);
setSize(300,200);
JPanel p=new BonjourPanel();
getContentPane().add(p);
}
}
class BonjourPanel extends JPanel{
public void paintComponent(Graphics g){
super.paintComponent(g);
g.drawString(« Bonjour »,75,100);
}
}
public class MyJFrameTest{
public static void main(String[] args){
JFrame frame = new MyJFrame();
frame.show();
}
}
Présentation de POO-Java - p. 247Philippe Canalda
• La méthode paintComponent() est une méthode de la classe javax.swing.JComponent, qui dérive de Container, qui dérive elle-même de Component.
• Chaque fois qu’une fenêtre est re-dessinée, le gestionnaire d’événements Java envoie une notification à cette fenêtre. Les méthodes paintComponent() de tous les composants de la fenêtre sont alors exécutés.
• Il ne faut pas appeler soi-même paintComponent() puisque ceci est fait automatiquement.
Pour dessiner on peut utiliser java.awt.Graphics.
(insertion de la fenêtre aimable)
Présentation de POO-Java - p. 248Philippe Canalda
Actions générées par un menuLa classe abstraite javax.swing.AbstractAction permet de définir des actions. Exécutable
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class MyJFrameAction extends JFrame {
public MyJFrameAction(){
super(« Ma fenêtre d’actions colorées »);
setSize(300,200);
JPanel p=new JPanel();
getContentPane().add(p);
Action bleuAction=new CouleurAction(« Bleue »,Color.blue,p);
Action rougeAction=new CouleurAction(« Rouge »,Color.red,p);
Action vertAction=new CouleurAction(« Vert »,Color.green,p);
JMenu m=new JMenu(« Couleur »)};
m.add(bleuAction);
m.add(rougeAction);
m.add(vertAction);
JMenuBar mBar=new JMenuBar();
mBar.add(m);
setJMenuBar(mBar);
}
}
public class MyJFrameActionTest{ ...
Présentation de POO-Java - p. 249Philippe Canalda
public class MyJFrameActionTest{
public static void main(String[] args){
JFrame frame = new MyJFrameAction();
frame.show();
}
}
class CouleurAction extends AbstractAction{
private Component cible;
private Color couleur;
public CouleurAction(String nom,Color couleur,Component cible){
super(nom);
this.couleur=couleur;
this.cible=cible;
}
public void actionPerformed(ActionEvent e){
cible.setBackGround(couleur);
cible.repaint();
}
}
(insertion ma fenêtre menu couleur)
Présentation de POO-Java - p. 250Philippe Canalda
Exemple de JToggleButton(insertion de la fenêtre de choix)
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class MyToggleFrame extends JFrame {
public static void main(String[] args){
JFrame frame = new MyToggleFrame();
frame.show();
}
public MyToggleFrame(){
super(« Choisir la liaison PPP »);
getContentPane().add(new MyTogglePanel());
Dimension dim=getToolkit().getScreenSize();
setLocation(dim.width/2 - getWidth()/2), dim.height/2 - getHeight()/2);
pack();
setVisible(true);
setDefaultCloseOperation(WindowsConstants.DO_NOTHING_ON_CLOSE);
WindowsListener l=new WindowAdapter(){
public void WindowClosing(WindowEvent e){
...
Présentation de POO-Java - p. 251Philippe Canalda
class MyToggleFrame extends JFrame {
public static void main(String[] args){
JFrame frame = new MyToggleFrame();
frame.show();
}
public MyToggleFrame(){
super(« Choisir la liaison PPP »);
getContentPane().add(new MyTogglePanel());
Dimension dim=getToolkit().getScreenSize();
setLocation(dim.width/2 - getWidth()/2), dim.heught/2 - getHeight()/2);
pack():
setVisible(true);
setDefaultCloseOperation(WindowsConstants.DO_NOTHING_ON_CLOSE);
WindowsListener l=new WindowAdapter(){
public void WindowClosing(WindowEvent e){
int confirm=JOptionPane.showOptionDialog(MyToggleFrame.this,
« Voulez-vous vraiment quitter ? »,
« Confirmation Quitter »,
JOptionPane.YES_NO_OPTION,
JOptionPane.QUESTION_MESSAGE,
null,null,null);
if (confirm==0) System.exit();
}
}
this.addWindowListener(l);
}
}
Présentation de POO-Java - p. 252Philippe Canalda
class MyTogglePanel extends JPanel {
JPanel choixPanel, quitterPanel;
public MyTogglePanel(){
setLayout(new GridLayout(2,1,1,1));
choixPanel=new JPanel(new GridLayout());
quitterPanel=new JPanel(new GridLayout));
add(choixPanel);
add(quitterPanel);
JToggleButton button1=new JToggleButton(« PPP0 »,true);
Font bigFont=new Font(« Dialog »,Font.plain,24);
button1.setFont(bigFont);
choixPanel.add(button1);
JToggleButton button2=new JToggleButton(« PPP1 »,false);
button2.setFont(bigFont);
choixPanel.add(button2);
JToggleButton button3=new JToggleButton(« PPP2 »,false);
button3.setFont(bigFont);
choixPanel.add(button3);
ButtonGroup buttonGroup=new ButtonGroup();
buttonGroup.add(button1);
buttonGroup.add(button2);
buttonGroup.add(button3);
ActionListener actionPPP=new ActionListener(){
public void ActionPerformed(ActionEvent e) {...
Présentation de POO-Java - p. 253Philippe Canalda
class MyTogglePanel extends JPanel {
JPanel choixPanel, quitterPanel;
public MyTogglePanel(){
…
ActionListener actionPPP=new ActionListener(){
public void ActionPerformed(ActionEvent e) {
JToggleButton b=(JToggleButton) e.getSource();
System.out.println(« liaison »+b.getTexte());
}
};
button1.addActionListener(actionPPP);
button2.addActionListener(actionPPP);
button3.addActionListener(actionPPP);
JButton button4=new Jbutton(« quitter »);
button4.setFont(bigFont);
quitterPanel.add(button4);
ActionListener actionQuitter=new ActionListener(){
public void actionPerformed(ActionEvent e){
System.exit(0);
}
};
button4.addActionListener(actionQuitter);
}
}
Présentation de POO-Java - p. 254Philippe Canalda
Remarque :
méthodologiquement, il faut préférer définir un Jpanel qui pourra être ensuite inséré au
choix dans une JFrame ou bien dans une Applet.
Présentation de POO-Java - p. 255Philippe Canalda
Partie VI c INTERFACES GRAPHIQUES : SWING(d'après "Swing, la synthèse", de
V.Berthié et J-B Briaud)
Présentation de POO-Java - p. 256Philippe Canalda
Introduction à la programmation événementielle en Java
• - IHM (Interface Homme-Machine) : la partie visible à l'écran d'une application• - programmation événementielle : basé sur des évenements (+ IG)• - nouveaux concepts :• - avant : un programme commençait, faisait des calculs, ensuite il• finissait (gcc, apt-get)• - maintenant : le programme est toujours à l'attente d'un événement,• et il fait quelque chose en fonction de l'événement (emacs,• firefox, jeux, mathematica, openoffice.org)• - en général c'est mixte (avec beaucoup plus de temps pour• événements que pour calcul), ex. firefox : partie événementielle• pour taper l'URL, partie calcul pour l'affichage• - avant : affichage par du texte (System.out.println)• - maintenant : affichage de composants graphiques• - avant : exécuté dans un terminal, c'est lui qui gérait• l'affichage, donc pas besoin de sauvegarder l'état de l'affichage• - maintenant : nécessité de pouvoir peindre la fenêtre à tout moment• (par ex. minimize->maximize), quand des parties masquées• deviennent de nouveau visible• - avant : chaque fonction était appelée dans le programme lui-même• (appel explicite)• - après : callback functions (appel implicite)
Présentation de POO-Java - p. 257Philippe Canalda
Exemple : affichage d'un texte
• import javax.swing.*;• public class Swing{• public static void main (String[] args){• JFrame f = new JFrame ("Premier programme Swing"); // cree
fenetre• JLabel l = new JLabel ("Bonjour le monde !"); // cree texte• f.getContentPane().add (l); // ajoute le texte sur la fenetre• f.setSize (100, 100); // la taille de la fenetre• f.show (); // affiche la fenetre• }• }
Présentation de POO-Java - p. 258Philippe Canalda
AWT vs. Swing
• beaucoup de bibliothèques d'IG : Java (AWT, Swing), gtk, qt, windows
• (MFC de Microsoft, VCL de Borland), avec "binding" dans plusieurs
• langages de programmation• - AWT - interface native• - Swing - interface gérée par Java, écrite en Java• - nous allons utiliser que Swing (classes commençant par J
pour composants)• - Button (AWT) -> JButton (Swing)
Présentation de POO-Java - p. 259Philippe Canalda
Composants de base• ** JLabel• - affiche texte• - JLabel (String nom), setIcon (new ImageIcon ("icone.jpg"))• - setText (String nom), getText• ** JTextField• - champ de saisie de texte (String !)• - JTextField (String nom)• - setText (String nom), getText ()• - setEditable (boolean)• - copy (), cut (), paste ()• ** JButton• - bouton simple, avec un texte et/ou une image• - JButton (String), JButton (String, Icon)• - setRolloverIcon (Icon), setPressedIcon (Icon)• - setMnemonic ('n') - ALT-n appuie sur le bouton• ** JToggleButton• - bouton à deux états (enfoncé ou non)• - setIcon (non enfoncé), setSelectedIcon (enfoncé)• - setSelected (boolean), isSelected ()
Présentation de POO-Java - p. 260Philippe Canalda
Composants de base• ** JCheckBox, JRadioButton• - boutons radio, cases à cocher• - ButtonGroup g = new ButtonGroup ();• JRadioButton rb1 = new JRadioButton ("Allemagne");• JRadioButton rb2 = new JRadioButton ("France");• JRadioButton rb3 = new JRadioButton ("Espagne");• rb2.setSelected (true);• g.add (rb1);• g.add (rb2);• g.add (rb3);• - JCheckBox cb1 = new JCheckBox ("Entree");• JCheckBox cb2 = new JCheckBox ("Plat");• JCheckBox cb3 = new JCheckBox ("Fromage");• JCheckBox cb4 = new JCheckBox ("Dessert");• ** JComboBox• - liste déroulante pour choisir un item• - deux états : fermé ou ouvert• - JComboBox (Vector), JComboBox ()• - new Vector (), add• - addItem• - setEditable (boolean)
Présentation de POO-Java - p. 261Philippe Canalda
Composants de base• ** Autres• *** JProgressBar• - une barre montrant la progression d'une tâche• - JProgressBar (int orientation, int min, int max)• - getValue (), setValue (int)• - setString (String), getString ()• *** JSlider• - barre permettant de déplacer un curseur pour choisir une valeur• - plus facile d'utilisation qu'un JTextField• - http://java.sun.com/docs/books/tutorial/uiswing/components/slider.html• - JSlider (int orientation, int min, int max, int initialvalue)• - setValue (int), getValue ()• - espacement des "tics" de l'axe• *** JSpinner• - deux petites flèches permettant d'augmenter ou réduire une valeur• - http://java.sun.com/docs/books/tutorial/uiswing/components/spinner.html• - trois types : liste, nombres et dates• - voir le lien ci-dessus pour plus d'informations• *** JTextArea etc.
Présentation de POO-Java - p. 262Philippe Canalda
Caractéristiques communes des composants de base
• ** Activation / désactivation• - défini en JComponent• - setEnabled (boolean), isEnabled ()• ** Visibilité• - setVisible (boolean), isVisible ()• - exemple : version démo = options invisibles• ** Curseurs• - l'apparence du curseur sur un composant• - setCursor (new Cursor(Cursor.WAIT_CURSOR));• ** Tooltips (boules d'aide)• - setToolTipText (String)• ** Couleurs• - setBackground (Color.red)• - setForeground (Color.blue)• ** Menus• - classes :• - JMenuBar - top menu line• - JMenu - top menu item• - JMenuItem - menu item• - JMenuItem.addSeparator () ou classe Separator - line menu item• - JCheckBoxMenuItem - check box menu item• - JCheckBoxMenuItem.setState (boolean)• - méthodes :• - JFrame.setJMenuBar (JMenuBar)• - JMenuBar.add (JMenu)• - JMenu.add (JMenuItem)• - JMenu.addSeparator ()
Présentation de POO-Java - p. 263Philippe Canalda
• - exemple :• JMenuBar barre = new JMenuBar ();• frame.setJMenuBar (barre);• JMenu f = new JMenu ("Fichier");• barre.add (f);• JMenuItem i = new JMenuItem ("Nouveau");• f.add (i);• i.addActionListener (new Ecouteur()); // Ecouteur spécifie l'action• i.setAccelerator (KeyStroke.getKeyStroke ('c'));• ** Taille préférée• - setPreferredSize (new Dimension (largeur, hauteur));
Présentation de POO-Java - p. 264Philippe Canalda
Containers et fenêtres• ** JFrame, JDialog• - JFrame - fenêtre principale, avec décorations (barre de titre)• - setDefaultCloseOperation (int flag) spécifie quoi faire si le• JFrame est fermé• - pour quitter l'application : setDefaultCloseOperation (EXIT_ON_CLOSE)• - JDialog - fenêtre secondaire (a toujours un parent), sans• décorations, peut être modale• - modale : empêche le travail sur les autres fenêtres tant qu'elle• n'est pas fermée• - JDialog jd = new JDialog (JFrame, true); // true = modale• - show (), hide ()• - spécifier la taille :• - rigide : setSize (int largeur, int hauteur)• - flexible : pack () - la taille de la fenêtre en fonction de la• taille préférée de ses composants• - dispose () - fait disparaître et la mémoire occupée peut être• libérée (ramasse-miettes)
Présentation de POO-Java - p. 265Philippe Canalda
Containers et fenêtres• ** Containers• - objets contenant des composants• - tout objet Swing est container, mais seuls quelques-uns sont utilisés• - JFrame, JDialog (fenêtres)• - JPanel - container minimal (vide)• - .add, .remove• - pour JFrame, JDialog on utilise getContentPane().add etc.• - comment placer les composants à l'intérieur : layout managers (voir• plus bas)• ** JScrollPane• - normalement, si un composant déborde le container, il est invisible• - il nous faut des scroll bars pour le container• - au lieu d'ajouter le container à la fenêtre, on ajoute un ScrollPane• qui le contient :• - JPanel container = new JPanel ();• - getContentPane().add (new JScrollPane (container));
Présentation de POO-Java - p. 266Philippe Canalda
Dessiner : classe Graphics• - classe abstraite fournissant des méthodes pour dessiner• - lignes, rectangles, cercles, définir la couleur du crayon, la police• (drawLine, drawOval, drawString etc.)• - origine d'un objet Graphics : haut-gauche• - tout composant a un objet Graphics associé• - pour dessiner, il faut obtenir l'objet Graphics qui lui est associé• ** Première méthode (sans rafraîchissement)• - étapes :• - getGraphics () sur un composant• - retourne null si erreur• - faire les dessins• - g.dispose ()• ** Deuxième méthode (rafraîchissement automatique)• - pour dessiner tout composant, JVM appelle son paint (), qui appelle :• paintComponent(Graphics)• paintBorder(Graphics)• paintChildren(Graphics)• - il faut redéfinir la méthode protected void paintComponent (Graphics g)• - notion de "callback function"• - getGraphics et dispose automatiques• - utiliser toujours cette méthode !• ** Composant de dessin• - dériver une classe de JPanel• - lui redéfinir la méthode paintComponent• - forcer le réaffichage d'un composant :• - panel.repaint (panel.getVisibleRect ());
Présentation de POO-Java - p. 267Philippe Canalda
Événements
• - événements : tout ce qui est interaction avec l'utilisateur :• - souris (clic...), clavier (appui touche...), focus, sélection d'un item...• - écouteur : méthode qui gère (est appelée pour) un ou plusieurs événements• - java.awt.event.*;• ** Exemple• JButton jb = new JButton ("Bouton non appuyé");• jb.addActionListener (new Ecouteur ());• ...• class Ecouteur implements ActionListener{• public void actionPerformed (ActionEvent e){• jb.setText ("Bouton appuyé");• }• }
Présentation de POO-Java - p. 268Philippe Canalda
Événements• ** Exemples d'événements• - clic sur un bouton - ActionEvent• - clic sur un JPanel - MouseEvent• - frappe d'une touche sur JPanel - KeyEvent• - passage du focus à un composant - FocusEvent• - iconification d'une fenêtre - WindowEvent• - sélection d'un item dans une JList - ListSelectionEvent• - tous ces événements encapsulent le composant graphique (la source) et• les coordonnées du clic, la touche frappée etc.• - la source peut être obtenue avec XYZEvent.getSource ()• ** Utilisation• - on écrit une classe (Ecouteur) qui implante l'interface qui nous• intéresse, e.g. ActionListener, WindowListener...• - pour trouver les événements qu'un composant peut générer, on• regarde dans la documentation ses méthodes addXYZListener• - on écrit les méthodes demandées par l'interface• - on lie un objet de cette classe (l'écouteur) à l'objet qui est la• source de l'événement :• jb.addActionListener (new Ecouteur ());• - (un même composant peut avoir plusieurs écouteurs, qui seront• appelés l'un après l'autre)
Présentation de POO-Java - p. 269Philippe Canalda
Événements• *** Classes internes• - peuvent accéder aux champs privés de la classe mère• - appropriées pour les classes écouteur, si elles ne sont pas réutilisées• - ExtClass.IntClass i = new ...()• ** Adaptateurs• - exemple : pour fermer la fenêtre, on devrait implanter• addWindowListener, mais elle a 7 méthodes :• - windowOpened (WindowEvent e)• - windowClosing• - windowClosed• - windowIconified• - windowDeiconified• - windowActivated• - windowDeactivated• - ce qui nous intéresse est seule windowClosing• - solution : adaptateur - classe non abstraite avec des méthodes vides,• ce qui nous permet d'écrire seules les méthodes qui nous intéressent• - windowAdapter dans ce cas• ** Terminologie• - pour le "type" XYZ :• - XYZEvent - la classe événement• - addXYZListener - méthode du composant pour y ajouter un écouteur• - XYZListener - interface avec les méthodes nécessaires à l'événement• - les méthodes ont comme paramètre un XYZEvent• - XYZAdapter (si elle existe) - classe non abstraite fournissant un• corps vide à toutes les méthodes du XYZListener
Présentation de POO-Java - p. 270Philippe Canalda
Gestionnaires d'affichage (layout managers)
• - gère le placement des composants à l'intérieur d'un container• - non précis (et difficile à comprendre), car il doit traiter le• placement pour toute taille du container• - méthode setLayout (LayoutManager) du container• - import java.awt.*;• ** Exemple• - mettre dans un container 6 boutons en 3 lignes et 2 colonnes :• setLayout (new GridLayout (3, 2));• add (new JButton ("1"));• add (new JButton ("2"));• add (new JButton ("3"));• add (new JButton ("4"));• add (new JButton ("5"));• add (new JButton ("6"));• ** BorderLayout• - le gestionnaire par défaut d'un JFrame.getContentPane()• - divise le container en 5 parties : S, N, E, W, C• jp.add (Component, BorderLayout.SOUTH);• ** GridLayout• - divise le container en rectangles de taille égale• - GridLayout (int nblignes, int nbcol)• - méthodes setColumns, setRows etc.• ** FlowLayout• - le gestionnaire par défaut de JPanel• - place les composants du container l'un après l'autre, de gauche à• droite
Présentation de POO-Java - p. 271Philippe Canalda
Gestionnaires d'affichage (layout managers)
• ** Beaucoup d'autres• - CardLayout : plusieurs composants au même endroit, un seul à la fois• est affiché• - GridBagLayout : on précise l'endroit précis ou chaque composant se• trouve à l'intérieur d'une grille• - SpringLayout : chaque composant précise la distance par rapport aux• composants voisins• - etc.• ** Combinaison des gestionnaires• - créer plusieurs JPanel, chacun avec le gestionnaire approprié
Présentation de POO-Java - p. 272Philippe Canalda
Applets
• - programmes téléchargeables sur Internet et exécutés localement• - téléchargés à partir d'une page Web (HTML)• - exécution :• - on crée une page Web qui contient un lien vers l'applet• - on charge la page dans un navigateur ou dans un "visualiseur• d'applets" (appletviewer, fourni par Java SDK)• - navigateurs, compatibilité avec JDK 1.2• ** Page basique HTML• - fichier a.html exécutant l'applet de MonApplet.java :• <HTML>• <BODY>• <APPLET code=MonApplet width=207 height=170></APPLET>• </BODY>• </HTML>
Présentation de POO-Java - p. 273Philippe Canalda
Applets• ** Particularités• - différences par rapport à un programme classique basé sur un JFrame :• - JFrame -> JApplet• - main -> init• - setTitle, setSize - interdites (car la taille est définie par la• page Web)• - sécurité (SecurityException) :• - pas d'accès ou d'exécution des fichiers locaux• - pas d'obtention d'informations système sensibles (nombre• d'utilisateurs, la charge du système etc.)• - méthodes automatiquement appelées :• - en-tête de ces méthodes : public void XYZ ()• - init : après la création de l'objet applet• - mettre ici le code d'initialisation de l'applet• - destroy : fermeture du navigateur ou de l'appletviewer• - stop : chaque fois que l'applet devient invisible, puis avant destroy• - faire arrêter ici les gros calculs (s'il y en a)• - start : après init, puis chaque fois que l'applet redevient visible• - faire redémarrer ici les gros calculs (s'il y en a)
Présentation de POO-Java - p. 274Philippe Canalda
Hiérarchie des classes• Component• Container (conteneur de composants) : méthode add• JComponent• AbstractButton• JButton• JMenuItem• JMenu• JCheckBoxMenuItem• JRadioButtonMenuItem• JToggleButton• JCheckBox• JRadioButton• JComboBoxpossibles• JFileChooser• JLabel• JList• JMenuBar• JPanel• JPopupMenu• JScrollBar• JTextComponent• JTextArea• JTextField• JToolBar• Window• Frame• JFrame• Dialog• JDialog• Panel• Applet• JApplet
Présentation de POO-Java - p. 275Philippe Canalda
• - remarques :
• - tout est container
• - applet = panel spécialisé
Présentation de POO-Java - p. 276Philippe Canalda
Divers
• - JFileChooser - classe pour choisir un fichier• - "look and feel" paramétrable• UIManager.setLookAndFeel(new MetalLookAndFeel());• UIManager.setLookAndFeel(new SynthLookAndFeel());• - Java beans• - convention d'écriture d'une classe : set/getX, isX• - tous les composants sont des beans
Présentation de POO-Java - p. 277Philippe Canalda
Partie VII Les flots
Présentation de POO-Java - p. 278Philippe Canalda
Les flots1- Généralités
2- Flots d’octets, flots de caractères
3- Les filtres
4- Comment lire un entier
5- Manipulation de fichiers
6- Flots d’objets ou sérialisation
Présentation de POO-Java - p. 279Philippe Canalda
GénéralitésUn flot (stream) est un canal de communication dans lequel on peut lire ou écrire. On
accède aux données de manière séquentielle.
Les flots prennent des données, les transforment éventuellement, et sortent les données
transformées.
Pipeline ou filtrageLes données d’un flot d’entrées s’écoulent d’une source, comme celle de l’entrée standard
ou bien encore celle d’un fichier, d’une chaîne, ou d’un tableau de caractères. Elle peut
aussi s’écouler d’une sortie d’un autre flot d’entrée.
De manière similaire, les données d’un flot de sortie se déversent dans un tube, comme
celui de la sortie standard ou celle d’un fichier, ou bien encore comme celui de l’entrée
d’un autre flot de sortie.
En Java les flots manipulent soit des octets, soit des caractères. Certains flots
manipulent des données typées. Toutes les classes se trouvent dans le paquetage java.io.
Les classes de base sont :• File
RandomAccessFile• InputStream
OutputStream• Reader
Writer• StreamTokenizer
Les Stream, Reader et Writer sont abstraites. Les Stream manipulent des octets, les Reader
et Writer manipulent des caractères.
Hiérarchie des classes...
Présentation de POO-Java - p. 280Philippe Canalda
Hiérarchie des classesFichiers• File
FileDescriptorRandomAccessFile
Streams• InputStream
– ByteArrayInputStream– FileInputStream– FilterInputStream
• BufferedInputStream• DataInputStream• LineNumberInputStream• PushBackInputStream
– ObjectInputStream– PipedInputStream– SequenceInputStream
• OuputStream– ByteArrayOutputStream– FileOututStream– FilterOututStream
• BufferedOututStream• DataOutputStream• PrintStream
– ObjectOutputStream– PipedOutputStream
Reader• ...
Présentation de POO-Java - p. 281Philippe Canalda
Hiérarchie des classes…
Reader• Reader
– BufferedReader• LineNumberReader
– CharArrayReader– FilterReader
• PushBackReader
– InputStreamReader• FileReader
– PipedReader– StringReader
Writer• Writer
– BufferedWriter– CharArrayWriter– FilterWriter– OutputStreamWriter
• FileWriter
– PipedWriter– PrintWriter– StringWriter
Présentation de POO-Java - p. 282Philippe Canalda
Flots d ’octets et de caractèresLes flots d’octets en lectureObjet d’une classe dérivant de InputStream.
System.in est un flot d’octet en lecture. Les méthodes pour lire à partir du flot :• int read() : lit un octet dans le flot, le renvoie comme octet de poids faible d’un int
ou renvoie -1 si la fin du flot est atteinte ;• int read(byte[] b) : lit au plus b.length octets dans le flot et les met dans b,
renvoie le nombre d’octets lus ou bien renvoie -1 si la fin du flot est atteinte ;• int read(byte[] b, int off, int len) : lit au plus len octets et les met dans b à
partir de la position n° off de b ;• int available() : retourne le nombre d’octets disponibles dans le flot ;• void close() : ferme le flot.
Les flots d’octets en écritureObjet d’une classe dérivant de OutputStream.
System.out est de la classe PrintStream, qui dérive de FilterOutputStream, qui dérive de OutputStream. Les méthodes pour écrire dans le flot :
• int write(int b) : écrit dans le flot, l’octet de poids faible de b ;• int write(byte[] b) : écrit dans le flot tout le contenu du tableau b ;• int write(byte[] b, int off, int len) : écrit dans le flot len octets de b à partir de
la position n° off de b ;• void close() : ferme le flot.
Lire un octet...
Présentation de POO-Java - p. 283Philippe Canalda
Lire un octetimport java.io.*;
public class Lire {
public static void main(String[] args){
try{
int i=System.in.read();
System.out.println(i);
} catch (IOException e){};
}
}
On obtient :
$ java Lire
a
97
Lire des octetsimport java.io.*;
public class Lire {
static int EOF=(int) ’\n’;
public static void main(String[] args)throws IOException{
int i;
while ((i=System.in.read()) != EOF)
System.out.print(i+ « »);
System.out.println(«\nFin »);
}
}
On obtient :$ java Lirea é97 32 130 13Fin
Présentation de POO-Java - p. 284Philippe Canalda
Les flots de caractères en lectureObjet d’une classe dérivant de Reader.
Les méthodes pour lire à partir du flot :• int read() : lit un caractère dans le flot, le renvoie comme octet de poids faible d’un
int ou renvoie -1 si la fin du flot est atteinte ;• int read(char[] b) : lit au plus b.length octets dans le flot et les met dans b,
renvoie le nombre d ’octets lus ou bien renvoie -1 si la fin du flot est atteinte ;• int read(char[] b, int off, int len) : lit au plus len carctères et les met dans b à
partir de la position n° off de b ;• int available() : retourne le nombre de caractères disponibles dans le flot ;• void close() : ferme le flot.
Rmq : les méthodes sont analogues à celle des flots d’octets en lecture.
Les flots de caractères en écritureObjet d’une classe dérivant de Writer.
Les méthodes sont là-aussi analogues à celles des flots d ’octets.
Les filtresUn filtre est un flot qui enveloppe un autre flot.
Quel en est le principe ? Les données sont, selon, lues ou écrites dans le flot enveloppé
mais après un traitement (codage, compaction, bufferisation, etc.). Le flot enveloppé est
passé en argument du constructeur du flot enveloppant.
Les filtres héritent des classes abstraites :• FilterInputStream (ou FilterReader)• FilterOutputStream (ou FilterWriter)
Présentation de POO-Java - p. 285Philippe Canalda
Les filtres prédéfinis : • DataInputStream, DataOutputStream : les méthodes sont writeType(), readType(), où Type doit
être remplacé par Int, Char, Double, etc. ;• BufferedInputStream : permet de bufferiser un flot ;• PushBackInputStream : permet de replacer des données lues dans le flot avec la méthode unread()
:• PrintStream : System.out est de la classe PrintStream :• InputStreamReader : transforme un Stream en Reader ;• BufferedReader : bufferise un flot de caractères ;• LineNumberReader : pour une lecture de caractères ligne par ligne ; • …
Lire des entiers : avec LineNumberReaderLa classe LineNumberReader dérive de la classe BufferedReader.
La méthode String readLine() de la classe BufferedReader retourne la ligne suivante.
class Lire{
public static int lireInt() throws IOException {
InputStreamReader in=new InputStreamReader(System.in);
LineNumberReader data=new LineNumberReader(in);
String s=data.readLine();
return Integer.parseInt(s);
}
}
class TestLireUnEntierLineNumberReader{
public static void main(String[] args){
int i=Lire.lireInt();
System.out.println(i);
}
}
Présentation de POO-Java - p. 286Philippe Canalda
Lire une suite d’entiers : avec StreamTokenizerUn StreamTokenizer prend en argument un flot (reader) et le fractionne en « token »
(lexèmes). Les attributs sont : • nval : contient la valeur (double) si le lexème est un nombre ;• sval : contient la valeur si le lexème courant est un mot ;• TT_EOF, TT_EOL, TT_NUMBER, TT_WORD : valeurs de l’attribut ttype. Si un token n’est ni
un mot, ni un nombre, il contient alors l’entier représentant le caractère.
class LireMulti{
public static void lire() throws IOException {
StreamTokenizer in;
InputStreamReader w=new InputStreamReader(System.in);
in=new StreamTokenizer(new BufferedReader(w));
in.quoteChar(‘/’);
in.wordChars(‘@’,‘@’);
do {
in.nextToken();
if (in.ttype == (int) ‘/’)
System.out.println(in.nval);
if (in.ttype == StreamTokenizer.TT_NUMBER)
System.out.println((int) in.nval); // valeur double
if (in.ttype == StreamTokenizer.TT_WORD)
System.out.println(in.sval);
} while (in.ttype != StreamTokenizer.TT_EOF);
}
}
Présentation de POO-Java - p. 287Philippe Canalda
Lire une suite d ’entiers : avec StreamTokenizer (suite)class TestLireMulti{
public static void main(String[] args){
LireMulti.lire();
}
}
Pour$ cat paul.txt0 @I1@ INDI1 NAME Paul /Le Guen/0 TRLROn obtient :$ java TestLireMulti < paul.txt0@I1@INDI1NAMEPaulLe Guen0TRLR
Présentation de POO-Java - p. 288Philippe Canalda
Manipulation de fichiersLes sources et puits des Stream et Reader sont :• les entrées et sorties standard (printf) ;• les String (sprintf) ;• les fichiers (fprintf).
Pour les String, il y a les StringReader et StringWriter.
Pour les fichiers il y a les stream et reader correspondant.• La classe java.io.File permet de manipuler le système de fichiers ;• Les classes FilesInputStream, et FileOutputStream, définissent des flots de lecture et
d’écriture de fichiers d’octets,et les classes FileReader et File Writer définissent les flots de lecture et d’écriture de fichiers de caractères.
La classe File permet d’observer une représentation d’un fichierimport java.io.*;
public class InfoFichier{
public static void main(String[] args) throws Exception{
info(args[0]);}
public static void info(String nom) throws FileNotFoundException{
File f=new File(nom);
if (!f.exists()) throw new FileNotFoundException();
System.out.println(f.getName()); System.out.println(f.isDirectory());
System.out.println(f.canRead()); System.out.println(f.canWrite());
System.out.println(f.length());
}
}
On obtient :$ ls -l fichierEssai-rw-r--r-- 1 canalda lifc 488 Dec 29 11:45 fichierEssaijava InfoFichier FichierEssaifichierEssaifalsetruetrue488
Présentation de POO-Java - p. 289Philippe Canalda
Lecture d ’un fichierUn lecteur de fichier est le plus souvent défini par :
FileReader f=new FileReader(nom); // nom désigne le nom de fichier, et les méthodes de
// lecture sont celles de la classe InputStreamReader
/** La lecture par bloc*/
FileInputStream in=new FileInputStream(nomIn);
FileOutputStream out=new FileOuputStream(nomOut);
int readLength;
byte[] block=new byte[8192];
while ((readLength = in.read(block)) != -1)
// nous ne sommes pas arrivé en fin de fichier ou il y a qqch à lire
out.write(block, 0, readLength);
/** La lecture d’un fichier de texte ligne par ligne */
public String readFile(String f) throws IOException{
FileReader fileIn=new FileReader(nom);
BufferedReader in=new BufferedReader(fileIn);
StringBuffer s=new StringBuffer();
String line;
while ((line = in.readLine()) != null)
s.append(line + «\n»);
fileIn.close();
return s.toString();
}
Présentation de POO-Java - p. 290Philippe Canalda
Les flots d’objets ou sérialisationUn flot d’objet permet d’écrire ou de lire des objets Java dans un flot.
On utilise pour cela les filtres ObjectInputStream. Ce service est appelé sérialisation.
Les applications qui échangent des objets via le réseau utilisent la sérialisation.
Pour sérialiser un objet, on utilise la méthode d’un flot implémentant l’interface ObjectOutput : void writeObject(Object o).
Pour désérialiser un objet, on utilise la méthode d’un flot implémentant l’interface ObjectInput : Object readObject().
Pour qu’un objet puisse être inséré dans un flot, sa classe doit implémenter l’interface Serializable. Cette interface ne contient pas de méthode.
La première fois qu’un objet est sauvé, tous les objets qui peuvent être atteints à partir de cet objet sont également sauvés. En plus de l’objet, le flot sauvegarde un objet appelé handle qui représente une référence locale de l’objet dans le flot. Une nouvelle sauvegarde de l’objet dans le flot entraîne la sauvegarde du handle à la place de l’objet.
Exemple de sauvegardeimport java.io.*
public class Point implements Serializable{
private int x, y;
public Point(int xx, int yy){this.x=xx;this.y=yy};
public String toString(){return «(» + this.x + «,» + this.y + «)»;}
public void sauvePoint(String nom) throws Exception{
File f=new File(nom);
...
}
}
Présentation de POO-Java - p. 291Philippe Canalda
Exemple de sauvegardeimport java.io.*
public class Point implements Serializable{
private int x, y;
public Point(int xx, int yy){this.x=xx; this.y=yy};
public String toString(){return «(» + this.x + «,» + this.y + «)»;}
public void sauvePoint(String nom) throws Exception{
File f=new File(nom);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(this);
out.close(); // fin de la partie sauvegarde
ObjectInputStream in= new ObjectInputStream(new FileInputStream(f));
Point oBis=(Point) in.readObject();
in.close();
System.out.println(this);
System.out.println(oBis);
System.out.println(this.equals(oBis));
}
public static void main(String[] args){
Point o = new Point(1,2);
o.sauvePoint(args[0});
}
}
On obtient :$ java Point sauvePoint.txt(1,2)(1,2)false
Présentation de POO-Java - p. 292Philippe Canalda
Redéfinir l’objet de sauvegardeAu moment de la sauvegarde, il est possible de remplacer un objet par un autre. Pour cela il
s’agit :• de redéfinir la méthode Object writeReplace() dans la classe de l’objet à remplacer ;• et au moment de la désérialisation, d’utiliser la méthode ObjectResolve() de la classe de
l’objet remplacé, pour retourner un objet compatible avec l’original.
Exemple Liste d’entiers to liste string : une liste d’entiers est remplacée par une liste d’entiers sous forme de chaîne de caractères
class Serial{
public static void main(String[] args) throws Exception{
Liste l=new Liste(1,new Liste(2, null)); // l=(1,(2,null))
l.ecrireListe(args[0]); l.lireListe(args[0]);}
}
public class Liste implements Serializable{
int val;
Liste next;
public Liste(int v, Liste n){val=v;next=n};
Object writeReplace() throws ObjectStreamException{
Liste ltmp;
StringBuffer sb=new StringBuffer();
for(ltmp=this;ltmp!=null;ltmp=ltmp.next)
sb.append(« »+ltmp.val);
return new ListeString(sb.toString());
}
...
Présentation de POO-Java - p. 293Philippe Canalda
Exemple Liste d ’entiers to liste string : une liste d ’entiers est remplacée par une liste d ’entiers sous forme de chaîne de caractères
public class Liste implements Serializable{
…
public String toString(){return «(» + val + «,» + next + «)»};
public void ecrireListe(String nom) throws Exception{
ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(nom));
out.writeObject(this);
out.close();
}
public void lireListe(String nom) throws Exception{
ObjectInputStream in=new ObjectInputStream(new FileInputStream(nom));
Liste l=(Liste) in.readObject();
System.out.println(l);
}
}
class ListeString implements Serializable{
String s;
ListeString(String s){this.s=s;};
Object readResolve() throws ObjectStreamException{
StringTokenizer st=new StringTokenizer(s);
return resolve(st);
}
Liste resolve(StringTokenizer st){...}
}
Présentation de POO-Java - p. 294Philippe Canalda
Exemple Liste d ’entiers to liste string : une liste d ’entiers est remplacée par une liste d ’entiers sous forme de chaîne de caractères
public class Liste implements Serializable{
…
}
class ListeString implements Serializable{
String s;
ListeString(String s){this.s=s;};
Object readResolve() throws ObjectStreamException{
StringTokenizer st=new StringTokenizer(s);
return resolve(st);
}
Liste resolve(StringTokenizer st){
if (st.hasMoreTokens()) {
int val=Integer.parseInt(st.nextToken());
return new Liste(val, resolve(st));
} else return null;
}
} On obtient :$ java Serial toto(1,(2,null))$file totototo: Java Serializable data, version 5
Présentation de POO-Java - p. 295Philippe Canalda
Partie VIII Xml
Présentation de POO-Java - p. 296Philippe Canalda
Partie IX Network
Présentation de POO-Java - p. 297Philippe Canalda
PROGRAMMATION RÉSEAU EN JAVA
• - guide networking : http://java.sun.com/j2se/1.4.2/docs/guide/net
• - Java 2 SE 4 API : file:///usr/share/doc/libgcj-doc/html/index.html
Présentation de POO-Java - p. 298Philippe Canalda
Programmation client/serveur
• - communication => deux programmes :• - serveur, qui est à l'écoute• - continue (se remet à l'écoute) même après avoir traité la• demande• - en général, il crée un processus/thread (il "fork") qui traite• la demande et lui, en parallèle, se remet à l'écoute => il• peut communiquer simultanément avec plusieurs clients• - généralement, c'est lui qui transmet les données• - contre-exemples : serveur FTP et on y dépose des fichiers• - client, qui fait la demande• - finit après que la demande ait été traitée
Présentation de POO-Java - p. 299Philippe Canalda
Perte de type lors du transfert
• - int a, b;• a = b;• => pas de problème• - sur le réseau, si on envoie a on ne sait plus de l'autre côté
qu'il• s'agit d'un entier !• => c'est à nous (le protocole application) de se gérer cela• - par ex., on envoie et on reçoit toujours un entier, ensuite
un• float, ensuite une chaîne de caractères finissant par \0
Présentation de POO-Java - p. 300Philippe Canalda
Conversion byte[] <-> String et autre• - String -> byte[] :
• String s = "hello";• byte[] b = s.getBytes ();• - byte[] -> String :• String s = new String (byte[] data, int offset, int count);• offset (indice à partir duquel on commence) est généralement 0• String (byte[] data) existe aussi, mais il convertit tout le tableau !!• - s'il y a d'autres types :• DataInputStream dis = new DataInputStream (new• ByteArrayInputStream (packet.getData ())));• short v1 = dis.readShort ();• long v2 = dis.readFloat ();• char c = dis.readChar (); // pour String aussi, avec une boucle for• - ASN.1 (Abstract Syntax Notation), network order : en java, pas de• souci, le langage utilise les conventions réseau• - ex. : int est stocké sur 4 octets, indépendamment de la machine
Présentation de POO-Java - p. 301Philippe Canalda
Adressage, classe InetAddress
• - sans constructeur
• - création d'un objet, par méthodes statiques :
• getLocalHost ()
• getByName (String)
• - (Inet4Address, Inet6Address : spécifiques à IPv4 et IPv6)
Présentation de POO-Java - p. 302Philippe Canalda
Transfert en mode non connecté (UDP)
• - mode non connecté : les paquets sont indépendants• - orienté paquet (pour un grand volume de données, c'est à
nous de le• découper en paquets)• - les paquets peuvent être :• - perdus• - dupliqués• - désordonnés (les paquets, pas les données, arrivent en
désordre)
Présentation de POO-Java - p. 303Philippe Canalda
Exemple, étapes
• - serveur :• - s'enregistre auprès du SE pour écouter sur un certain port (en• Java : crée une socket)• - se met en attente de paquets• - quand un paquet lui arrive, fait le traitement nécessaire (en• général, renvoi d'une réponse)• - avant la fin, libère le port• - client :• - choisit un port (en Java : crée une socket)• - crée un paquet pour une certaine destination• - envoie le paquet• - libère le port
Présentation de POO-Java - p. 304Philippe Canalda
Exemple en Java• import java.net.*;• import java.io.*;
• public class Serveur{• public static void main (String args[]) throws IOException, SocketException{• byte[] msg = new byte[1500];• int sport = 33000; // le port sur lequel on ecoute• DatagramSocket s = new DatagramSocket (sport);• DatagramPacket p = new DatagramPacket (msg, msg.length); // l'objet• // ou le paquet est stocke• s.receive (p); // blocage jusqu'a reception d'un paquet• s.close (); // ferme la socket, libère le port• System.out.println (new String (p.getData (), 0, p.getLength ()));• }• }
Présentation de POO-Java - p. 305Philippe Canalda
Exemple en Java• import java.net.*;• import java.io.*;
• public class Client{• public static void main (String args[])• throws IOException, SocketException, UnknownHostException{• int sport = 33000;• String m = "Hello world!";• byte[] msg = m.getBytes ();• DatagramSocket s = new DatagramSocket (); // le port est• // choisi au hasard par le SE• DatagramPacket p = new DatagramPacket (msg, m.length (),• InetAddress.getLocalHost (), sport);• s.send (p);• s.close (); // ferme la socket, libère le port• }• }
Présentation de POO-Java - p. 306Philippe Canalda
DatagramSocket et le port, discussion• - pour le client :
• - réservation d'un port aléatoire libre : new DatagramSocket ();
• - réservation des ports :• - http: //cczxc TODO• - mieux vaut entre 33000 et 65000• - on ne peut pas se "lier" ("to bind") à un port plusieurs
fois !• On reçoit BindException à l'exécution• - fermeture du port recommandé (.close)
Présentation de POO-Java - p. 307Philippe Canalda
DatagramPacket, discussion
• - pour le récepteur des données :• - automatiquement rempli avec les données reçues• - longueur des données : p.getLength (), car on ne peut pas se fier• au msg.length !• - si msg.length < p.getLength (), la fin des données est perdue• - pour l'émetteur des données :• - on met nous-mêmes les données à envoyer, l'adresse et le port• destination• - données : sans type, donc byte[] et longueur• - pour les deux :• - p.getAddress () retourne l'InetAddress de l'autre extrémité
Présentation de POO-Java - p. 308Philippe Canalda
Transfert en mode connecté (TCP)
• - mode connecté : les paquets forment un tout• - orienté flux (c'est TCP qui découpe les données
en morceaux/paquets• de la bonne taille)• - garanties :• - fiabilité• - non-duplication• - ordonnancement
Présentation de POO-Java - p. 309Philippe Canalda
Exemple, étapes
• - serveur :• - s'enregistre auprès du SE pour écouter sur un certain port (en• Java : crée une socket)• - se met en attente de connexion• - quand une connexion est créée, fait le traitement nécessaire (par• ex. le renvoi d'un fichier)• - ferme la socket• - libère le port• - client :• - choisit un port et se connecte à une certaine machine + port (en• Java : crée une socket)• - reçoit/envoie des données• - ferme la socket et libère port
Présentation de POO-Java - p. 310Philippe Canalda
Exemple en Java• import java.net.*;• import java.io.*;
• public class Server{• public static void main (String args[]) throws IOException{• byte[] msg = new byte[3000];• for (int i=0 ; i<msg.length ; i++)• msg[i] = (byte)(i % 10);• int sport = 40000; // le port sur lequel on ecoute• ServerSocket ss = new ServerSocket (sport); // erreur si port utilise• Socket s = ss.accept (); // bloque jusqu'a l'arrivee d'une connexion• OutputStream os = s.getOutputStream (); // recupere le canal de transm• os.write (msg);• s.close (); // fermeture de la connexion => informe le peer• // de la fin des donnees• ss.close (); // liberation du port• System.out.println ("fin");• }• }
Présentation de POO-Java - p. 311Philippe Canalda
Exemple en Java• import java.net.*;• import java.io.*;
• public class Client{• public static void main (String args[])• throws IOException, UnknownHostException{• int nb; // nombre d'octets lus• int sport = 40000;• byte[] msg = new byte[1];• Socket s = new Socket ("localhost", sport);• InputStream is = s.getInputStream ();• while ((nb = is.read (msg)) != -1)• System.out.print (msg[0]); // affiche le 1er octet des donnees• s.close ();• }• }
Présentation de POO-Java - p. 312Philippe Canalda
Communication, entrées/sorties, discussion
• - Socket = extrémité d'une connexion TCP• - InputStream, OutputStream : flux binaires• - OutputStream :• - write (byte[] b) écrit TOUS les bytes de la variable b• - write (b, offset, length) écrit length bytes à partir d'offset• (offset est par ex. 0)• - InputStream :• - la méthode read bloque jusqu'à réception d'au moins 1 octet• - read (byte[] b) remplit la variable b, sauf s'il y a moins de données• - => voir son code de retour : -1 si EOF, ou bien le nombre octets lus• - lire/écrire les types primitifs dans les flux binaires : les classes• DataOutputStream et DataInputStream• - création de l'objet : DataInputStream dos = new DataInputStream (os);• - readInt (), writeInt (int) : lit, écrit un int• - readDouble (), writeDouble (byte) : lit, écrit un double• - readUTF (), writeUTF (String) : lit, écrit un String• - etc. : lancent EOFException si EOF
Présentation de POO-Java - p. 313Philippe Canalda
Transfert au niveau application
• - HTTP et FTP fournis pour l'instant
• - d'autres peuvent être définis par le programmeur
• - la classe URL :
• - crée la connexion TCP
• - crée l'en-tête de niveau application
• - envoie la requête
Présentation de POO-Java - p. 314Philippe Canalda
• import java.net.*;• import java.io.*;
• public class Server{• public static void main (String args[]) throws IOException{• URL u = new URL ("http://www.univ-fcomte.fr");• DataInputStream br = new DataInputStream ((InputStream)u.getContent ());• for (int i=0 ; i<10 ; i++)• System.out.println (br.readLine ());• }• }
Présentation de POO-Java - p. 315Philippe Canalda
Partie X JDBC - Java Data Base Connection
Présentation de POO-Java - p. 316Philippe Canalda
JDBC ( Java DataBase Connectivity )
Présentation de POO-Java - p. 317Philippe Canalda
Motivations
• Par défaut, les bases de données réseaux ne sont accessibles que par des commandes SQL.
• Pour construire des applications à partir de SGBD réseaux, les éditeurs fournissent des API (Application Programming Interface : ensemble de procédures et de fonctions) spécifiques à leurs SGBDs.
• Pour le langage Java, Sun a proposé une API générique d'accès aux bases de données : JDBC.
Présentation de POO-Java - p. 318Philippe Canalda
Spécifications de JDBC
• Utiliser SQL
• S'inspirer des API existantesen particulier d'ODBC (API générique d'accès aux SGBD pour le langage C sur les systèmes Microsoft)
• Être simple
• Être générique (valable quelque soit la base de données)
Présentation de POO-Java - p. 319Philippe Canalda
Besoin de drivers
• JDBC utilisable pour accéder à n'importe quel SGBD présent ou futur
• Or les SGBD sont différents les uns des autres
il faut utiliser un pilote (driver) pour faire l'interface entre l'API JDBC et une base particulière !!
Présentation de POO-Java - p. 320Philippe Canalda
Mise en œuvrede
JDBC
Présentation de POO-Java - p. 321Philippe Canalda
• Importer les paquetages JDBC import java.sql.* ;
• Charger les driversClass.forName("nomDuDriver").newInstance();(pour nous, "nomDuDriver" sera "org.gjt.mm.mysql.Driver")
– Diverses exceptions peuvent être levées, en particulier si le driver n'est pas trouvé. Par conséquent, on doit capturer l'exception générique « Exception »
– Si on doit accéder à plusieurs bases, plusieurs drivers peuvent être chargés.
Présentation de POO-Java - p. 322Philippe Canalda
• Établir une connexion(correspond à la commande "mysql -u cece -h serveur.fr -pxZ6gW absencesProfs")
Connection co = DriverManager.getConnection( "jdbc:mysql://serveur.fr/absencesProfs", // URL de la base
"cece", // login "xZ6gW"); // mot de passe
• getConnection peut lever l'exception "SQLException" (si la connexion n'a pu s'établir).
Présentation de POO-Java - p. 323Philippe Canalda
• Construire un objet StatementStatement sql = co.createStatement();
– Permet d'exécuter des requêtes– On peut avoir plusieurs Statement par connection– Permet aussi de récupérer les warnings,...– Peut lever l'exception "SQLException".
Présentation de POO-Java - p. 324Philippe Canalda
Exécution d'une requête SQL
• Requêtes ne produisant pas de résultat(CREATE, INSERT, UPDATE, ALTER, DROP, etc...)
int nbLignes = sql.executeUpdate( "INSERT INTO absence(motif, date, prof)" +
"VALUES ('sieste hebdomadaire'," + " '2003-11-07', 'Cece')" ) ;
– Retourne le nombre de lignes modifiées– Peut lever SQLException (pb de connexion, requête non
valide, etc...).
Présentation de POO-Java - p. 325Philippe Canalda
• Requête produisant un résultat
ResultSet result =
sql.executeQuery("SELECT distinct motif " +
"FROM absence WHERE prof='Cece'");
– L'ensemble des lignes est stocké dans un objet de type ResultSet
– Peut lever SQLException (raisons identiques au cas qui précède)
Présentation de POO-Java - p. 326Philippe Canalda
Lecture du résultat d'une requête
• boolean encore = result.next() ;– peut lever SQLException (pb de connexion, requête
non valide, etc...).– passe à la ligne suivante.– retourne false s'il ne reste plus de ligne à parcourir.– retourne true s'il reste des lignes à parcourir.
!!! DOIT être exécuté avant de consulter la première ligne !!!
Présentation de POO-Java - p. 327Philippe Canalda
• int nb = result.getInt("num")– peut lever SQLException– retourne sous forme d'entier le contenu de la colonne "num" de
la ligne courante– retourne 0 si le contenu est NULL.
• String mot = result.getString("motif");– peut lever SQLException– retourne sous forme de String le contenu de la colonne "motif".– retourne null si le contenu est NULL.
Présentation de POO-Java - p. 328Philippe Canalda
Autres méthodes de ResultSet
• getDouble("note")
• getDate("naissance")• getTime("heure")• ...
• getXxx(3) – retourne le contenu de la 3ième colonne sous la forme
d'un Xxx. (les indices pour les colonnes commencent à 1 et non à 0)
Présentation de POO-Java - p. 329Philippe Canalda
Fermer les Statement et Connection
• sql.close();
• co.close();
Présentation de POO-Java - p. 330Philippe Canalda
Types Java et SQL
Présentation de POO-Java - p. 331Philippe Canalda
Types de base et objets simples
(*) avec un « import java.sql.* ; »
(**) n’existe pas en MySQL
Attention, en Java une constante "Float" doit être suivie de la lettre "F".
Ex. : float x = 3.14F
BOOLEAN (**)boolean
CHAR(n) ou VARCHAR(n)String
TIMETime (*)
DATEDate (*)
REALfloat
DOUBLE, FLOATdouble
INTEGER ou INTint
SQLJava
Présentation de POO-Java - p. 332Philippe Canalda
Chaînes de caractères versusObjets
Présentation de POO-Java - p. 333Philippe Canalda
Exemple
• Créons sur le serveur MySQL une table de schéma : evaluation(coefficient, note)
• Peut-on écrire en Java ? : double co = 2.5;
double no = 15.6;
String str = "INSERT INTO evaluation(coefficient, note) " +
"VALUES (co, no) "
int nbLignes = sql.executeUpdate(str);
NON !!!
Présentation de POO-Java - p. 334Philippe Canalda
• Il faut que : str
"INSERT INTO evaluation(coefficient, note) " +
"VALUES (2.5, 16.6)"
• Ce qui revient à : "INSERT INTO evaluation(coefficient, note) " +
"VALUES (" + str_co +", " + str_no + ")"
avec – str_co = "2.5"– str_no = "15.6"
Présentation de POO-Java - p. 335Philippe Canalda
Vers une chaîne de caractères
• String.valueOf(x)Chaîne de caractères correspondant à x (valeur d'un type de base ou objet d'une classe quelconque)
• Exempleint n = 3 ;
boolean b = true ;
String s = String.valueOf(n) + " " + String.valueOf(b) ;
• Remarque :Si x est un objet d'une classe X, la méthode String.valueOf(x) fait appel à la méthode toString() de la classe X
Présentation de POO-Java - p. 336Philippe Canalda
A partir d'une chaîne de caractères
• Types de baseType de x Instruction à employerint Integer.valueOf("123").intValue() ;boolean Boolean.valueOf("false").booleanValue();double Double.valueOf("3.14158").doubleValue();float Float.valueOf("2.7183F").floatValue();
Objets
Type de x Instruction à employerTimeDate Date.valueOf("2001-03-5");
Time.valueOf("9:45:00"); // il faut absolument les trois champs
Présentation de POO-Java - p. 337Philippe Canalda
Exemple
Time ti;
Date da;
String st;
ti = Time.valueOf("9:45:00");
da = Date.valueOf("2001-03-5");
st = " date " + String.valueOf(da) + ", time " + String.valueOf(ti);
System.out.println(st);
Affiche : date 2001-03-05, time 09:45:00
Présentation de POO-Java - p. 338Philippe Canalda
Remarque
valueOf peut lever l'exception IllegalArgumentException quant on passe d'une chaine mal construite vers un type : int, double, ..., Date, Time.
Présentation de POO-Java - p. 339Philippe Canalda
Métadonnées
(données sur les données )
Présentation de POO-Java - p. 340Philippe Canalda
Exemple
Comment afficher le contenu d'une table T dont on ne connaît que le nom ?
– Faire une requête "SELECT * FROM T" et demander à l'objet ResultSet, ainsi obtenu, le nombre et la liste de ses colonnes. (c-à-d : demander à la base de données -- des informations -- sur les données qu'elle contient)
– Afficher la liste des noms des colonnes, puis le contenu des colonnes.
Présentation de POO-Java - p. 341Philippe Canalda
Intermède par transparent
Présentation de POO-Java - p. 342Philippe Canalda
ResultSetMetaDataA partir d'un objet ResultSet, set, on obtient un objet ResultSetMetaData, rmeta, qui contient comme informations :
– le nombre de colonnes,– le nom de chaque colonne,– la taille de la zone d'affichage de chaque colonne,– la possibilité de lire une colonne donnée,– la possibilité d'écrire dans une colonne donnée,– la présence d'un champ "AUTO_INCREMENT",
....
Présentation de POO-Java - p. 343Philippe Canalda
DatabaseMetaData
Nous pouvons aussi recueillir des méta-données sur le serveur :– le type du serveur, [ ici MySQL ]– son numéro de version,– la liste des bases présentes sur le serveur,– la liste des tables d'une base,– les privilèges associés à chaque table, colonne, ...– la présence de telle ou telle caractéristique
• (liste des mots clés non SQL92, liste des fonctions mathématiques, liste des fonctions sur les chaînes de caractères, possibilités de modifier les tables, …)
Présentation de POO-Java - p. 344Philippe Canalda
Exemple
Connection co =
DriverManager.getConnection(url, user, password);
DatabaseMetaData meta = co.getMetaData();
System.out.println("SGBD : " + meta.getDatabaseProductName() + "\n" + "version : " + meta.getDriverVersion() + "\n" +
"pilote : " + meta.getDriverName() );
Présentation de POO-Java - p. 345Philippe Canalda
L’examen terminal valide :
– Tout ce qui a été vu en TD
– Tous les concepts du cours (pas l’introspection)• Surtout l’héritage, l’interface, la délégation, la surcharge, la redéfinition,
les design patterns, les exceptions, les collections et les maps, les threads, AWT/SWING, et les flux
• Pour les derniers, les illustrations sont celles du cours ou du projet (et la notation finalene désavantage personne)
– Forme des exercices / compétences :• Diagramme de classe, RI, programmation orientée interface, rigueur et
présentation
• Dérouler un programme, concevoir le diagramme objet de l’application, méthodologie de réalisation
Recommended