23 - Classe abstraite ** permet de définir des méthodes sans les

23 - Classe abstraite
� permet de définir des méthodes sans les implémenter : méthode abstraite
abstract <definition_de_methode>;
� classe abstraite
abstract <definition_de_classe>
{ ...
� une classe abstraite n'est pas instanciable
� on peut définir une classe abstraite sans méthode abstraite
� une sous-classe non abstraite d'une classe abstraite doit définir explicitement
toutes les
méthodes abstraites
abstract class GeometriePlane
{ static final double PI=3.14159 ;
abstract double perimetre();
abstract double surface();}
class Rectangle extends GeometriePlane
{ double largeur,longueur;
double perimetre()
{return 2*(largeur+longueur);}
double surface()
{return largeur*longueur;}}
Exemple
24 - Interface
� "classe" entièrement abstraite
� sans variable d'instance, avec des méthodes abstraites et des constantes uniquement
� interface publique
� toutes les méthodes sont implicitement abstraites et publiques et héritées par toute classe
qui
implémente l'interface
� classe qui implémente une interface doit définir toutes ses méthodes pour être instanciable
(non abstraite)
� Une classe peut
� hériter d'une classe au plus
� MAIS, implémenter plusieurs
interfaces
� Une interface peut "hériter" de
plusieurs interfaces
Héritage multiple
� pour définir un type abstrait : une
interface
décrit un ensemble de comportements, mais ne
les implémente pas
� pour implémenter l'héritage multiple
Pourquoi utiliser une interface?
interface Geometrie
{static final double PI=3.14159 ;}
interface Courbe extends Geometrie
{ double longueur();}
interface Surface extends Geometrie
{ double surface() ;}
Exemple
class Rectangle
implements Courbe, Surface
{ double largeur,longue;
public double longueur()
{return 2*(largeur+longue);}
public double surface()
{return largeur*longue;}}
Interface I1
m()
class C
m()
Interface I2
m()
implements
Si les méthodes m() de I1 et I2 ont la même signature et :
- même type de retour : C doit implémenter m()
- des types de retour différents : impossible
Si les méthodes m() de I1 et I2 n'ont la même signature
C doit implémenter les deux méthodes m()
25 – Classes internes
Classe définie dans une autre classe
Quatre types différents :
� Classes internes membres
� Classes internes membres statiques
� Classes internes locales
� Classes internes anonymes
Classe interne membre
� permet de définir plusieurs
instances de la classe interne, liés à une même instance de la
classe englobante
class Ext
{ int var;
public class Interne
{//accède à toutes les variables de Ext
int x;
this.x=Ext.this.var;
}
...
}
Ext o=new Ext();
Ext.Interne i1=o.new Interne();
Ext.Interne i2=o.new Interne();
Création d'objets internes
Classe interne membre
statique
class Ext
{ static int var;
static public class IntStat
{//accède aux variables statiques de Ext
int x;
x=var;
}
...
}
Ext o1=new Ext();
Ext o2=new Ext();
Ext.IntStat i1=new Ext.IntStat();
Ext.IntStat i2=new Ext.IntStat();
Création d'objets internes
Classe interne locale
class Ext
{ final int var;
public Iterator m()
{ class IteratorSpecial implements Iterator
{//accède aux variables final accessibles de Ext
public boolean hasNext() {. . .}
public Object next() {. . .}
public void remove() {. . .}
}//class IteratorSpecial
return new IteratorSpecial();
}//methode m()
...
}// class Ext
Ext o1=new Ext();
Iterator i=e.m();
while (i.haxNext())
{ . . . i.next(). . .
Création d'objets internes
Classe interne anonyme
class Ext
{ final int var;
public Iterator m()
{
return new Iterator(){
public boolean hasNext() {. . .}
public Object next() {. . .}
public void remove() {. . .}
}; //new
}//methode m()
...
}// class Ext
Ext e=new Ext();
Iterator i=e.m();
while (i.haxNext())
{ . . . i.next(). . .
Création d'objets internes
Quand utiliser une classe anonyme?
� quand une seule instance est nécessaire
� quand le nom de la classe interne locale n'est pas utile
� pour écrire un code plus concis
� AWT
� SWING
II - Interfaces graphiques
� composants légers, écrits en Java, indépendants du système natif
� pluggable look and feel
� ensemble d'outils graphiques beaucoup plus important que dans AWT
� inclus dans le JDK depuis la versions 1.2
Une première fenêtre
public class Fenetre extends Frame
{ final static int HTAILLE=550;
final static int VTAILLE=450;
public Fenetre(){
setTitle("Ma première fenêtre");
setSize(HTAILLE,VTAILLE);
setVisible(true);}}
Avec ce code, la fenêtre ne peut pas se fermer …
Ouvrir la fenêtre
class Test{
public static void main(String arg[]){
Fenetre f=new Fenetre();}}
Toute application graphique commence par créer un objet Frame
Dessiner
� utiliser la classe Graphics
package java.awt
� méthodes de la classe Graphics :
clearRect() drawLine() drawRect() drawOval()
drawArc() drawImage()
fillRect() fillOval() drawString() setColor()
…
� origine du système de coordonnées : coin haut
gauche
Affichage du dessin
� un objet Component se dessine lorqu'il reçoit le message
paint()
� la méthode paint()
est appelée quand le dessin d’un objet Component doit être mis à jour
(première visualisation, changement de taille, réaffichage)
� l'objet est redessiné complètement à chaque appel de la méthode paint()
� les méthodes update() et repaint() permettent de mettre à jour l'objet
La méthode paint(Graphics gc)
� définie dans Component, ne fait rien
� doit être redéfinie dans des classes dérivées de
Frame, Canvas, Applet, pour dessiner l’objet s’il
n’est pas utilisé comme objet Container
� l'objet Graphics en argument
� représente le contexte graphique de l’objet
Component
� reçoit les messages permettant de dessiner
� est fourni par la machine virtuelle
La classe java.awt.Graphics
� est abstraite
� regroupe toutes les méthodes de dessin
� ne peut pas être instanciée par un new
� accès aux instances de la classe avec les méthodes paint(), update()
d'un objet Component
Contexte graphique Exemple
public class Fenetre extends Frame
{ public Fenetre()
{}p{}ub.l.i.c vogi.ddrpaawiSnttr(iGnrga(p"hHieclslog"),100,100);
}
Méthodes repaint() et update()
La méthode update()
� est appelée indirectement par la méthode repaint()
� remplit le composant avec sa couleur de fond
� initialise la couleur du premier plan
� appelle paint()pour redessiner l'objet Component
La classe java.awt.Component
� classe abstraite
� super-classe de Canvas, Container, Frame,
Applet, Button,…
� méthodes :
getParent() getPeer() getToolkit()
getBackground() setBackground()
getForeground() setForeground()
paint() repaint() update() …
Classes dérivées
� objets Container
et getGraphics()
utilisés pour contenir d'autres objets ou pour afficher directement des dessins
� Window
Dialog : boîtes
un titre
Frame :
l'hôte
de dialogue ayant un cadre et
fenêtres du système graphique de
objets utilisés comme zone d'affichage pour ajouter des composants ou dessiner
directement
� objets Canvas
rectangles blancs utilisés pour définir des composants graphiques personnalisés dessinés en
utilisant les méthodes de la classe Graphics
� autres objets
� Panel :
Button, Chekbox, List, Choice, Label
Scollbar, TextComponent
Disposition des composants
� Chaque objet Container mémorise la liste des
objets qui lui sont ajoutés (add() ) ou enlevés (remove() )
� Un objet Container dispose ses composants à l'écran en
utilisant un objet Layout associé qui
gère la disposition
� quelques méthodes de la classe Container
public Component add(Component c)
public Component add(String name, Component c)
public Component add(Component c, Object Constraints)
Objets LayoutManager
� gèrent la mise en page des composants d'interface
� différents types : FlowLayout, BorderLayout,
GridLayout, CardLayout, GridBagLayout
� les objets Container ont un gestionnaire par défaut
pour Panel et Applet : FlowLayout
pour Window, Dialog et Frame : BorderLayout
� choix d'un gestionnaire de mise en
forme
avec la méthode setLayout()
� exemple :
setLayout(new FlowLayout());
Objets MenuComponent
Menu : un objet Menu contient des objets MenuItem
MenuBar
MenuItem
Exemple : un éditeurgraphique
Une classe FenetreEditeur
public class FenetreEditeur extends Frame
{ final static int HTAILLE=550;
final static int VTAILLE=450;
public FenetreEditeur()
{
setTitle("Editeur graphique");
setSize(HTAILLE,VTAILLE);
setVisible(true);}}
Une classe MenuEditeur
public class MenuEditeur extends MenuBar
{ public MenuItem menuNouveau, menuQuitter, menuApropos public MenuEditeur(){
Menu menuFichier = new Menu("Fichier");
menuNouveau = new MenuItem("Nouveau");
menuQuitter = new MenuItem("Quitter");
menuFichier.add(menuNouveau) ;
menuFichier.add(menuQuitter) ;
Menu menuAide = new Menu("aide");
menuApropos = new MenuItem("Apropos");
menuAide.add(menuApropos);
add(menuFichier);
add(menuAide); }
seul un objet Frame peut contenir un menu
public FenetreEditeur(){
setTitle("Editeur graphique");
setMenuBar(new MenuEditeur());
setSize(HTAILLE,VTAILLE);
setVisible(true);}
Ajouter un objet Menu
Ajouter une objet Panel
public class BarreOutils extends Panel{
public BarreOutils(){
Choice listeCouleur ;
String libelleCoulleurs[]="Rouge","Jaune","Vert"};
Color couleurs[]={Color.blue,Color.red,Color.yellow,Color.green};
this.setBackground(Color.lightGray);
listeCouleur=new Choice();
for (int i=0;i<libelleCouleurs.length;i++)
listeCouleur.addItem(libelleCouleurs[i]);
listeCouleur.select(0);
add(listeCouleur);
add(new Button("Défaire"));
add(new Button("Effacer tout"));
add(new Button("Quitter"));}}
public class FenetreEditeur extends Frame{
final static int HTAILLE=550;
final static int VTAILLE=400;
public FenetreEditeur (){
ZoneGraphique graphique;
setTitle("Editeur graphique");
setSize(HTAILLE,VTAILLE);
setBackground(Color.darkGray);
add(new BarreOutils(),"North");
add(new ZoneGraphique(),"Center");
setMenuBar(new MenuEditeur());
setVisible(true);}
}// classe FenetreEditeur
2. Evénements
� Toute action sur les éléments de l'interface utilisateur génère un événement
� Un événement déclenché par une action sur une objet AWT est un objet de type
java.awt.AWTEvent
� Flux d'événement et traitement de l'événement sont traités séparément
Types d'événements
� événements de clavier
� événements de souris : clics, mouvements
� événements de fenêtre : ouverture, fermeture, sortie
� événements d'interface utilisateur liés aux fonctionnalités des composants : clics
ouverture de menu popups, ...
de boutons,
Gestion des événements
� un objet source (composant graphique) émet un événement
� l'objet source délègue la gestion des événements utilisateur à un autre objet " écouteur" (d'une
classe dérivée de java.util. EventListener)
� l'écouteur indique qu'il est intéressé par un événement particulier en implémentant une ou
plusieurs interfaces dérivée de EventListener
� pour relier la source et l'écouteur, la source "enregistre" l'écouteur concerné par l'événement
qui peut être généré
Créer l'écouteur
(Listener ou Adapter)
public class typeEcouteur implements typeListener
{ {publ/i/ct rvaoiitdemeevnetn edmee nlt'Aétvréanietmeern(t ttyyppeeEEvveenntt evenement)}
/implémentation des autres méthodes}
ou ----------------------------------------------------
public class typeEcouteur extends typeAdapter
{ {publ/i/ct rvaoiitdemeevnetn edmee nlt'Aétvréanietmeern(t ttyyppeeEEvveenntt evenement)}}
Associer l'écouteur au composant
public class ComposantParticulier
{ p{ubl.i.c. ComposantParticulier()
//le composant peut être
//source d'événements typeEvent
addtypeListener(new typeEcouteur());
...
� Le composant (source de l'événement) enregistre un écouteur en appelant une méthode
addtypeListener peut enregistrer plusieurs écouteurs (délégués)
� Un écouteur peut traiter des événements venant de plusieurs composants
Package java.awt.event
� classes encapsulant les évènements
� interfaces dérivées de EventListener décrivant les "listeners "
� classes implémentant les interfaces dérivées de EventListener
Interfaces
ActionListener
AdjustmentListener
ComponentListener
ContainerListener
FocusListener
ItemListener
KeyListener
MouseListener
MouseMotionListener
TextListener
WindowListener
Classes
ActionEvent
AdjustmentEvent
ComponentAdapter
ComponentEvent
ContainerAdapter
ContainerEvent
FocusAdapter FocusEvent
InputEvent ItemEvent
KeyAdapter KeyEvent
MouseAdapter MouseEvent
MouseMotionAdapter
PaintEvent TextEvent
WindowAdapter WindowEvent
Listeners - Adapters
� Les "listeners" sont des interfaces
� Les "adapters" sont des classes abstraites, permettent de ne pas implémenter
méthodes de l'interface
� exemple : l'interface ActionListener définit une seule méthode
public void actionPerformed(ActionEvent e)
s'applique aux objets boutons, liste item, menu item et champ de texte
Il n'existe pas d'adapter pour ces évènements
l'interface MouseListener définit
public void mouseEntered(MouseEvent e)
public void mousePressed(MouseEvent e)
public void mouseExited(MouseEvent e)
public void mouseReleased(MouseEvent e)
public void mouseClicked(MouseEvent e)
La classe MouseAdapter fournit une version vide
de ces méthodes
--------------------------------------------l'interface MouseMotionListener définit
public void mouseMoved(MouseEvent e)
public void mouseDragged(MouseEvent e)
la classe MouseMotionAdapter fournit une version
l'interface WindowListener définit
public void windowOpened(WindowEvent e)
public void windowClosed(WindowEvent e)
public void windowClosing(WindowEvent e)
public void windowIconified(WindowEvent e)
public void windowDeiconifieed(WindowEvent e)
public void windowActivated(WindowEvent e)
public void windowDeactivated(WindowEvent e)
vide de ces méthodes
toutes les
la classe WindowAdapter fournit une version vide de ces méthodes
Exemple1 : un bouton Quitter
public class Fenetre extends Frame
{ final static int HTAILLE=500;
final static int VTAILLE=400;
public Fenetre()
{ Bouton boutonQuitter=new Bouton("Quitter");
setSize(HTAILLE,VTAILLE);
setTitle("Première fenêtre");
add(boutonQuitter,"North");
show();}}
public class Bouton extends Button
{ public Bouton(String nom){
super(nom);
addActionListener(new BoutonEcouteur());}}
----------------------------------------------ipmupbolritc jcalvaas.sa wBto.uetvoennEtc.o*u;teur implements
{} p{}ublASicycts itvoeonmiL.diesxaticettn(ie0or)n;Performed(ActionEvent e)
Exemple2 : Une fenêtre qui se ferme
public class Fenetre extends Frame
{ final static int HTAILLE=500;
final static int VTAILLE=400;
public Fenetre(){
setSize(HTAILLE,VTAILLE);
setTitle("Editeur graphique");
//la fenêtre peut être source d'événement
//WindowEvent
// elle enregistre l'écouteur FenetreEcouteur
addWindowListener(new FenetreEcouteur());
show();}
Création de l'écouteur
import java.awt.event.*;
class FenetreEcouteur extends WindowAdapter{
public void windowClosing(WindowEvent e){
System.exit(0);}}
Pour gérer des événements
� identifier l'objet source de l'événement
� identifier le type de l'événement et lui associer un écouteur (méthode de
� créer une classe qui implémente l'interface associée à l'événement
� implémenter la méthode associée à l'événement
Exemple 3 : un dialogue
public class FenetreSaisieTexte extends Frame
implements WindowListener
{ final static int HTAILLE=300;
final static int VTAILLE=200;
protected Dialogue monDialogue;
private TextArea zoneAffichage;
public FenetreSaisieTexte(){
setSize(HTAILLE,VTAILLE);
setTitle("Fenêtre Saisie de Texte");
//création d'une zone de texte pour afficher
//le texte saisi dans le dialogue
zoneAffichage=new TextArea(5,40);
add("Center",zoneAffichage);
//création d'un bouton pour ouvrir
//la boite de dialogue
Button boutonOuvrirDialogue=new Button("Ouvrir Dialogue");
boutonOuvrirDialogue.addActionListener(new
BoutonOuvrirDialogueEcouteur (this));
//creation d'un panneau pour placer le
//bouton OuvrirDialogue
Panel panneau=new Panel();
type addtypelistener)
panneau.add(boutonOuvrirDialogue);
add("South",panneau);
//ici, la fenetre traite elle-meme
//l'événement : mauvaise solution
addWindowListener(this);
sstVisible(true);
}// FenetreSaisieTexte
public void ajouterTexte(String unTexte)
{
zoneAffichage.append(unTexte + "\n");
}public void windowClosing(WindowEvent e)
{ System.exit(0);}
public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e) {}
} // classe FenetreSaisieTexte
public class Dialogue extends Dialog{
TextField champSaisie;
FenetreSaisieTexte parent;
Button boutonAjoutTexte;
public Dialogue(Frame fenParent, String titre){
super(fenParent,titre,false);
parent=(FenetreSaisieTexte) fenParent;
//création d'un panneau pour la saisie du texte
Panel panneau1=new Panel();
Label libelle=new Label("Saisissez un texte");
panneau1.add(libelle);
champSaisie=new TextField(40);
panneau1.add(champSaisie);
add("Center",panneau1);
//création d'un panneau pour placer le bouton Ajouter
//du texte
Panel panneau2=new Panel();
boutonAjoutTexte=new Button("Ajout Texte");
boutonAjoutTexte.addActionListener(new
BoiteDialogueEcouteur(this));
panneau2.add(boutonAjoutTexte);
add("South",panneau2);
pack();}
} //classe Dialogue
public class BoutonOuvrirDialogueEcouteur
implements ActionListener{
FenetreSaisieTexte laFenSaisie;
public BoutonOuvrirDialogueEcouteur(FenetreSaisieTexte uneFen){
laFenSaisie=uneFen;}public void actionPerformed(ActionEvent e){
if (laFenSaisie.monDialogue==null)
laFenSaisie.monDialogue=
new Dialogue(this.laFenSaisie,"Dialogue");
laFenSaisie.monDialogue.show();}
}// classe BoutonOuvrirDialogueEcouteur
public class BoiteDialogueEcouteur
implements ActionListener{
Dialogue laBoiteDialogue;
FenetreSaisieTexte laFen;
public BoiteDialogueEcouteur(Dialogue unDialogue){
laBoiteDialogue=unDialogue;
laFen=unDialogue.parent;}
public void actionPerformed(ActionEvent e){
Object source=e.getSource();
if (source==laBoiteDialogue.boutonAjoutTexte){
laFen.ajouterTexte(
laBoiteDialogue.champSaisie.getText());}
laBoiteDialogue.champSaisie.selectAll();
laBoiteDialogue.setVisible(false);
}
}// classe BoiteDialogueEcouteur
2- SWING
� composants légers, écrits en Java
� indépendants de la plate-forme
� look and feel modifiables
� des composants correspondants à ceux du AWT et de nouveaux composants (JFrame, Japplet,
JButton, …)
� package javax.swing et sous-packages
� inclus dans le JDK depuis la version1.2
� même modèle de programmation d'évènements que AWT
Pluggable Look and Feel (PLAF)
� trois implémentations de PLAF : Motif, Windows, Metal (javasoft)
� modèle MVC Model-View-Control : possiblité de passer d'un L&F à un autre à l'exécution
Structure d'une fenêtre JFrame
JRootPane rootPane
Component glassPane JLayeredPane LayredPane
Component
contentPane JMenuBar menuBar
SWING : 4 composants lourds
JFrame,JWindow,JDialog,JApplet
contiennent plusieurs surfaces d'affichage
contentPane
glassPane
menuBar layeredPane
rootPane
Ajout d'un composant à une JFrame
Attention : Ajouter les composants au
contentPane (ou au glassPane)
JFrame f = new JFrame();
JButton b = new JButton("XXX");
f.getContentPane().add(b);
Button JButton
Panel JPanel
CheckBox JCheckBox
Choice JComboBox
Dialog JDialog
Frame JFrame
...
Composants AWT et
correspondants Swing
Nouveaux composants
JInternalFrame
JLayeredPane
JSplitPane
JTree
JTable
JPopMenu
…
Quelques packages Swing
javax.swing
javax.swing.event
javax.swing.plaf
javax.swing.tree
javax.swing.plaf.metal
javax.swing.text.html
...
L'exemple SwingSet2
Conteneurs principaux
Une interface graphique a toujours une fenêtre initiale
JFrame, JApplet
Tout conteneur principal contient un panneau
(contentPane) qui contient lui-même tous les
composants visibles du conteneur principal
Un composant graphique doit être ajouté à la hiérarchie des conteneurs pour être visible
Le conteneur principal peut être retrouver en appelant getContentPane()
Lorsqu'on ferme une fenêtre JFrame, la fenêtre est cachée
La méthode setDefaultCloseOperation permet de fixer le comportement de l'objet JFrame après
un clic sur le bouton Quitter avec une des trois possibilités suivantes :
DO_NOTHING_ON_CLOSE
HIDE_ON_CLOSE
DISPOSE_ON_CLOSE
valeur par défaut : HIDE_ON_CLOSE.
Fermer une fenêtre JFrame look and feel
- à tout moment, une application a un seul "look and feel"
- chaque fois qu'un composant est crée, il s'attache la classe UI implémentée par le L&F choisi
- la classe UIManager permet de connaître le look and feel selectionné
méthodes
getLookAndFeel()
setLookAndFeel()
getCrossPlatformLookAndFeelClassName()
getInstalledLookAndFeels()
public static void main(String[] args){try {
UIManager.setLookAndFeel(
UIManager.getCrossPlatformLookAndFeelClassName());
} catch (Exception e) { }...
JFrame frame = new JFrame();...
SwingUtilities.updateComponentTreeUI(frame);
}
Chapitre 3 - Applets
Une applet : "petite" application destinée à être
� chargée depuis une machine distante (serveur)
� exécutée sur une autre machine (client)
� invoquée à partir d'une page HTML
� exécutée sous contrôle d'une autre application ( navigateur
muni d'un interprète Java,
appletviewer)
� soumise à des contraintes de sécurité Restrictions de sécurité : le bac à sable
� Par défaut, une applet ne peut pas
� accéder au système de fichiers sur la machine client
� ouvrir une connexion réseau avec un serveur autre que celui d'où elle est chargée
� lancer l'exécution d'un autre programme sur le système client
� charger des programmes qui résident sur le système du client
� créer des "threads" n'appartenant pas au groupe dethreads de l'applet
� modifier des propriétés système sur la machine client Politique de sécurité
� JDK 1.0 : le bac à sable
� JDK 1.1 : le bac à sable + possibilité dedéfinir des signatures numériques
� JDK 1.2 : le bac à sable + possibilité dedéfinir des contrôle d'accès et des permissions
utilisant le package java.security (classes Policy, Permission, …)
Servlets
� application destinée à être
� exécutée sur un serveur web pour construire des pages "à la volée"
en
exemple : pour un programme d'accès à une BD stockée sur le serveur,
une applet permet de télécharger une classe
permettant de manipuler les données une servlet chargée depuis le client permet de sélectionner
les données Pour créer une applet
� Créer une classe qui hérite de
�
java.applet.Applet
� exemple :
import java.applet.*;
import java.awt.*;
public class MaPremiereApplet extends Applet
{
public void paint(Graphics gc)
{ gc.drawString("Hello Web",40,40);}}
Seule la méthode paint a été redéfinie
La classe Applet
Applet
Panel
Container
Component
Object
Une applet est :
- un objet graphique
- un objet créé et contrôlé par un navigateur We
Méthodes de la classe Applet
� méthodes d'interface graphique
héritées
public void paint(Graphics g)
public void add(Component c)
...
� méthodes de contrôle
public void init()
public void start()
public void stop()
public void destroy()
d'éxecution
Insertion dans une page HTML
<!-- Fichier MaPremiereApplet.html -->
<HTML>
<HEAD>
<TITLE> MaPremiereApplet
</TITLE>
</HEAD>
<BODY>
<APPLET CODE="MaPremiereApplet.class"
WIDTH=300 HEIGHT=150>
</APPLET>
</BODY>
</HTML>
L'applet s'exécute ...
Construction d'un objet Applet
Le navigateur
� détermine la localisation de la classe, charge son byte-code
� instancie l'objet de la classe dérivée de
Applet (avec le constructeur par défaut)
� envoie le message init()à l'objet pour le configurer Initialisation de l'applet : dans le
constructeur par défaut ou dans la méthode init()
Cycle de vie d'une applet
stop
destroy
init()
envoyé dès que l'objet estconstruit
start()
envoyé dès que la page HTML estactive
stop()
envoyé dès que la page HTML estinactive
destroy()
envoyé dès l'arrêt de la VM
construite
initialisée
active
inactive
init
start
inexistante
start
La méthode paint
public void paint(Graphics g)
� héritée de Component
� appelée après init() et start()
� principale activité de l'applet
� intervient lorsque la fenêtre revient au premier
la méthode repaint() est appelée
elle fait appel à update()
qui fait appel à paint()
Font f=new Font("Times Roman", Font.BOLD,36);
public void paint(Graphics gc)
{
gc.setFont(f);
gc.setColor(Color.red);
gc.drawString("Hello web",40,40);
}
Redéfinition de paint()
public class AppletObserver extends Applet
{ boolean ok;
p{}ubloikc= tvrouied;init()
p{}ublriecp avionitd()s;tart()
p{}ublic vooikd=!sotko;p()
plan ou est déplacée :
Une applet qui se décrit
public void paint(Graphics g)
{ if (ok)
g.setColor(Color.blue);
else
g.setColor(Color.red);
g.drawString("je me redessine
en changeant de couleur",50,50);
}
} //classe AppletObserver
Disposer une applet dans une page HTML
� l'attribut CODE référence le fichier compilé (byte-code) d'une classe dérivée de la classe Applet
CODE="AppletHorloge.class"
WIDTH=300
HEIGHT=300
� les attributs HEIGHT et WIDTH indiquent
<APPLET
CODE="MaDeuxiemeApplet.class"
WIDTH=300
HEIGHT=300
CODEBASE="http://mon_serveur/applets"
la surface réservée à l'exécution de l'applet en pixels
ALIGN="LEFT"
HSPACE=10
VSPACE=10
ALT="Impossible de charger l'applet">
<PARAM NAME="accueil" VALUE="Bonjour il est :">
Si pveouuts plaiss eizn tceer ptreextteer cl'ee scto dqeu ej avvoatre navigateur ne
</APPLET>
L'URL de base
� l'attribut CODE précise le nom de la classe, mais pas sa localisation
� l'attribut CODEBASE précise l'URL de base de la classe à télécharger
� exemple :
CODEBASE="http://mon_serveur/mes_classes" il est nécessaire si les fichiers .html et .class ne
sont pas situés dans le même répertoire
� méthodes définies dans la classe Applet :
getCodebase() getDocumentBase()
� l'attribut ALIGN positionne l'applet par rapport à l'élément HTML situé après la balise
</APPLET>
� l'attribut ALT désigne le texte affiché par le navigateur si l'applet ne peut pas être chargée
� les attributs HSPACE et VSPACE délimitent les marges horizontales et verticales qui encadrent
l'applet en pixels
� le texte libre entre <APPLET> et </APPLET> est affiché par un navigateur incapable
d'interpréter Java
Autres attributs
Passage de paramètres à l'applet
� la balise
<PARAM NAME = "..." VALUE = "..."> est utilisée
pour transmettre un paramètre à l'applet placée
entre <APPLET> et </APPLET>
<PARAM NAME="accueil" VALUE="Bonjour il est :">
� les noms doivent être identiques à ceux passés à la méthode public String
getParameter(String nom)
La méthode getParameter
public String getParameter(String nom)
� définie dans la classe Applet
� paramètre de type String qui identifie le paramètre de l'applet dans la page HTML
<PARAM NAME="accueil" VALUE="Bonjour il est :">
� la valeur de retour est un objet de type String qui représente la valeur du paramètre
dans la
public void init(){
accueil = getParameter("accueil") ;}
public void paint(Graphics g){ …………….
g.drawString(accueil,50,30);}
� méthode à appeler une fois que l'objet est instancié et plutôt dans la méthode init
� déclenche l'exception NullPointerException si elle est appelée dans le constructeur par
défaut
page HTML
Exemples d'applets
les applets "demo",
exemple :
<title> Texte nerveux </title>
<hr>
<applet code="AppletNervousText.class"
width=300 height=200>
<param name="text" value="Mon Texte">
</applet>
Insérer des images
� objets de type java.awt.Image
� les méthodes
Image getImage(URL url)
Image getImage(URL url, String name)
objets Image à afficher dans la fenêtre de l'applet avec la méthode drawImage() de la classe
java.awt.Graphics)
� le paramètre de type URL identifie l'URL absolue contenant l'image
� le paramètre de type String représente l'emplacement de l'image par rapport à l'URL
� pour les sons :
AudioClip getAudioClip(URL url)
AudioClip getAudioClip(URL url , String name)
public void init()
{
URL url =getCodeBase();
Image limage =
getImage(url, "SmallTiger.gif");
}
Exemple
Visualiser un document
méthodes de la classe AppletContext
void showDocument(URL url)
remplace le document visualisé dans la fenêtre de l'applet par l'url donné en paramètre
void showDocument(URL url, String target)
affiche le document dans la frame identifiée par le paramètre target
Exemple
String nomURL ="http://www.unice.fr";
AppletContext appletContext=getAppletContext();
try{ url=new URL(nomURL);}
catch(Exception e){};
if (url != null)
appletContext.showDocument(url);
Faire communiquer des applets en utilisant l'une des méthodes suivantes de l'interface
AppletContext
Applet getApplet(String name)
permet de retrouver une applet par son nom
Enumeration getApplets()
retourne toutes les applets du document du contexte de l'applet
<HTML>
<BODY>
<H1>Emetteur</H1>
<APPLET CODE=Emetteur.class
WIDTH=200 HEIGHT=200>
NAME="applet Emetteur">
</APPLET>
<HR>
<H1>Recepteur</H1>
<APPLET CODE=Recepteur.class
WIDTH=400 HEIGHT=90 >
NAME="applet Recepteur">
</APPLET>
</BODY>
</HTML>
6
<HTML>
<BODY>
<H1>Emetteur</H1>
<APPLET CODE=Emetteur.class
WIDTH=200 HEIGHT=200>
<PARAM NAME="name" value="applet Emetteur">
</APPLET>
<HR>
<H1>Recepteur</H1>
<APPLET CODE=Recepteur.class
WIDTH=400 HEIGHT=90 >
<PARAM NAME="name" value="applet Recepteur">
</APPLET>
</BODY>
</HTML>
public class Emetteur extends Applet{
private static Applet recepteur ;
public void init(){
...
recepteur =
getAppletContext().getApplet("applet
Recepteur");
...
(Recepteur)recepteur).executerRequeteVenantDe
("applet Emetteur");
}//classe Emetteur
public class Recepteur extends Applet{
public void init() {
...
emetteur = getAppletContext().getApplet("applet
Emetteur");
...}
public void executerRequeteVenantDe(String nomEmetteur){
...
this.getGraphics().drawString("Message reçu de . . .
"!",100,150);
emetteur.getGraphics().drawString("dans
Recepteur",20,100);}
}//classe Recepteur
Exercice
• Ecrire une applet AppletHorloge qui affiche l'heure système statiquement
• Modifier l'applet AppletHorloge de manière à pouvoir passer en paramètre (dans le code HTML)
un message à afficher au-dessus de l'heure
• Ecrire une applet AppletHorlogeDyn qui affiche l'heure système dynamiquement
Dates et heures
classe java.util.Date
valeur de type long
nombre de millisecondes depuis le 01/01/1970 obtenue par :
long time=System.CurrentMillis();
ou
Date maintenant = new Date();
long time=maintenant.getTime();
formatter dates et heures en textes
� Classe java.text.DateFormat
définir obtenir des entiers (jour, mois, heure, …) à partir d'une date
� Classe java.util.Calendar
Dates et heures
Classe java.text.DateFormat
String format(Date date)
formatte en chaîne de caractères
static DateFormat getDateInstance()
donne le formatteur de date selon les paramètres locaux
static DateFormat getTimeInstance()
donne le formatteur d'heure selon les paramètres locaux
String chaineHeure =
DateFormat.getTimeInstance().format(maintenant);
Dates et heures
Classe java.text.SimpleDateFormat
pour définir un modèle propre de formattage
SimpleDateFormat formatter =
new SimpleDateFormat ("yyyy.MM.dd G 'at' hh:mm:ss a zzz");
Date current= new Date();
String dateString = formatter.format(current);
SimpleDateFormat formatteur =
new SimpleDateFormat ("HH:mm:ss");
String chaineHeure = formatteur.format(date);
Horloge dynamique
// pour rafraîchir la la fenetre
public void paint(Graphics g)
{. . .
g.clearRect(0,0,getSize().width,getSize().height);
// pour mettre en veille le processus courant
public void paint(Graphics g)
{. . .
try {Thread.sleep(1000);}
catch (InterruptedException signal){}. . .
Applet et/ou Application
public class AppletAppli extends JApplet
{. . .
static private JApplet applet;
public void init()
{ . . .}
public static void main(String[] arg)
{ applet = new AppletAppli();
JFrame fenetre=new JFrame();
fenetre.getContentPane().add(applet);
applet.init(); applet.start();
Applet et/ou Application
//la fenetre se ferme en stoppant l'execution
fenetre.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
applet.stop();
applet.destroy();
System.exit(1);}});
fenetre.setVisible(true);
}. . .
Archives .jar
� fichier .jar
� format ZIP
� archive de fichiers .class
ressources auxiliaires
meta-informations : fichier manifest
� créé avec l'outil jar
jar cf monArchive.jar *.class
� peut être une entrée de la variable CLASSPATH
� peut être utilisé pour faciliter le chargement d'une
applet
Chapitre 5 - Entrées-Sorties
� Flux d'entrée-sortie
� Package java.io
� Entrée-Sortie Console
� Fichiers
� Sérialisation
Flux d'entrée-sortie
séquence de données qui ont une source (entrée) et une sortie (output)
� permet de transporter une information (caractère, objet, image, sons)
� Source : fichier, console, communication réseau
� Données lues dans l'ordre où elles sont écrites
� Un flux peut utiliser un tampon
Package java.io Package java.io
� Byte Streams : format 8 bits
� input streams, output streams
� data byte streams
� object byte streams
� Character Streams : format 16 bits UNICODE
� readers , writers
Package java.io
• les classes de type Data Sink Streams
•les classes de type Processing Streams
Data Sink Streams
Processing streams
Flux d'octets
Object
OutputStream InputStream
BufferedOutputStream
FilterOutputStream FilterInputStream
BufferedInputStream
FileOutputStream FileInputStream
Flux de caractères
Object
Writer Reader
BufferedWriter BufferedReader
LineNumberReader
StringWriter StringReader
Data Sink Streams
Character Streams Byte Streams
Processing Streams : opérent sur les
données
CharacterStreams Byte Streams
Super – classes (abstraites)
Octets
InputStream
int read()
int read(byte cbuf[])
OutputStream
void write( int c)
void write(byte cbuf[])
Caractères
Reader
int read()
int read(char cbuf[])
Writer
void write( int c)
void write(char cbuf[])
public abstract int read() throws IOException
lit un octet et retourne sa valeur entre 0 et 255 ou bien -1
public long skip(long nb) throws IOException
saute nb octets dans le flux d'entrée
public int available() throws IOException
retourne le nombre d'octets prêts à être lus
public void flush() throws IOException
vide le flux
Classe InputStream
package java.lang
class System
{
public static InputStream in ;
public static PrintStream out;
public static PrintStream err;
...
Les flux standard
public static int lireOctet()
{ int a=0;
try
{
a = System.in.read();
}
catch (IOException e){};
return a;
}
Exemple 1 : Lire un octet au clavier
Classes InputStreamReader
OutputStreamWriter
� InputStreamReader implémente
un
flux qui lit des bytes en entrée et les convertit en caractères Unicode
� OutputStreamWriter implémente un
flux qui convertit les caractères Unicode et les écrit vers un flux d'octets
Classes PrintStream
PrintWriter
PrintStream et PrintWriter
méthodes print et println
public void println(String s)
pour les types:
char int float boolean
char[] long double String
Object
Flux tampons
évitent de lire et écrire directement dans le flux suivant
améliorent les performances
permettent de lire des lignes de texte
classe BufferedReader
public String readLine() throws IOException
lit une ligne de texte et la retourne comme un objet
String
Exemple 2 : Lire une ligne au
clavier
public static String lireLigne()
{ BufferedReader fluxEntree =
new BufferedReader(
new InputStreamReader(System.in));
String s = null;
try
{ ligne = fluxEntree .readLine();
}
catch (IOException e){}
return s;}
Flux sur fichiers
Classes
FileInputStream, FileOutputStream,
pour créer des flux d'octets
FileReader, FileWriter,
convertissent des flux d'octets en flux de caractères
RandomAccessFile
permet écriture et lecture dans le même flux
Classe File
boolean canRead()
boolean canWrite()
boolean isFile()
boolean isDirectory()
...
Exemple 3 : Ecrire dans un fichier
BufferedReader entree =
new BufferedReader(new StringReader(ch));
PrintWriter sortie=
new PrintWriter(new BufferedWriter(
new FileWriter("fic.out")));
while ((s=entree.readLine())!=null)
sortie.println(s);
sortie.close();
BufferedReader entree =
new BufferedReader(
new FileReader("Fic.in"));
while((s=entree.readLine())!=null)
System.out.println(s);
entree.close();
Exemple 4 : Lire dans un fichier Flux d'objets
� Classes
ObjectInputStream et ObjectOutputStream
permettent de lire et d'écrire des graphes d'objets
� Lire et Ecrire des objets dans un flux : la sérialisation
Sérialisation
� sauvegarder un objet et les objets qu'il référence
� principe pour sauvegarder un objet : sauver dans
le flux, un descripteur de la classe suivi des
valeurs des champs non statiques
� exemple d'utilisation : échange d'objets
via le réseau, persistance
Sérialiser un objet
� la classe de l'objet doit implémenter Serializable
� construire un objet ObjectOutputStream à partir d'un objet FileOutputStream
� utiliser la méthode writeObject sur l'objet
ObjectOutputStream
public final void writeObject(Object obj)
throws IOException
Exemple 5
FileOutputStream fout = new FileOutputStream("tmp");
ObjectOutputStream fluxObjets =
new ObjectOutputStream(fout);
Personne objetAserialiser = new Personne("Dupont");
fluxObjets.writeObject(objetAserialiser);
Sérialiser un objet
� Si un objet qui référence d'autres objets, est sérialisé, les objets référencés
sont également
sérialisés
� La méthode writeObject propage une exception NotSerializableException si l'objet n'est pas
sérialisable
� un objet est sérialisable s'il implémente l'interface Serializable
Lire un objet sérialisé
� construire un objet ObjectInputStream à partir d'un objet FileInputStream
� utiliser la méthode readObject sur l'objet
ObjectInputStream
public final Object readObject()
throws OptionalDataException,
ClassNotFoundException, IOException
FileInputStream fin = new FileInputStream("tmp");
ObjectInputStream inStream = new ObjectInputStream(fin);
try{
Personne objetDeserialise=
(Personne)(inStream.readObject());
}catch(Exception e){}
Chapitre 6 –
Programmation distribuée
1. Programmation réseau
� Téléchargement via une URL
� Gestion des sockets TCP et UDP
2. Connexion à une base de données
relationnelle (JDBC)
6.1 Programmation réseau
• Deux approches :
• programmation basée sur la connexion à une URL accès à une ressource sur le web
• programmation basée sur sockets TCP ou UDP communications client/serveur
• Un package : java.net
• manipulation des adresses Internet : classe InetAddress
• accès de type fichier désigné par URL : classes URL et URLConnection
• communication de bas niveau (en mode non connecté) : classes DatagramPacket et
DatagramSocket
• communication en mode connecté : classes Socket et ServerSocket
Package java.net Classe InetAddress
• représente les adresses IP sur 32 bits
• méthodes
static InetAddress getLocalHost()
throws UnknownHostException;
static InetAddress getByName(String m)
throws UnknownHostException;
String getHostName();
try{
InetAddress address;
System.out.println("Affichage de l'adresse IP de nyx a
partir de son nom : ");
address = InetAddress.getByName("nyx.unice.fr");
System.out.println(address);
SysLtoecma.loHuots.tp"r)i;ntln("Affichage de l'adresse IP de
address = InetAddress.getLocalHost();
System.out.println(address);
System.out.println("Affichage du nom de l'hote");
System.out.println(address.getHostName());
}catch(UnknownHostException e){}
Classe URL
• permet de représentée une ressource accessible sur le web au moyen
flux de données de type InputStream
• constructeurs
URL (String spec) throws MalformedURLException
URL (String protocol, String host, int port, String
file)throws MalformedURLException
URL (String protocol, String host, String file) throws
MalformedURLException
public String getProtocol ()
public String getHost ()
public int getPort ()
public String getFile ()
retournent le protocole, l'hôte, le port, le chemin d'accès au
fichier d'une instance de la classe URL
InputStream openStream()
ouvre une connexion en lecture avec l'URL
retourne l'objet InputStream qui permet de lire le contenu
de cette url.
d’une URL comme un
Deux façons d'accéder aux données
une fois l'objet URL construit :
InputStream openStream()
ouvre une connexion en lecture avec l'URL
retourne l'objet InputStream qui permet de lire le
contenu de cette url comme un flux d'octets. OU
Object getContent ()
retourne un objet correspondant au contenu du fichier
représenté par un objet de classe URL. Par exemple, si le
fichier est une image, cette méthode retourne une
instance d'une classe dérivée de la classe Image.
// afficher les 3 premieres lignes
// d'un fichier HTML
public static void main(String argv[])
IOExcepttihornows MalformedURLException,
{ BufferedReader in;
URL url=nUeRwL ( "http:www.dtc.com" ) ;
in=new BufferedReader(
new InputStreamReader(url.openStream()));
for (int nl=0; nl<3;nl++)
{ String ligne=in.readLine();
System.out.println(ligne);}}
méthode de la classe URL :
URLConnection openConnection ()
représente une connexion avec une URL, et retourne une
instance de la classe URLConnection qui permet d'obtenir
toute sorte de renseignements (dates, en-tête,...) sur le
fichier correspondant à l'URL
et donne un contrôle plus étendu sur la communication clientserveur
(possibilité de gérer un flux de sortie du client vers le serveur)
URL Connexions
Classe URLConnection
• abstraite
• super-classe pour toutes les classes qui représente une connexion entre une application et une
URL
• une instance d'une classe dérivant de cette classe est obtenue grâce à la méthode
openConnection () de la classe URL
• méthodes permettant de créer un flux de données pour lire et/ou écrire dans le fichier
désigné
par une URL, et d'obtenir d'autres d'informations sur ce fichier (sa date de dernière
modification, sa taille, son type,...)
• la méthode connect() permet d'ouvrir la connexion
Sockets
• les données transmises à travers Internet sont éclatées en paquets (datagrammes)
• le logiciel réseau natif gére la séparation en paquet sur l'émetteur et rassemble les paquets sur
le recepteur
• l'API java.net permet d'ignorer les problèmes de codage de paquets, … et se place à un niveau
d'abstraction plus élévé en manipulant des sockets
Un socket
• représente une communication d'une machine avec une autre machine pour la transmission de
données
• permet de se connecter à une machine distante envoyer des données recevoir des données
fermer la communication
• est connecté à une seule machine à la fois
• peut envoyer et recevoir des données avec
le même hôte
Sockets TCP
Machine Cliente Machine Serveur
port
Socket C
Application
Client Application
Serveur
port Socket S
• Un socket est caractérisé par une adresse Internet et un port
sur la machine locale
• La communication utilise deux sockets : un sur le client et un
sur le serveur
ServerSocket
Modèle réseau Java
1. le serveur enregistre son service sous un numéro de port
2. il attend qu'un socket du client demande une connexion (méthode accept())
3. le client connaît le nom de la machine serveur et le numéro du port auquel est connectée
l'application serveur ; le client demande la création d'un socket vers le serveur
4. si la connexion est acceptée, le serveur sort de l'attente et crée un socket de communication
avec le client
5. le client et le serveur communiquent en écrivant et en lisant dans leur socket
Classe java.net.Socket
• constructeurs
public Socket (String host, int port)
throws UnknownHostException, IOException
public Socket (InetAddress address, int port)
throws IOException
permettent de créer une instance de la classe
Socket et d'obtenir pour un programme client une connexion avec le programme serveur de la
machine hôte en attente sur le port port
• pour initialiser la connexion, le client doit construire
une instance de Socket
• une fois la connexion établie, les flux d'entrée et de sortie vers le serveur sont récupérables
• méthodes :
public InputStream getInputStream ()
throws IOException
public OutputStream getOutputStream ()
throws IOException
• quand l'application se termine, il faut
Socket pour libérer le port
public void close () throws IOException
fermer l'objet
Autres méthodes
public InetAddress getLocalAddress ()
public int getLocalPort ()
retournent adresse et port sur la machine locale
public InetAddress getInetAddress ()
public int getPort ()
retournent adresse et port adresse et port sur la
machine distante
public class ClientEchoTCP
{ public static final int PORT=7;
public static void main(String arg[]) throws IOException
{
Socket socketEcho = null;
PrintWriter fluxSortie = null;
BufferedReader fluxEntree = null;
// Récupération des adresses
InetAddress adrLocale = InetAddress.getLocalHost ();
InetAddress adrDistante = adrLocale ; //cas particulier
try {
// Ouverture d'une connexion sur le port 7
// de l'hôte distant
socketEcho = new Socket(adrDistante , 7);
// Récupération des flux d'entrés et de sortie
fluxSortie = new PrintWriter(
socketEcho.getOutputStream(), true);
fluxEntree = new BufferedReader(
new InputStreamReader(socketEcho.getInputStream()));
}
catch (UnknownHostException e)
{ System.err.println("Hote inconnu " );
System.exit(1); }
catch (IOException e)
{ System.err.println("Pas d'E/S pour la connexion avec
l'hote"); System.exit(1);}
//envoi d'une ligne au serveur
fluxSortie.println("essai de la socket Echo ");
//affichage de ce qui est lu sur la connexion
System.out.println("echo: " + fluxEntree.readLine());
fluxSortie.close();
fluxEntree.close();
socketEcho.close()}
}//class ClientEchoTCP
Classe ServerSocket
Constructeurs
public ServerSocket (int localPort)
throws IOException
public ServerSocket (int localPort,
int maxWait, InetAddress addrLocal )
throws IOException
permettent de créer un socket de serveur en attente sur le
port port
maxWait représente le nombre maximum de connexions
pendantes
Connexions
• Une fois l'objet ServerSocket créé, l'appel sur cet objet de la méthode
public Socket accept () throws IOException
met le serveur en attente d'une demande de connexion d'un client et retourne un socket (objet
Socket) qui correspond à cette connexion une fois qu'elle est établie
• Le socket retourné est appelé socket de service
Il est attaché à la même adresse Internet et au même port TCP que le socket serveur
Serveur itératif
...
socketService.close();}}
ServerSocket s=new SocketServer(port);
le serveur attend les connexions pendantes et traite de manière itérative, toute celles qu'il
accepte
Serveur concurrent
• le serveur lance un processus léger pour traiter chaque connexion ; chaque connexion est
traitée en concurrence avec les autres
• le serveur est concurrent :
class Serveur extends Thread
{…
• l'objet Serveur appelle la méthode accept()
pour une nouvelle connexion et utilise le socket
résultant pour créer un nouveau thread qui exécute le code du service à rendre pour ce nouveau
client
Exemple
Un serveur doit attendre des clients pour leur rendre le service suivant : le client envoie un
texte, ligne par ligne et le serveur compte le nombre de mots du texte
class ClientCompteMot
{ static final int port=10000;
public static void main(String[] argv)
{
BufferedReader lecteurFichier =null;
BufferedReader fluxEntree =null;
PrintStream fluxSortie =null;
String ligne =null;
Socket socket =null;
try{ socket = new Socket(argv[1],port);
lecteurFichier =new BufferedReader(
new FileReader(argv[0]));
fluxEntree = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
fluxSortie = new PrintStream(socket.getOutputStream());
while ((ligne=lecteurFichier.readLine())!=null)
fluxSortie.println(ligne);
fluxSortie.println("xxxxxx");
System.out.println(fluxEntree.readLine());
socket.close();
}
catch(IOException exc){
System.out.println("probleme a determiner");}
}
}//ClientCompteMot
public class ServeurCompteMot extends Thread
{
final static int port=10000;
ServerSocket receptionniste;
public ServeurCompteMot()
{try
{receptionniste=new ServerSocket(port);}
catch(IOException exc)
{System.out.println("impossible de creer le
serveur");}
this.start();
}
public void run()
{ Socket socket;
Service c;
try{while(true)
{
socket=receptionniste.accept();
c=new Service(socket);
}}catch(IOException exc)
{System.out.println("probleme de
connection");}
}
public static void main(String argv[])
{new ServeurCompteMot();}
}//class ServeurCompteMot
class Service extends Thread
{
Socket socket;
BufferedReader fluxEntree;
PrintStream fluxSortie;
Service(Socket socket)
{this.socket=socket;
try{fluxEntree=new BufferedReader(new
InputStreamReader(socket.getInputStream()));
fluxSortie=new
PrintStream(socket.getOutputStream());
} catch(IOException exc){}
try{socket.close();} catch(IOException e){}}
this.start();}
public void run()
{ String texte;
int compteur=0;
try{ while(!(texte=fluxEntree.readLine()).
equals("xxxxxx"))
compteur+=(new
StringTokenizer(texte)).countTokens();
fluxSortie.println(
"votre texte possede "+compteur+" mots");
}catch(IOException exc){}
try{socket.close();}catch(IOException e){}}
}//class Service
EXERCICES TDS
AWT exo 3
EXERCICE 3
/**
* Une FenetreEditeur est une fenetre principale
* qui contient une ZoneGraphique
* Cette fenetre peut se fermer
*/
import java.awt.*;
import java.awt.event.*;
public class FenetreEditeur extends Frame{
final static int HTAILLE=500;
final static int VTAILLE=400;
public FenetreEditeur(){
ZoneGraphique zone = new ZoneGraphique();
setSize(HTAILLE,VTAILLE);
setTitle("Editeur graphique");
add(zone,"Center");
add(new BarreOutils(zone),"North");
//la fenetre se ferme en stoppant l'execution
addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);}});
setVisible(true);
}
}//FenetreEditeur
/**
*
* Une ZoneGraphique est un rectangle a fond bleu
* a curseur en forme de croix
* La zone graphique intercepte les clics de la souris
* Pour le clic mousePressed, une droite est initiée et
* pour le clic mouseReleased, la droite es tracée
*
*/
import java.awt.*;
import java.awt.event.*;
public class ZoneGraphique extends Canvas{
private int xOrigine,yOrigine;
public ZoneGraphique(){
setBackground(Color.blue);
setForeground(Color.yellow);
setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
addMouseListener(new MouseAdapter(){
public void mousePressed(MouseEvent e){
ZoneGraphique.this.initieDroite(e.getX(), e.getY());}
public void mouseReleased(MouseEvent e){
ZoneGraphique.this.termineDroite(e.getX(), e.getY());}} );
}//ZoneGraphique()
public void initieDroite(int x, int y){
xOrigine=x;
yOrigine=y;}
public void termineDroite(int x, int y){
Graphics g=getGraphics();
g.drawLine(x,y,xOrigine,yOrigine);}
}// classe ZoneGraphique
/**
*
* Une BarreOutils est un panneau à ajouter à un objet FenetreEditeur
* et contenant un bouton QUITTER
* et une liste déroulante de couleurs permettant de
* changer la couleur du fond de la ZoneGraphique
*/
import java.awt.*;
public class BarreOutils extends Panel{
Choice listeCouleur ;
Button boutonQuitter;
public BarreOutils(ZoneGraphique uneZone){
String libelleCouleurs[]={"Bleu", "Rouge","Jaune","Vert"};
Color couleurs[]={Color.blue,Color.red,Color.yellow,Color.green};
setBackground(Color.yellow);
listeCouleur=new Choice();
for (int i=0;i<libelleCouleurs.length;i++)
listeCouleur.addItem(libelleCouleurs[i]);
listeCouleur.select(1);
add(listeCouleur);
add(boutonQuitter=new Button("Quitter"));
//gestion des évènements
listeCouleur.addItemListener(new OutilsEcouteur(couleurs,uneZone));
boutonQuitter.addActionListener(new OutilsEcouteur(uneZone));}
} //classe BarreOutils
/**
* Pour traiter les évènements générés par
* l'activation des objets d'une BarreOutils
*/
import java.awt.*;
import java.awt.event.*;
public class OutilsEcouteur implements ActionListener, ItemListener{
private ZoneGraphique zone;
private Color couleurs[];
public OutilsEcouteur(ZoneGraphique uneZone){
this.zone=uneZone;}
public OutilsEcouteur(Color desCouleurs[],ZoneGraphique uneZone){
this.couleurs=desCouleurs;
this.zone=uneZone;}
public void itemStateChanged(ItemEvent e){
Choice liste=(Choice) e.getSource();
this.zone.setBackground(couleurs[liste.getSelectedIndex()]);}
public void actionPerformed(ActionEvent e){
System.exit(0);}
}// classe OutilsEcouteur
EXO Applet
XERCICE3
**
applet qui met en evidence ces différents états
*/ IUT Département Informatique Programmation en Java M.Collard
mport java.awt.*;
mport java.applet.Applet;
ublic class AppletObserver extends Applet {
oolean ok;
ublic void init() {
k=true; }
ublic void start() {
epaint(); }
ublic void stop() {
k=!ok; }
ublic void paint(Graphics g) {
(ok)
.setColor(Color.blue);
lse
.setColor(Color.red);
.drawString("je me redessine en changeant de couleur",50,100); }
// class AppletObserver
XERCICE4
**
Affiche le contenu d'un fichier HTML specifié par une URL
mport java.awt.*;
mport java.applet.*;
import java.net.*; IUT Département Informatique Programmation en Java M.Collard
ublic class AppletShowDoc extends Applet {
RL url ;
ublic void init() {
tring nomURL ="http://verdon.unice.fr";
ppletContext appletContext=getAppletContext();
y{
rl=new URL(nomURL);
catch(Exception e){};
(url != null) appletContext.showDocument(url);
lse System.out.println("ERREUR"); }
// classe AppletShowDoc
XERCICE5
**
affiche l'heure système et un message passé en parametre
mport java.awt.*;
mport java.applet.Applet;
mport java.text.DateFormat;
mport java.util.Date;
ublic class AppletHorloge extends Applet {
rivate String chaine;
rivate String accueil;
ublic AppletHorloge() {
etFont(new Font("Courrier",Font.BOLD,36));
etBackground(Color.green);
setForeground(Color.blue); IUT Département Informatique Programmation en Java M.Collard }
ublic void init() {
ccueil = getParameter("accueil") ; }
ublic void paint(Graphics g)
Date date = new Date();
tring chaine=DateFormat.getTimeInstance().format(date);
.drawString(accueil,30,30);
.drawString(chaine,50,85);
//classe AppletHorloge
*
affiche l'heure système, met a jour l’affichage et
affiche un message passé en parametre
mport java.awt.*;
mport java.applet.Applet;
mport java.text.DateFormat;
mport java.util.Date;
ublic class AppletHorlogeDyn extends Applet {
rivate String chaine;
rivate String accueil;
ublic AppletHorlogeDyn() {
etFont(new Font("Courrier",Font.BOLD,36));
etBackground(Color.green);
etForeground(Color.blue); }
ublic void init() {
ccueil = getParameter("accueil") ; }
ublic void paint(Graphics g) {
while (true) IUT Département Informatique Programmation en Java M.Collard {
ate date = new Date();
tring chaine=DateFormat.getTimeInstance().format(date);
.clearRect(0,0,getSize().width,getSize().height);
.drawString(accueil,30,30);
.drawString(chaine,50,85);
y {Thread.sleep(1000);}
atch (InterruptedException signal){} } }
//classe AppletHorlogeDyn
HTML>
HEAD>
TITLE>AppletHorlogeDyn</TITLE>
/HEAD>
BODY>
H1>AppletHorlogeDyn</H1>
HR>
APPLET CODE=AppletHorlogeDyn WIDTH=300 HEIGHT=300>
param name="accueil" value="Il est ">
/APPLET>
HR>
/BODY>
/HTML>
XERCICE 6
**
Une AppletAppli peut s'exécuter indifféremment à partir d'une page web <br>
ou à partir de la ligne de commande <br>
Elle affiche l'heure système dynamiquement et
affiche un message passé en parametre
mport java.awt.*;
mport javax.swing.*;
import java.awt.event.*; IUT Département Informatique Programmation en Java M.Collard
mport java.applet.Applet;
mport java.text.DateFormat;
mport java.util.Date;
ublic class AppletAppliHorloge extends Applet //ou JApplet {
rivate String chaine;
rivate String accueil;
*
applet represente l'applet qui est ajoutee à la fenetre
principale de l'application
/
tatic private Applet applet ;
/ou
/static private JApplet applet ;
ublic AppletAppliHorloge() {
etFont(new Font("Courrier",Font.BOLD,36));
etBackground(Color.green);
etForeground(Color.blue);
etSize(300,300); }
ublic void init() {
(applet != null)
ccueil = "Il est :";
lse
ccueil = getParameter("accueil") ; }
ublic static void main(String[] arg) {
*
fenetre represente l'applet la fenetre principale de l'application
/
rame fenetre=new Frame();
/ou
/JFrame fenetre=new JFrame();
pplet = new AppletAppliHorloge();
enetre.setSize(200,200);
enetre.add(applet);
//ou IUT Département Informatique Programmation en Java M.Collard
/fenetre.getContentPane().add(applet);
pplet.init();
pplet.start();
enetre.setVisible(true); }
ublic void paint(Graphics g) {
hile (true) {
ate date = new Date();
tring chaine=DateFormat.getTimeInstance().format(date);
.clearRect(0,0,getSize().width,getSize().height);
.drawString(accueil,30,30);
.drawString(chaine,50,85);
y {Thread.sleep(1000);}
atch (InterruptedException signal){} } }
//classe AppletAppliHorloge
------------------------------------------------------------XERCICE 8
* un Emetteur est une applet qui envoie un message à l'applet Recepteur IUT Département Informatique
Programmation en Java M.Collard
mport java.awt.*;
mport java.applet.*;
mport java.awt.event.*;
ublic class Emetteur extends Applet {
rivate static Applet recepteur ;
ublic void init() {
etBackground(Color.yellow);
etForeground(Color.blue);
Panel panneau1=new Panel();
anneau1.add(new Label("Nom de cette applet : " + getParameter("NAME"), Label.LEFT));
dd(panneau1);
anel panneau2=new Panel();
utton boutonEnvoyer = new Button("Envoyer message");
anneau2.add(boutonEnvoyer);
dd(panneau2);
ecepteur = getAppletContext().getApplet("applet Recepteur");
outonEnvoyer.addActionListener(new ActionListener() {
ublic void actionPerformed(ActionEvent e)
if (recepteur != null)
if (!(recepteur instanceof Recepteur)) {
metteur.this.getGraphics().drawString("Applet trouvee ; son nom : "+ recepteur.getParameter("name") + ", "+ " mais
e n'est pas un recepteur\n",20,50); }
lse {
metteur.this.getGraphics().drawString("Applet trouvee ; son nom : "+ recepteur.getParameter("name") + " message
nvoye!!!",20,50);
(Recepteur)recepteur).executerRequeteVenantDe("applet Emetteur"); } }
lse
Emetteur.this.getGraphics().drawString("Impossible de trouver "
"applet Recepteur" + ".\n",20,50);}
} IUT Département Informatique Programmation en Java M.Collard
);
//init
//classe Emetteur
**
un Recepteur est une applet qui reçoit et affiche un message
venant de l'applet Emetteur
mport java.applet.*;
mport java.awt.*;
mport java.awt.event.*;
ublic class Recepteur extends Applet
tatic final String messageAttente = "En attente d'un message... ";
abel labelAttente = new Label(messageAttente, Label.RIGHT);
tatic Applet emetteur;
ublic void init()
etBackground(Color.blue);
etForeground(Color.yellow);
anel panneau1=new Panel();
anneau1.add(new Label("Nom de cette applet : " + getParameter("NAME"), Label.LEFT));
dd(panneau1);
anel panneau2=new Panel();
utton boutonEffacer = new Button("Effacer");
anneau2.add(boutonEffacer);
dd(panneau2);
anel panneau3=new Panel();
anneau3.add(labelAttente);
dd(panneau3);
emetteur = getAppletContext().getApplet("applet Emetteur"); IUT Département Informatique Programmation en
Java M.Collard
outonEffacer.addActionListener(new ActionListener() {
ublic void actionPerformed(ActionEvent e) {
ecepteur.this.labelAttente.setText(Recepteur.messageAttente );
ecepteur.this.getGraphics().clearRect(0,20,500,40); } }); }//init
ublic void executerRequeteVenantDe(String nomEmetteur) {
abelAttente.setText("Message reçu de " + nomEmetteur + "!"); }
//classe Recepteur
HTML>
HTML>
HEAD>
TITLE>Communication entre applets</TITLE>
/HEAD>
BODY>
TABLE>
TR>
H1>Emetteur</H1>
APPLET CODE=Emetteur.class WIDTH=400 HEIGHT=200
AME="applet Emetteur">
PARAM NAME="NAME" value="applet Emetteur">
/APPLET>
/TR>
TR>
HR>
H1>Recepteur</H1>
APPLET CODE=Recepteur.class WIDTH=400 HEIGHT=200
AME="applet Recepteur">
PARAM NAME="NAME" value="applet Recepteur">
/APPLET>
/TR>
/TABLE>
/BODY>
</HTML>