Fascicule de cours 2 - Laboratoire d`Informatique de Paris 6

Transcription

L3 Monnaie - Finance
Algorithmique et initiation à la
programmation java
Seconde partie
O. Auzende
2012-2013
2
Licence Monnaie - finance
2012-2013
Algorithmique et programmation java
LE PAQUETAGE GRAPHIQUE JAVA.AWT ............................................................. 5
Construction d’une fenêtre graphique ................................................................................................................ 5
Création d’interfaces : bilan ................................................................................................................................ 9
LA GESTION DES EVENEMENTS ............................................................................ 9
Principe de la gestion des événements ................................................................................................................. 9
Principe de mise en œuvre en java....................................................................................................................... 9
Programmation ................................................................................................................................................... 10
Application à la fenêtre précédente ................................................................................................................... 11
LES SAISIES ET RECUPERATIONS DE DONNEES ............................................. 14
Champ de saisie de type texte ............................................................................................................................ 14
Choix dans un List ou Choice ............................................................................................................................ 14
Choix d’un Checkbox dans un groupe .............................................................................................................. 15
LES CONVERSIONS ET LES CALCULS................................................................ 15
Donnée = chaîne de caractères ........................................................................................................................... 15
Conversion d’une chaîne ch en nombre ............................................................................................................ 15
Conversions d’un nombre en chaîne ................................................................................................................. 15
Exemple ................................................................................................................................................................ 15
LES APPLETS JAVA .............................................................................................. 17
Qu’est-ce qu’une applet ? ................................................................................................................................... 17
Différences entre applet et application .............................................................................................................. 17
Méthodes d’une applet........................................................................................................................................ 17
Exécution d’une applet ....................................................................................................................................... 18
Méthodes à programmer .................................................................................................................................... 18
Lancement d’une applet ..................................................................................................................................... 18
3
Transformation d’une application en applet .................................................................................................... 18
Création directe d’une applet ............................................................................................................................ 20
Les images dans les applets ................................................................................................................................ 22
Paramètres provenant de la page HTML ......................................................................................................... 25
ANNEXES ................................................................................................................ 30
Noms des variables .............................................................................................................................................. 30
Casse ..................................................................................................................................................................... 30
Mots clés............................................................................................................................................................... 30
Portée des variables ............................................................................................................................................ 30
4
2012-2013
Le paquetage graphique java.awt
Le paquetage java.awt fournit les classes permettant de bâtir des fenêtres graphiques
Component : à l’origine …
En italiques, les classes abstraites (qui n’autorisent
…
Une classe abstraite a pour rôle de proposer des méthodes qui seront
classes
Dans la parabole, ce qui est
En pointillé, les …
…
…
).
par toutes les sous-
au paquetage java.awt, mais dérive d’une classe de java.awt.
Button
Canvas
Checkbox
Choice
Component
Panel
Applet
Container
Dialog
Label
FileDialog
Window
Frame
List
Scrollbar
TextArea
TextComponent
TextField
MenuBar
MenuComponent
MenuItem
BorderLayout
CardLayout
FlowLayout
GridBagConstraints
LayoutManager
GridBagLayout
GridLayout
Construction d’une fenêtre graphique
Les composants (textes, boutons, cases à cocher, etc.) sont insérés dans un objet dérivant de Container
Container contient Panel et Window
o Les objets de type Panel sont
…
permettant de ranger des composants
o Les objets de type Window sont …
Frame est une sous-classe de Window
o Les objets de type Frame sont des fenêtres avec …
5
Chaque container possède un LayoutManager (
sont placés les objets qu’il contient.
…
) qui définit comment
LayoutManager est une interface utilisée par :
o BorderLayout : répartit les objets au Nord, Sud, Est, Ouest et Centre (option par défaut pour
o FlowLayout : les répartit de gauche à droite puis passe à la ligne suivante (option par défaut pour
)
…
)
…
o GridLayout : les répartit dans un tableau dont toutes les cases ont la même taille
Exemples
Appli1.java
import java.awt.* ;
class Appli1 {
public static void main(String arg[]) {
Frame w = new Frame("Exemple") ;
w.add("North", new Label("Un")) ;
w.add("Center", new Label("Deux")) ;
w.add("South", new Label("Trois")) ;
w.show() ;
w.pack() ;
}
}
Gestionnaire par défaut : BorderLayout
Appli2.java
import java.awt.* ;
class Appli2 {
w.setLayout(new FlowLayout()) ;
w.add(new Label("Un")) ;
w.add(new Label("Deux")) ;
w.add( new Label("Trois")) ;
w.show() ;
w.pack() ;
}
}
Gestionnaire demandé : FlowLayout
Appli3.java
import java.awt.* ;
class Appli3 {
w.setLayout(new GridLayout(2,2)) ;
w.add(new Label("Un")) ;
w.add(new Label("Deux")) ;
w.add( new Label("Trois")) ;
w.add( new Label("Quatre")) ;
w.show() ;
w.pack() ;
}
}
6
Gestionnaire demandé : GridLayout
2012-2013
Exemple : construction de fenêtre
Les objets de type Panel n’ont pas d’apparence physique propre
o Ils permettent de
…
des composants, dont d’autres …
Chaque Panel gère ses propres composants avec le LayoutManager qui …
La fenêtre correspond ainsi au schéma suivant :
Les différents éléments sont systématiquement déclarés …
Le fichier UtilFenetre.java comporte deux classes :
o la classe Fenetre …
o la classe publique UtilFenetre constituant …
Les deux classes construisent la fenêtre souhaitée.
Mais pour le moment
…
n’est pris en compte sur cette fenêtre.
import java.awt.* ;
class Fenetre extends Frame {
protected Panel p1, p2, p3, p31, p32 ;
protected TextArea txt ;
protected Button bouton1, bouton2, bouton3 ;
protected CheckboxGroup cbg ;
protected Checkbox chb1, chb2, chb3 ;
protected List selection1, selection2 ;
7
Fenetre() {
setLayout(new FlowLayout()) ;
// construction du Panel p1
p1 = new Panel() ;
p1.setLayout(new GridLayout(4,1)) ;
p1.add(new Label("Jour")) ;
selection1 = new List(3) ;
selection1.addItem("lundi") ;
selection1.addItem("mardi") ;
selection1.addItem("mercredi") ;
selection1.addItem("jeudi") ;
selection1.addItem("vendredi") ;
selection1.addItem("samedi") ;
selection1.addItem("dimanche") ;
p1.add(selection1) ;
p1.add(new Label("Horaire")) ;
selection2 = new List(3) ;
selection2.addItem("9 h - 12 h") ;
p1.add(selection2) ;
add(p1) ;
p2 = new Panel() ;
p2.setLayout(new GridLayout(4,1)) ;
p2.add(new Label("Localisation")) ;
cbg = new CheckboxGroup();
chb1 = new Checkbox("Paris", cbg, true);
p2.add(chb1) ;
chb2 = new Checkbox("Lyon", cbg, false);
p2.add(chb2) ;
chb3 = new Checkbox("Marseille", cbg, false);
p2.add(chb3) ;
add(p2) ;
}
p3 = new Panel() ;
p3.setLayout(new BorderLayout()) ;
p31 = new Panel();
bouton1 = new Button("Valider") ;
p31.add(bouton1) ;
bouton2 = new Button("Désélectionner") ;
p31.add(bouton2) ;
p3.add("North", p31) ;
txt = new TextArea(5,30) ;
p3.add("Center",txt) ;
p32 = new Panel() ;
bouton3 = new Button("Quitter") ;
p32.add(bouton3) ;
p3.add("South", p32) ;
add(p3) ;
}
// fin du constructeur
// fin de la classe Fenetre
public class UtilFenetre {
// classe utilisateur
public static void main(String args[]) {
Fenetre f = new Fenetre() ;
f.pack() ;
f.show() ;
}
}
8
2012-2013
Création d’interfaces : bilan
Création d’un panel :
Création d’une zone de texte statique :
Création d’une zone de saisie de texte :
Création d’une liste de sélection :
Création d’un objet de type Choice :
Création de checkbox associés dans un groupe :
Création d’un bouton :
La gestion des événements
Principe de la gestion des événements
La fenêtre graphique délègue la gestion des événements à d’autres classes : c’est le modèle MVC (
…
)
Fenêtre =
…
(instance d’une classe)
Prise de décision =
Action =
…
…
…
(instance d’une autre classe)
(instance d’une troisième classe)
Principe de mise en œuvre en java
La fenêtre graphique contient des objets.
On attache un
Window, …)
…
(surveillant) aux objets graphiques que l’on souhaite surveiller (Button, List,
9
o
Il existe différents
…
.
…
dépendant du type d’objet à surveiller, mais tous sont des instances
On a donc besoin d’une classe implémentant les interfaces nécessaires ; on appellera cette classe la classe …
Un objet de la classe Adaptateur, étant de fait devenu un listener, sera alors automatiquement averti des
événements (event) qui se produisent sur …
Il décidera alors des actions à entreprendre en fonction …
Il donnera l’ordre à un
…
d’effectuer ces actions.
L’exécuteur sera un objet d’une classe que l’on appellera la classe
…
Il exécutera les actions demandées par l’objet Adaptateur et
en modifier l’apparence.
…
pour
Illustration par deux exemples
Clic sur un bouton contenu dans la fenêtre
Clic sur le bouton de fermeture de la fenêtre
Programmation
La VUE est
…
. C’est une instance d’une classe graphique.
Le CONTROLEUR est une instance d’une classe implémentant
…
On appellera cette classe la classe Adaptateur car elle décide comment
actions demandées par l’utilisateur.
…
La METHODE est une instance d’une classe contenant
…
On appellera cette classe la classe Delegue car le CONTROLEUR
responsabilité des actions à entreprendre sur la fenêtre.
10
…
la fenêtre aux
à la METHODE la
2012-2013
Application à la fenêtre précédente
Résultat attendu :
Pour les étapes suivantes, complétez chaque fois que nécessaire le fichier
figurant pages 13 et 14
Etape 1. Dans le constructeur de la fenêtre, on déclare un attribut de nom delegue de la classe Delegue
protected Delegue delegue ;
Puis on demande à la classe Delegue la création d’un objet Delegue par appel au constructeur en lui envoyant
…
delegue = new Delegue(this) ;
// this = ...
L’adresse du délégué ainsi créé est donc stockée dans
…
tandis que le délégué stocke dans son attribut fen l’adresse de la fenêtre pour pouvoir ultérieurement …
Analogie avec le courrier :
Nous écrivons à un destinataire que nous venons de découvrir (à une adresse que nous gardons en mémoire) et
nous lui envoyons notre propre adresse (this) pour qu’il puisse lui-même la stocker et nous répondre plus tard.
Etape 2. On définit une classe Adaptateur qui
…
les événements et décide des actions à
faire accomplir par le délégué. Pour cela, la classe Adaptateur implémente
…
selon le type
…
11
Exemple : pour surveiller les éléments sur un bouton et sur une fenêtre, il faut écrire :
class Adaptateur implements WindowListener, ActionListener {
...
}
et définir dans la classe Adaptateur
ActionListener (…).
…
des interfaces WindowListener (…) et
Etape 3. On déclare dans le constructeur de la fenêtre un attribut appelé adapt de la classe Adaptateur :
protected Adaptateur adapt ;
Puis on demande au constructeur de la classe Adaptateur de créer un objet de la classe Adaptateur en lui
envoyant l’adresse du délégué, puisque
…
adapt = new Adaptateur(delegue) ;
Penser encore à l’analogie avec le courrier : nous écrivons à un second destinataire (l’Adaptateur adapt), mais
nous lui demandons de répondre ultérieurement au premier destinataire (le delegue), dont il n’a pas a priori
l’adresse. Il faut donc lui passer cette adresse, pour qu’il puisse la stocker.
La fenêtre stocke l’adresse
L’adaptateur stocke l’adresse
…
…
dans son attribut adapt.
dans un attribut delegue :
Etape 4. Dans le constructeur de la fenêtre, on “enregistre” l’Adaptateur adapt sur …
Les méthodes d’enregistrement des adaptateurs dépendent …
Exemple : si bouton1 est un objet de la classe Button, et si adapt doit surveiller bouton1, on écrira :
bouton1. ...
12
2012-2013
Etape 5. On complète dans la classe Adaptateur les méthodes obligatoires provenant
…
On écrit dans la classe Delegue les méthodes nécessaires pour que le délégué puisse effectuer …
import java.awt.* ;
import ...
// la classe de la fenêtre (la VUE)
protected Panel p1, p2, p3, p31, p32 ;
protected TextArea txt ;
protected Button bouton1, bouton2, bouton3 ;
protected CheckboxGroup cbg ;
protected Checkbox chb1, chb2, chb3 ;
protected List selection1, selection2 ;
protected ...
protected ...
Fenetre() {
// construction des Panel p1, p2 et p3
...
// ajouts pour la gestion des événements
// création du délégué et de l’adaptateur
delegue = ...
adapt = ...
// enregistrement de l’adaptateur comme listener
addWindowListener...
bouton1.addActionListener...
}
}
public class UtilFenetre { // la classe utilisateur
f.pack() ; f.show() ;
}
}
class Delegue {
protected Fenetre fen ;
// partie traitement (la METHODE)
Delegue(Fenetre f) {
fen = f ;
}
public void quitter() {
...
}
public void annulle() {
fen.selection1.deselect...
fen.selection2.deselect...
fen.chb1.setState...
fen.txt.setText...
}
public void affichetexte() {
String res = "Vous avez choisi le " + ...
res=res + "\ndans la tranche horaire " + ...
res=res + "\nà " + ...
fen.txt.setText...
}
}
13
class Adaptateur implements ActionListener, WindowListener {
// aiguillage (le CONTROLEUR)
Adaptateur(Delegue d) {
delegue = d ;
}
// méthode indispensable comme ActionListener
public void actionPerformed(ActionEvent e) {
Object src = ...
String param = ...
if (param == "Quitter") delegue.quitter() ;
else if (param == "Désélectionner")
delegue.annulle() ;
else delegue.affichetexte() ;
}
// méthodes indispensables comme WindowListener
public void windowClosing(WindowEvent e) {
delegue.quitter() ;
}
public void windowClosed(WindowEvent e) {}
public void windowIconified(WindowEvent e) {}
public void windowDeiconified(WindowEvent e) {}
public void windowActivated(WindowEvent e) {}
public void windowDeactivated(WindowEvent e) {}
public void windowOpened(WindowEvent e) {}
}
Les saisies et récupérations de données
Champ de saisie de type texte
Création
txt = new TextField() ;
txt = new TextField(10) ;
Remplissage
txt...
Récupération
String res = ...
Vidage
txt...
Choix dans un List ou Choice
Création
ll = new List() ;
ll = new List(10) ;
ll = new Choice() ;
Remplissage
ll...
Récupération
String res = ...
int n = ...
Remplissage par boucle : ajouter une suite de nombres dans un objet de type Choice ou List
Choice c = new Choice();
for (int i=1 ; i < 20; i++) {
// autorisés, au choix :
c...
OU c...
}
14
2012-2013
Choix d’un Checkbox dans un groupe
Création
cbg = new CheckboxGroup() ;
c1=new Checkbox("prop 1",...
c2=new Checkbox("prop 2",...
);
);
Récupération
String res = cbg.getSelectedCheckbox()...
boolean etat1 = c1...
boolean etat2 = c2...
Les conversions et les calculs
Donnée = chaîne de caractères
Toute donnée entrée dans un champ de saisie ou récupérée d’une liste de sélection est
…
Pour être utilisable en vue de calculs, elle doit être convertie en …
Les méthodes de conversion dépendent …
Conversion d’une chaîne ch en nombre
En un entier n :
o
o
int n = ...
int n = ...
En un flottant f :
o
o
float f = ...
float f = ...
En un double d :
o
o
double d = ...
double d = ...
Conversions d’un nombre en chaîne
Conversions inverses pour l’affichage du …
Toute donnée à afficher dans une fenêtre graphique doit être de type …
Conversion d’un entier n en chaîne ch
o
String ch = ...
Conversion d’un flottant f en chaîne ch
o
String ch = ...
Conversion d’un double d en chaîne ch
o
String ch = ...
Exemple
Compléter l’application UtilCalculs.java suivante pour qu’elle exécute la conversion d’euros en dollars :
import java.awt.* ;
import java.awt.event.* ;
static double t = 1.4 ;
protected Panel p0,p1,p2 ;
protected TextField txt1, txt2 ;
protected Button bouton ;
15
Fenetre() {
p0 = new Panel() ;
p0.add(new Label("Conversion euros --> dollars"));
add("North", p0);
p1 = new Panel() ;
p1.setLayout(new GridLayout(2,3));
p1.add(new Label("montant en €"));
p1.add(new Label(" ")) ;
p1.add(new Label("montant en $")) ;
txt1 = new TextField(3) ; p1.add(txt1);
bouton = new Button(" = "); p1.add(bouton) ;
add("Center", p1) ;
p2 = new Panel() ;
p2.add(new Label("Taux actuel : 1 euro vaut " + t + " $"));
add("South", p2);
addWindowListener(adapt) ;
bouton.addActionListener(adapt) ;
}
}
public class UtilCalculs {
f.pack() ; f.show() ;
}
}
class Delegue {
protected Fenetre fen
fen = f ;
}
public void quitter()
System.exit(0)
}
public void calcule()
...
...
...
...
}
}
;
{
;
{
public Adaptateur(Delegue d) {
delegue = d ;
}
delegue.calcule() ;
}
delegue.quitter() ;
}
}
16
2012-2013
Les applets Java
Qu’est-ce qu’une applet ?
Une applet est une
…
même temps que la page HTML.
, insérée dans une page HTML et chargée par un navigateur en
Insertion d’une applet dans une page HTML : balises <applet> et </applet>
en gras les lignes obligatoires
URL où on cherche le fichier .java
nom du fichier de pseudo-code
texte si navigateur non compatible
nom de l’applet dans la page html
largeur puis hauteur de la
zone d’affichage de l’applet
paramètres
éventuels
<applet
codebase=codebase_URL
code="nomclasse.class"
alt="texte_de_remplacement"
name="nom_instance"
width="pixels"
height="pixels" >
<param name=nom_param1 value="valeur1">
<param name=nom_param2 value="valeur2">
</applet>
Exécutée par l’interpréteur java du navigateur, l’applet permet de
…
certains
(calculs, animations graphiques, vérification de la validité d’un formulaire, etc) chez …
traitements
Du point de vue informatique, une applet est une instance d’une classe java héritant de …
import java.applet.* ;
class monApplet extends Applet {
...
}
Elle gère seule son apparence dans la zone …
Différences entre applet et application
Stockage
Une application réside généralement
…
Une applet, chargée à travers le réseau, reste
le disque dur de la machine qui l’exécute.
de l’ordinateur qui l’exécute.
…
; elle n’est
… stockée sur
Lancement
Une application est lancée
…
, pour …
Une applet est initialisée et démarrée au premier chargement d’une page HTML, puis
à chaque fois que l’utilisateur recharge la même page HTML.
…
Droits de lecture et écriture
Une application peut
autre programme,
…
…
Une applet ne peut
…
ne peut communiquer qu’avec …
un fichier sur le disque dur,
avec d’autres machines
un
de fichier sur le disque dur, ni lancer de programme ; elle
Méthodes d’une applet
La classe maître de l’applet est une classe
…
…
17
, dérivant de la classe …
Elle ne comporte jamais de méthode
o
o
o
o
o
o
…
, mais elle dispose de méthodes spécifiques :
le constructeur de la classe, …
init() réalisant …
start() qui lance l’applet au démarrage et à chaque fois que l’applet a été stoppée (rechargement de la
page HTML, par ex)
stop() qui
…
l’applet (lors d’un changement de page, par ex)
destroy() qui
…
lorsque le navigateur est fermé
paint(Graphics g) qui …
en permanence l’applet sur l’écran à l’aide d’un contexte graphique
g fourni.
Exécution d’une applet
Lorsqu’un navigateur a chargé une page HTML contenant une applet, il lance l’interpréteur java qui appelle la
méthode
…
de l’applet.
Cette méthode initialise l’applet et charge
L’interpréteur appelle ensuite les méthodes
pour la lancer et la dessiner.
…
…
et
dont l’applet a besoin
…
de
l’applet
L’applet assume ensuite avec ses propres méthodes la gestion de sa zone d’affichage. Pour être redessinée, elle
fait appel à la méthode
…
Méthodes à programmer
Les méthodes qu’il faut généralement redéfinir sont :
o init() pour …
o paint(Graphics g) si …
Les autres méthodes (héritées de Applet) n’ont généralement pas à être redéfinies.
Si l’on veut permettre à l’utilisateur d’interagir avec l’applet, il faut gérer les événements en définissant (comme
pour les applications) les classes …
(contrôleur) et
…
(exécuteur).
Lancement d’une applet
Il y a deux manières de lancer des applets :
o
faire appel à un
…
(l’appletViewer) à qui on donne le nom de la page HTML contenant
l’applet : appletViewer …
La page HTML n’est pas visible, seule
…
est visualisée
o
faire appel à un
…
en lui faisant charger la page HTML contenant l’applet
Transformation d’une application en applet
Conditions
On peut transformer une application en applet à certaines conditions :
o Ne pas avoir besoin …
o
Ne pas avoir de traitement …
Liste des modifications à effectuer
o
o
o
importer le paquetage …
faire dériver la classe de la fenêtre (la VUE) de la classe
…
supprimer la classe principale de l’application (ce qui impose de
18
(au lieu de la classe Frame)
…
)
o
o
o
o
o
o
2012-2013
la classe de la fenêtre étant devenue la classe maître, la déclarer
…
et
constructeur en ...
modifier la classe
…
pour qu'elle n'implémente plus l'interface …
modifier la classe de la VUE en conséquence
modifier la classe
…
en conséquence
écrire …
compiler et tester avec l’appletViewer et avec un navigateur.
renommer
son
Exemple
Transformer l’application UtilCalculs.java en une applet intégrée dans une page HTML.
import java.awt.* ;
...
protected Panel p0,p1,p2 ;
protected TextField txt1, txt2 ;
protected Button bouton ;
Fenetre() {
p0 = new Panel() ; p0.add(new Label("Conversion euros --> dollars"));
add("North", p0);
p1 = new Panel() ; p1.setLayout(new GridLayout(2,3));
p1.add(new Label("montant en €"));
p1.add(new Label(" ")) ; p1.add(new Label("montant en $")) ;
bouton = new Button(" = "); p1.add(bouton) ;
add("Center", p1) ;
p2 = new Panel() ;
p2.add(new Label("Taux actuel : 1 euro vaut 1,55 $"));
add("South", p2);
delegue = new Delegue(this) ; adapt = new Adaptateur(delegue) ;
addWindowListener(adapt) ;
bouton.addActionListener(adapt) ;
}
}
public class UtilCalculs {
Fenetre f = new Fenetre() ; f.pack() ; f.show() ;
}
}
class Delegue {
protected Fenetre fen ;
fen = f ;
}
public void quitter() {
System.exit(0) ;
}
public void calcule() {
String txt1 = fen.txt1.getText() ;
double euros = new Double(txt1).doubleValue() ;
double dollars = euros * 1.55 ;
String txt2 = new Double(dollars).toString() ;
Fen.txt2.setText(txt2);
}
}
19
delegue = d ;
}
delegue.calcule() ;
}
delegue.quitter() ;
}
}
Page HTML appelant l’applet :
<html>
<head>
<title> Applet</title>
</head>
<body>
<h2><center>Applet Calculs</center></h2>
<center>
<applet code="Fenetre.class" width="300" height="300">
</applet>
</center>
</body>
</html>
Création directe d’une applet
Il faut écrire :
o la classe maître de l’applet dérivant de la classe Applet
o les classes Delegue et Adaptateur si l’utilisateur interagit avec l’applet
o la page HTML
Page valacquise.html :
<HTML>
<HEAD>
<TITLE> Applet</TITLE>
</HEAD>
<BODY>
<center>
<APPLET CODE="ValAcquise.class" WIDTH="300" HEIGHT="150">
</APPLET>
</center>
</BODY>
</HTML>
Les dimensions reserves à l’applet sont …
Le fichier de l’applet comporte :
o la classe dérivant de Applet :
20
2012-2013
import java.awt.* ;
public class ValAcquise extends Applet {
protected TextField montant, taux, nb, valeur ;
protected Button valider ;
protected Delegue delegue;
protected Adaptateur adapt;
public void init() {
setLayout(new GridLayout(3,3));
add(new Label("Montant"));
add(new Label("Taux"));
add(new Label("Nombre d'années"));
Panel p1 = new Panel();
montant = new TextField(10);
p1.add(montant);
add(p1);
taux = new TextField(10);
p2.add(taux);
add(p2);
nb = new TextField(10);
p3.add(nb);
add(p3);
valider = new Button("Valider");
p4.add(valider);
add(p4);
p5.add(new Label("Valeur acquise"));
add(p5);
valeur = new TextField(10);
p6.add(valeur);
add(p6);
delegue = new Delegue(this);
adapt = new Adaptateur(delegue);
valider.addActionListener(adapt);
}
}
o
la classe Adaptateur :
class Adaptateur implements ActionListener {
delegue = d ; }
// événements surveillés en tant que ActionListener
delegue.calculeResultat() ;
}
}
o
la classe Delegue :
class Delegue {
protected ValAcquise va ;
Delegue(ValAcquise v) {
va = v ;
}
21
public void calculeResultat() {
}
}
Le fichier doit être enregistré sous le nom …
Exécution :
appletViewer …
ou …
Les images dans les applets
Principe
La classe Applet du paquetage java.applet contient une méthode appelée
…
qui permet à l’applet de
…
(mais pas d’…
) une image provenant du serveur.
Cette méthode renvoie un objet de la classe
On écrira donc, par exemple,
…
(classe du paquetage java.awt.image).
Image im = getImage(getDocumentBase(), "vnus.gif") ;
getDocumentBase()donne le répertoire du serveur où se trouve …
La classe Graphics s’occupe de l’apparence graphique des applications et des applets. Sa méthode drawImage
permet
…
Pour afficher l’image im à partir du point (20,20), pn écrira donc :
Image im = getImage(getDocumentBase(),"vnus.gif") ;
g.drawImage(im, 20, 20, this) ;
Le 4e argument de drawImage doit être un
…
Mais comme la classe Component (dont
dérive Applet) implémente cette interface, l’applet est elle-même un ImageObserver. On écrit donc this comme
4ème argument.
Applet affichant une image
Fichier AppletImage.java :
import java.awt.* ;
import java.awt.image.* ;
public class AppletImage extends Applet {
private Image im ;
im = getImage(getDocumentBase(),
}
public void paint(Graphics g) {
g.drawImage(im, 20, 20, this) ;
}
}
22
"vnus.gif") ;
2012-2013
Page appletimage.html :
<html>
<head>
<title> Applet</title>
</head>
<body>
<applet code="AppletImage.class" width="300" height="300">
</applet>
</body>
</html>
Applet visualiseur d’images
Lecture sur le serveur d’un fichier appelé « listephotos.txt » contenant des noms d’images
o Affichage de la liste des images dans une liste de sélection
o Choix de l’image par simple clic sur son nom
Fichier listephotos.txt :
13
statuesRamses
DeirElBahari
ballon
Ramasseum
Allee
villageArtisans
villageDetail
coucherSoleil
fresque
valleeRois
portail
esna
temple
nombre de photos
liste des noms des photos
Page visualiseur.html :
<html>
<head>
<title>Applet</title>
</head>
<body>
<center><h2><center>Catalogue de photos</h2>
<applet code="Visualiseur.class" width="410" height="280">
</applet></center>
</body>
</html>
Fichier Visualiseur.java :
import
import
import
import
import
...
public
java.awt.* ;
java.applet.* ;
java.awt.image.* ;
java.io.* ;
java.net.* ;
class Visualiseur extends Applet {
protected Panel p1, p2, p11, p12 ;
protected List liste ;
protected Image image ;
...
...
23
URL url ; // URL pour retrouver listephotos.txt sur le serveur
InputStream stream ;
// flot vers le serveur
BufferedReader fichier ; // buffer de lecture de données
int nblignes;
// nombre de lignes à lire
setLayout(new BorderLayout()) ;
p1 = new Panel() ;
liste = new List() ;
try
{
url = new URL(getDocumentBase(),"listephotos.txt") ;
stream = url.openStream() ;
// ouverture du flot
fichier =new BufferedReader(new
InputStreamReader(stream)); // ouverture du buffer
// recuperation du nombre de lignes à lire
nblignes = Integer.parseInt(fichier.readLine()) ;
// lecture et mise des noms de photos dans la liste
for (int i = 0 ; i < nblignes ; i++)
liste.add(fichier.readLine()) ;
}
catch (IOException e) {}
p1.add(liste) ;
add("North", p1) ;
...
...
...
image = getImage(getDocumentBase(), liste.getItem(0)+".jpg") ;
}
g.drawImage(image, 55, 60, this) ;
}
}
En exécutant l’applet, on constate que la liste des photos est bien mise à jour, mais que lorsqu’on clique sur un
nom de photo il ne se passe rien.
Or on souhaite qu’en cliquant sur le nom d’une image, celle-ci s’affiche. Il faut donc gérer un événement d’un
type
…
de ceux gérés jusqu’à présent.
L’Adaptateur doit donc implémenter une interface susceptible d’écouter les actions sur un objet de la classe …
Cette interface est l’interface
…
.
Une seule méthode doit être définie : la méthode …
import
import
import
import
import
import
java.awt.* ;
java.applet.* ;
java.awt.image.* ;
java.awt.event.* ;
java.io.* ;
java.net.* ;
public class Visualiseur extends Applet {
protected List liste ;
protected Image image ;
URL url ;
InputStream stream ;
BufferedReader fichier ;
int nblignes;
setLayout(new BorderLayout()) ;
p1 = new Panel() ;
liste = new List() ;
24
2012-2013
try
{
url = new URL(getDocumentBase(), "listephotos.txt") ;
stream = url.openStream() ;
fichier =new BufferedReader(new
InputStreamReader(stream));
nblignes = Integer.parseInt(fichier.readLine()) ;
for (int i = 0 ; i < nblignes ; i++)
liste.add(fichier.readLine()) ;
}
catch (IOException e) {
}
p1.add(liste) ;
add("North", p1) ;
image = getImage(getDocumentBase(), liste.getItem(0)+".jpg") ;
...
}
g.drawImage(image, 55, 60, this) ;
}
}
class Delegue {
protected Visualiseur v ;
Delegue(Visualiseur i) {
v = i ;
}
void afficher() {
...
...
...
}
}
class Adaptateur implements
delegue = d ;
}
public void
...
...
}
}
...
(...
Paramètres provenant de la page HTML
Principe
Une page HTML peut passer des
…
à une applet.
Si la page HTML contient les lignes :
<applet code= "truc.class" …>
<param name="nom" value="dupont">
</applet>
alors on peut récupérer le nom dans les méthodes de l’applet par :
String nom =...
25
{
e) {
Exemple : version initiale sans paramètre
Dans la page interets0.html :
<html>
<head><title> Applet</title></head>
<body>
<center><h2><center>Calcul d'intérêts</h2>
<applet code="Interets0.class" width="310" height="200">
</applet></center>
</body>
</html>
Dans le fichier Interets0.java ci-dessous le taux est donné « en dur » dans la méthode calcule de la classe
Delegue : double taux = 4.5 ;
Changement de taux  …
import java.awt.* ;
public class Interets0 extends Applet {
protected TextField montant, nb, res ;
protected Button ok ;
setLayout(new GridLayout(4,1)) ;
p1 = new Panel() ;
p1.add(new Label("Montant initial : ")) ;
p1.add(montant) ;
add(p1) ;
p2 = new Panel() ;
p2.add(new Label("Nombre d'années : ")) ;
p2.add(nb) ;
add(p2) ;
p3 = new Panel() ;
ok = new Button("OK");
p3.add(ok) ;
add(p3) ;
p4 = new Panel() ;
p4.add(new Label("Montant obtenu : ")) ;
res = new TextField(10);
p4.add(res) ;
add(p4) ;
ok.addActionListener(adapt);
}
}
class Delegue {
protected Interets0 interets ;
Delegue(Interets0 i) {
interets = i ;
}
void afficher() {
double montant = ...
int annees = ...
double taux = 4.5 ;
26
2012-2013
for (int i = 0; i < annees; i++)
montant = ...
interets.res.setText(
}
...
}
delegue = d ;
}
delegue.afficher() ;
}
}
Version avec un paramètre
Dans la page interets1.html :
<html>
<body>
<param name='taux' value='4.25'>
</applet></center>
</body>
</html>
Dans afficher() de Interets1.java :
import
import
import
public
java.awt.* ;
java.applet.* ;
java.awt.event.* ;
class Interets1 extends Applet {
p1 = new Panel() ;
p1.add(montant) ;
add(p1) ;
p2 = new Panel() ;
p2.add(nb) ;
add(p2) ;
p3 = new Panel() ;
p3.add(ok) ;
add(p3) ;
p4 = new Panel() ;
p4.add(res) ;
add(p4) ;
}
}
27
);
class Delegue {
interets = i ;
}
void afficher() {
double montant = new Double(interets.montant.getText()).doubleValue();
int annees = new Integer(interets.nb.getText()).intValue();
double taux = ...
for (int i = 0; i < annees; i++)
montant = montant *(1 + taux/100) ;
interets.res.setText(new Double(montant).toString());
}
}
delegue = d ;
}
}
}
Il suffit alors de changer la valeur
(sans …
…
de la page HTML pour modifier le taux
).
Version avec trois paramètres
On ajoute deux nouvelles balises <PARAM> dans la page HTML pour un 2ème taux et un montant seuil
permettant de passer d’un taux à l’autre.
Page interets2.html :
<html>
<body>
<param name='taux1' value='4.25'>
<param name='taux2' value='5.25'>
<param name='montant' value='20000'>
</applet></center>
</body>
</html>
Dans le fichier Interets2.java, la seule modification est encore dans afficher() :
import java.awt.* ;
public class Interets2 extends Applet {
p1 = new Panel() ;
28
2012-2013
p1.add(montant) ;
add(p1) ;
p2 = new Panel() ;
p2.add(nb) ;
add(p2) ;
p3 = new Panel() ;
p3.add(ok) ;
add(p3) ;
p4 = new Panel() ;
p4.add(res) ;
add(p4) ;
}
}
class Delegue {
interets = i ;
}
void afficher() {
double montant = new Double(interets.montant.getText()).
doubleValue();
int annees = new Integer(interets.nb.getText()).intValue();
double taux1 = ...
double taux2 = ...
double bascule = ...
double taux ;
...
for (int i=0 ; i < annees ; i++)
montant = montant * (1 + taux/100);
interets.res.setText(new Double(montant).toString());
}
}
delegue = d ;
}
}
}
Application au projet
Dans le projet, le calcul de la mensualité dépend du taux, qui dépend lui-même d’une valeur (montant emprunté
ou durée de l’emprunt…)
Dans la partie applet :
Si on met les taux et les valeurs de bascule dans la page HTML, il n’est plus nécessaire de recompiler l’applet à
chaque changement de valeur soit du taux, soit des valeurs servant de bascule.
29
Annexes
Noms des variables
Le nom d’une variable est composé d’un seul mot et commence obligatoirement par une lettre. Il peut être
constitué de lettres, de chiffres ou du caractère souligné _ et peut contenir un nombre quelconque de caractères
(se limiter pour la commodité à une taille raisonnable).
Casse
Il y a une distinction entre minuscules et majuscules (java est toujours sensible à la CASSE). Par convention les
noms de variable sont orthographiés en lettres minuscules sauf la première lettre de chaque mot si le nom de la
variable en comporte plusieurs : nomDeFamille par exemple.
Mots clés
Les mots clés du langage ne peuvent en aucun cas être utilisés comme noms de variable.
Ce sont les mots :
abstract
case
continue
extends
for
instanceof
new
public
super
throws
volatile
assert
catch
default
false
goto
int
null
return
switch
transient
while
boolean
char
do
final
if
interface
package
short
synchronized
true
break
class
double
finally
implements
long
private
static
this
try
byte
const
else
float
import
native
protected
strictfp
throw
void
Portée des variables
La portée d’une variable est la portion de code dans laquelle on peut manipuler cette variable. Elle est fonction
de l’emplacement où est située la déclaration de la variable.
La déclaration d’une variable peut être faite dans le bloc de code d’une classe, le bloc de code d’une fonction ou
un bloc de code à l’intérieur d’une fonction (boucle for, while, do while par exemple). Seul le code du bloc où
est déclarée la variable peut utiliser la variable.
Il ne peut pas y avoir deux variables portant le même nom avec la même portée. On peut cependant déclarer une
variable interne à une fonction ou un paramètre d’une fonction ayant le même nom qu’une variable déclarée au
niveau de la classe. La variable déclarée au niveau de la classe est dans ce cas masquée par la variable interne à
la fonction.
30

Fascicule de cours 2 - Laboratoire d`Informatique de Paris 6

Transcription

Documents pareils

DELEGUE MEDICAL

préparation conseil de classe

DELEGUE MEDICAL F/H POUR CHAQUES REGIONS

Ingénieur/Architecte logiciel

district cote d`azur de football

Communiquer avec la carte

LIGUE POITOU-CHARENTES DE VOLLEY

Exposé Carte à puce

TP 1 : premiers pas pratiques

Programmation SIG et Internet Cartographique Séance 4 : Applet