Cours intensif Java

publicité
.
Cours intensif Java
3er cours: introduction aux Applets
Septembre 2009
Enrica D UCHI
LIAFA, Paris 7
[email protected]
JAVA ET L’ INTERNET
Applet:
programmes écrits en java et intégrés dans une page web
utilisées pour créer des applications interactives qu’on ne peut pas faire
avec HTML
chargée depuis une machine distante (serveur)
exécutée sur la machine locale (client)
exécutée sous le controle d’une autre application (navigateur avec
interpréteur java)
Servlet: (hors du champs de ce cours)
pour développer des serveurs pour internet.
R ESTRICTIONS ET SÉCURITÉ
Pour assurer la sécurité des utilisateurs, certaines opérations sont interdites
aux applets par défaut.
Une applet ne peut exécuter que son propre code, ne peut accéder aux
fichiers de la machine client et ne peut modifier les propriétés système de
la machine client.
Une applet peut interagir au travers du réseau uniquement avec le
serveur sur lequel elle a été chargée.
Il est possible, avec le consentement explicite de l’utilisateur, de donner
quelques permissions, toujours assez limités, à des applets dont on a vérifié
la provenance au moyen de signatures électroniques (pas traité ici).
U NE PREMIÈRE APPLET
Une applet qui écrit Hello web.
import java.awt.*;
import java.applet.*;
public class MonApplet extends Applet
{
public void paint(Graphics gc){
gc.drawString("Hello Web",40,40);
}
}
Notre applet est un objet de la classe Applet du package java.applet.
La classe Applet hérite de la classe Panel définie dans la bibliothèque
d’interface graphique awt: une applet est donc un objet graphique !
Pour comprendre cette applet il nous faut étudier un peu la bibliothèque awt
où sont définis la classe Graphics et la méthode drawString.
I NTERFACES GRAPHIQUES
Les packages pour interfaces graphiques (GUI pour Graphical User Interface)
Le package initial java.awt.
Le package javax.swing, plus avancé et permettant de faire certaines
opérations plus simplement, mais réutilisant les concepts de base de awt.
Les applications utilisent maintenant plutôt swing, mais pour comprendre les
concepts de base en peu de temps, awt est plus commode.
On distingue deux grandes parties dans la création d’une GUI:
la définition de tout ce qui peut être affiché: fenêtre, dessins, bouton,
barre d’outils, menu déroulant, etc.
la gestion des évènements: interagir avec l’utilisateur (souris, clavier, etc).
Nous aurons le temps d’aborder uniquement la première partie: suffisante
pour faire une page applet animée, à défaut d’être interactive.
M ON PREMIER COMPOSANT GRAPHIQUE: UNE FENÊTRE
Pour ouvrir une fenêtre on commence par créer une classe qui la décrit: cette
classe hérite de la classe Frame (fenêtre générique) et de ses méthodes,
entre autres setTitle, setSize, setVisible:
public class Fenetre extends Frame
{
public Fenetre(){
setTitle("Fen^
etre, modèle Duchi");
setSize(500,700);
setVisible(true);
}
}
Il suffit maintenant de créer un objet de la classe Fenetre !
class Essai
{
public static void main(String [] arg){
Fenetre f=new Fenetre();
}
}
L’exécution ouvre une fenêtre moins large que haute: les boutons habituels
sont présents mais inactifs, il faut tuer le processus (Ctrl-C) pour l’arrêter.
LA VOILÀ
C ONTENANT ET CONTENU
Notre objet fenêtre est un composant graphique avec deux qualités:
la fenêtre dispose d’un environnement graphique: il s’agit d’un objet qui
gère l’affichage dans le rectangle de la fenêtre.
les fenêtre est un contenant: elle peut contenir d’autres composants
graphiques (des applets, des menus, des boutons, etc).
Pour utiliser un composant, par exemple une fenêtre, on peut:
utiliser les méthodes de l’environnement graphique pour dessiner
directement dans le rectangle, indexé en coordonnées cartésiennes.
ou ajouter des (sous-)composants dans le contenant, comme par
exemple, des zones de dessins, des boutons, des menus, etc.
Ces composants sont alors disposés suivant une mise-en-page
automatique (layout) paramétrable, qui s’adapte au rectangle.
Les composants ajoutés dispose de leur environnement graphique et peuvent
être aussi des contenants auxquels on peut ajouter d’autres composants, etc.
(Pour compléter le tableau, on dira seulement que les interactions avec l’utilisateur sont réalisées
en associant à ces composants des écouteurs qui attendent un évènement particulier (clic ou
clavier) pour effectuer des actions.)
L’ ENVIRONNEMENT GRAPHIQUE D’ UN COMPOSANT
L’environnement graphique d’une fenêtre (ou plus généralement d’un
composant graphique) est un objet g de la classe java.awt.Graphics
l’objet g s’occupe de gérer une zone graphique: un rectangle de
dimension fixée dans lequel on peut dessiner;
l’objet g dispose de méthodes graphiques variées telles que drawLine(),
drawString(), drawImage(), setColor(), fillRectangle(), dont les
effets sont d’effectuer les opérations nommées dans le rectangle:
le rectangle est muni d’un système de coordonnées cartésiennes (origine
en haut à gauche); ces coordonnées sont utilisées par les méthodes
graphiques pour spécifier les opérations à faire dans le rectangle.
void monLogo(Graphics g, int x, int y){
g.drawOval(x,y,10,10);
g.drawRect(x+5,y+10,10,20);
}
Pour dessiner mon logo (un rond et un carre) en position 50,50 il suffit
d’appeler la méthode: monLogo(g,50,50);
L A GESTION DE L’ ENVIRONNEMENT GRAPHIQUE
Chaque composant (en particulier notre fenêtre) hérite d’une méthode
paint(Graphics g) qui par défaut ne fait rien et d’une méthode repaint().
La méthode paint est appelée automatiquement avec l’environnement
graphique de notre fenêtre en argument lorsque le window manager décide
qu’il faut la raffraichir, ou lorsqu’on appelle explicitement repaint().
Pour dessiner dans notre fenêtre il faut redéfinir sa méthode paint:
public class Fenetre extends Frame
{
public Fenetre(){
setTitle("Fen^
etre, modèle Duchi");
setSize(500,700);
setVisible(true);
}
public void paint(Graphics g){
monLogo(g,50,50,10);
g.drawString("Quel progrès !",50,100);
}
}
La fenêtre créée se redessine automatiquement chaque fois que nécessaire.
L ES COMPOSANTS ET LEUR DISPOSITION
La méthode paint est fournie par la classe abstraite java.awt.Component,
avec d’autres méthodes permettant de fixer les caractéristiques principales
du composant. Par exemple:
setBackground(Color.yellow), setForeground(Color.red),etc.
Les sous-classes de Component qui nous serviront sont:
Canvas. Un objet de cette classe n’a que son environnement graphique,
pas de sous-composants. Il peut être inclus dans un contenant.
Container. Les objet de cette classe sont ceux qui peuvent contenir des
sous-composants. Les sous-classes de cette classe sont:
Panel. Les objets de cette classe sont les contenants qui peuvent être
eux-mêmes inclus dans un autre contenant.
Windows. Les objets de cette classe sont les contenants qui
interagissent directement avec le window manager (ils peuvent être
déplacés). Ils ne peuvent pas être inclus dans un autre contenant
Frame: pour les “vraies” fenêtres (déjà utilisées)
Dialog: pour les boites de dialogue.
La classe Applet est une sous-classe de la classe Panel.
A JOUTER DES COMPOSANTS DANS UN CONTENEUR
On a dit que les conteneurs, comme par exemple une fenêtre, peuvent
recevoir des composants. La méthode pour ajouter un composant à un
conteneur est la méthode add de la classe Container.
Par exemple définissons une classe Message qui étend la classe Canvas et
utilisons la pour ajouter des composants dans un Panel.
class Message extends Canvas
{
String texte;
public Message(String texte){
setSize(100,30);
this.texte=texte;
}
public void paint(Graphics g){
g.drawString(this.texte,10,20);
}
}
class Bandeau extends Panel
{
public Bandeau(){
setSize(400,50);
setLayout(new BorderLayout);
add(new Message("A gauche"),"West");
add(new Message("A droite"),"East");
}
}
L’appel new Message("toto") crée un rectangle de taille 100 × 100 contenant
le texte toto. Le panel créé par l’appel new Bandeau() est de taille 100 × 100
et contient deux messages.
A JOUTER DES COMPOSANTS DANS UN CONTENEUR
class Message extends Canvas
{
String texte;
public Message(String texte){
setSize(100,30);
this.texte=texte;
}
public void paint(Graphics g){
g.drawString(this.texte,10,20);
}
}
class Bandeau extends Panel
{
public Bandeau(){
setSize(400,50);
setLayout(new BorderLayout);
add(new Message("A gauche"),"West");
add(new Message("A droite"),"East");
}
}
L’appel new Message("toto") crée un rectangle de taille 100 × 100 contenant
le texte toto. Le panel créé par l’appel new Bandeau() est de taille 100 × 100
et contient deux messages.
La méthode setLayout de la classe Container sélectionne une mise en page
des sous-composants: dans la mise en page BorderLayout, les composants
peuvent être mis sur les différents bords (nord, sud, est, ouest) ou au centre.
A JOUTER DES COMPOSANTS DANS UN CONTENEUR
On crée une classe Dessin qui étend Canvas pour y mettre un dessin, puis on
ajoute ce dessin et notre bandeau à une fenêtre.
class Dessin extends Canvas
{
public Dessin(){
setSize(200,200);
}
public void paint(Graphics g){
g.drawRect(50,50,75,100);
}
}
public class Fenetre extends Frame
{
public Fenetre(){
setTitle("Fen^
etre, modèle Duchi 2");
setLayout(new BorderLayout());
setSize(500,700);
add(new Bandeau(),"North");
add(new Dessin(),"Center");
setVisible(true);
}
}
La fenêtre obtenue contient en haut le bandeau et au centre le dessin.
R ETOUR SUR NOTRE APPLET
On est maintenant en mesure de lire le code de l’applet:
import java.awt.*;
import java.applet.*;
public class MonApplet extends Applet
{
public void paint(Graphics gc){
gc.drawString("Hello Web",40,40);
}
}
La classe Applet est une sous-classe de la classe Panel: on peut donc
ajouter une applet à une fenêtre avec la méthode add.
public class Fenetre extends Frame
{
public Fenetre(){
...
add(new MonApplet());
}
}
et l’utiliser dans un programme Java normal.
On verra bientôt une autre façon d’utiliser les applets, via les pages HTML.
L ES MÉTHODES DES APPLETS, CYCLE DE VIE
En tant que sous-classe de la classe graphique Panel, la classe Applet
hérite des méthodes paint(Graphic g) pour s’afficher et add(Component c)
pour inclure des composants graphiques.
Par ailleurs les applets ont un cycle d’exécution, controlé par les méthodes:
init(): initialisation de l’applet; appelée une seule fois au démarrage;
start(): réveil de l’applet; pour réveiller l’applet
stop(): endormissement de l’applet; pour endormir l’applet;
destroy(): destruction de l’applet; appelée à la terminaison.
Après avoir inclu une applet on va donc l’initialiser et la réveiller:
public Fenetre(){ // constructeur de la classe Fenetre
...
MonApplet uneApplet = new MonApplet();
add(uneApplet);
uneApplet.init();
uneApplet.start();
}
Si on savait gérer les évènements, on mettrait des boutons pour endormir et
reveiller l’applet (en appellant uneApplet.stop() et uneApplet.start()) et
un appel de uneApplet.destroy() à la fermeture de la fenêtre.
A PPLETS ET WEB
Les applets sont avant tout faites pour aller sur des pages web: on va voir
qu’on peut directement créer un objet Applet en chargeant la classe
MonApplet depuis une page HTML.
Le cycle de vie de l’applet prend alors tout son sens:
init(): initialisation de l’applet; elle sera lancée automatiquement au
chargement de la page web.
start(): reveil de l’applet; elle sera appelée automatiquement chaque
fois que la page web redevient visible.
stop(): endormissement de l’applet; elle sera appelée automatiquement
chaque fois que la page web est cachée.
destroy(): destruction de l’applet; elle sera appelée lorsqu’on quitte la
page web (pour aller sur une autre page par ex).
De plus, chaque fois que le window manager jugera utile de raffraichir la
page, la méthode MonApplet.paint() sera invoquée.
DANS LE FICHIER HTML
Pour créer une applet il suffit d’insérer une balise <APPLET>:
<HTML>
<BODY>
<APPLET CODE="MonApplet.class"
CODEBASE="http://serveur/mesapplets"
WIDTH=500 HEIGHT=700
ALT="chargement impossible">
J’écris ça si je suis un navigateur sans java.
</APPLET>
</BODY>
</HTML>
CODE indique le nom du fichier bytecode de la classe: MonApplet.class
CODEBASE donne l’adresse web où trouver le fichier (si il n’est pas dans
le même répertoire que la page HTML)
WIDTH et HEIGHT fixent les dimensions de l’environnement graphique
(remplace l’appel à setSize)
ALT donne le message pour le cas où on n’arrive pas à charger l’applet
entre les 2 balises <APPLET> et </APPLET> on écrit le message qui
remplace l’applet si le navigateur ne gère pas Java.
A PPLET LANCÉE DEPUIS UNE PAGE WEB
Récapitulons: à la lecture du code HTML, le navigateur
charge le bytecode de la classe
crée un objet a de la classe MonApplet en appelant le constructeur par
défaut de la classe
appelle les méthodes a.init() et a.start()
Ensuite le cycle de vie se déroule avec appels automatiques de a.start(),
a.stop(), a.paint(), a.destroy(), comme décrits précédement.
PARAMÉTRAGE D ’ UNE APPLET DEPUIS HTML
Pour transmettre des paramètres à une applet depuis la page HTML:
dans le code HTML, on insère entre <APPLET> et </APPLET> la balise:
<PARAM NAME = "monParametre" VALUE = "saValeur">
dans l’applet on insère un appel getParameter("monParametre") qui
renvoit un String contenant "saValeur".
Un exemple:
public class MonApplet implements Applets
{
private String message;
public void init(){
message = getParameter("monParametre");
}
public void paint(Graphics g){
g.drawString(message,100,50)
}
}
I NSÉRER DES IMAGES
La classe java.awt.Image fournit les outils pour charger des images à partir
d’une adresse web: en particulier la méthode
Image monImage = getImage(adresseWeb,"photoVacances.jpeg")
Le paramètre adresseWeb est un objet de la classe java.net.URL, obtenu à
l’aide de la méthode getCodeBase() de la classe Applet:
URL adresseWeb=getCodeBase();
Le chargement des images se fait en général à l’initialisation, dans la
méthode init.
On peut ensuite insérer l’image obtenue dans un environnement graphique
avec la méthode drawImage() de la classe Graphics:
dans la méthode paint(Graphics g) faire:
g.drawImage(monImage,0,0,this)
pour insérer l’image à la position 0,0.
A RCHIVES . JAR
Le programme jar permet de créer une archive au format ZIP contenant les
fichier .class et les éventuels autres fichiers dont l’applet pourrait avoir
besoin (images, etc).
En chargant un fichier .jar contenant tout ce qui sert on évite que l’applet
n’aille chercher les classes et les images dont elle a besoin une par une sur
le serveur web.
La commande jar s’utilise avec une syntaxe similaire à la commande tar.
Par exemple pour créer une archive ArchiveApplet.jar contenant tous les
fichiers .class du répertoire et un fichier image uneImage.jpeg on écrit:
jar cf ArchiveApplet.jar *.class uneImage.jpeg
Pour charger une applet sous forme d’archive a partir d’une page web il faut
ajouter le champs ARCHIVE="ArchiveApplet.jar" dans la balise <APPLET>
où figure le champs CODE qui indique le nom de la classe à exécuter.
A PPLETVIEWER
Lorsqu’on développe des applets le programme Appletviewer est très utile: il
permet de lancer une applet comme depuis une page web sans avoir à écrire
le code HTML et sans lancer de navigateur.
La commande appletviewer prend en argument un fichier texte contenant
une balise <APPLET CODE="maClasse.class" WIDTH=100 HEIGHT=80>
</APPLET>. Une façon commode de l’utiliser est d’inclure une ligne de
commentaire:
// <APPLET CODE="maClasse.class"> </APPLET>.
au début du fichier maClasse.java, ce qui permet de lancer depuis un
terminal la commande :
appletviewer maClasse.java
pour exécuter l’applet.
Le programme Appletviewer effectue alors les opérations suivante:
il extrait le nom de l’applet indiqué par la balise et oublie le reste du fichier,
il crée une fenêtre et y ajoute une instance de l’applet ainsi qu’un menu
déroulant permettant d’appeler les méthodes init, start, stop et
destroy
Téléchargement