1.5 Les méthodes des applets

JAVA ET LES APPLETS
JAVA – LES APPLETS
Sommaire
1.1 Présentation _______________________________________________3
1.1.1
Les applets ____________________________________________3
1.1.2
Structure du code d'une applet V2 __________________________5
1.1.3
Structure minimale d'une page HTML incorporant une Applet ____5
1.2 Première Applet : Afficher un texte _____________________________6
1.3 Les attributs de la balise Applet ________________________________8
1.4 La balise Param lors de l'appel d'une applet _______________________9
1.5 Les méthodes des applets ____________________________________11
1.5.1
Le constructeur _______________________________________11
1.5.2
La méthode init() ______________________________________11
1.5.3
La méthode start() _____________________________________11
1.5.4
La méthode paint() ____________________________________11
1.5.5
La méthode repaint() ___________________________________11
1.5.6
La méthode stop() _____________________________________11
1.5.7
La méthode destroy() ___________________________________11
1.5.8
La méthode getParameter() ______________________________12
1.5.9
La méthode getAppletInfo() _____________________________12
1.5.10 La méthode showStatus() _______________________________12
1.5.11 La méthode getParameterInfo() ___________________________13
1.6 Le cycle de vie d'une applet __________________________________14
1.7 Utilisation de quelques méthodes de base _______________________16
1.8 Une applet pour contrôler une saisie ___________________________19
1.9 Lire un fichier sur le WEB ___________________________________22
1.10 Une applet pour accéder à une table MySQL ___________________25
1.11 Communication Applet-HTML : Le convertisseur _______________27
1.12 Le graphisme dans les applets _______________________________31
1.13 Le graphisme animé dans une applet _________________________33
1.14 Des images dans une applet ________________________________35
1.15 Une animation avec des JPEG dans une applet __________________38
1.16 Une applet dans une application _____________________________43
1.17 Utiliser un fichier JAR pour une applet ________________________47
1.18 Annexe : Structure du code d'une applet V1 ____________________48
© Pascal Buguet
Imprimé le 27 mai 2017
Page 2
JAVA – LES APPLETS
1.1
PRESENTATION
1.1.1
Les applets
Une applet Java est un petit programme qui sera exécuté par et dans un navigateur ou l'AppletViewer
ou même une application.
Mais la plupart du temps il s'agit d'une classe qui est appelée dans une page HTML bien souvent pour
faire de l'animation.
Les applets de la version 2 de Java sont issues de la classe JApplet du package javax.swing.
Les applets de la version 1 sont issues de la classe Applet du package java.applet.
Les deux classes ne sont pas compatibles dans la mesure où, comme nous l'avons déjà vu lors de
l'étude de l'interface Swing, le container ContentPane est le parent de tous les enfants de l'applet.
Les applets, principalement utilisées dans des pages HTML, sont chargées au travers du réseau. Ce
sont des applications mobiles ou portables exécutées dans le navigateur.
Les navigateurs n'acceptent pas nativement les applets.
Le plugin Java2 de Sun est nécessaire et doit être installé sur le poste client. Il s'agit du JRE. Il installe
une console.
Il est par ailleurs possible de développer avec le JDK2 et de compiler en version 1.x avec l'option target. La syntaxe est la
suivante : Javac –target 1.1 applet.java.
Schéma de chargement d'une applet
Client
Serveur
Requête HTML
Réponse HTML
Requête Applet
Réponse Applet
Note :
Si plusieurs éléments sont présents et composent l'applet (Classes, images, …) il faut créer un jar. Cf plus loin.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 3
JAVA – LES APPLETS
Les applets résident sur le disque dur du serveur et s'exécute chez le client.
Le cycle de vie d'une applet est différent du cycle de vie d'une application.
Une applet est d'abord initialisée (init()) puis démarrée (start()) à chaque fois que l'utilisateur change
de page puis revient sur la page contenant l'applet.
Les applets ont moins de droits que les applications dans la mesure où elles ne peuvent ni lire, ni
écrire de fichiers, ni lancer de programmes, ni charger de dll du poste client.
Elles ne peuvent communiquer qu'avec le serveur d'origine ou une autre applet.
Les applets permettent de faire du C/S plus évolué que le HTML (en créant un client riche) dans la
mesure où vous pouvez faire des contrôles au moment de la saisie de l'utilisateur (comme avec
JavaScript par ailleurs ou ActionScript de Flash).
L'arborescence du site …
Classes
Html
Images
Ressources
Pour
Pour
Pour
Pour
les
les
les
les
.class ou .jar (soit du package des applets, soit des pilotes BD utilisés)
fichiers HTML
images
autres ressources (fichiers TX, CSV, XML, …)
Ou avec NetBeans et Tomcat :
Notes :
Création d'une applet avec NetBeans :
Projet de type Java/Application Java : projetApplet.
Package : PackageApplets.
Deux types d'applet : Japplet et Japllet Form.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 4
JAVA – LES APPLETS
1.1.2 Structure du code d'une applet V2
import javax.swing.*;
public class NomApplet extends JApplet
{
public void init()
{
// --- Le code
}
}
Le code minimal est le code qui précède.
Une applet nécessite l'importation d'un package :
Javax.swing pour la classe JApplet et l'interface graphique.
La classe est une extension de la classe JApplet.
Elle comporte au moins la fonction init() qui fait office de constructeur.
Les applets ne possèdent pas de méthode main().
Les applets doivent être déclarées comme public.
1.1.3 Structure minimale d'une page HTML incorporant une Applet
L'applet a été développée dans un package par défaut (déconseillé).
<html>
<applet codebase="chemin des .class" code="NomApplet.class" width="pixels"
height="pixels">
</applet>
</html>
Le code minimal est le code qui précède.
Il s'agit de la balise <applet> avec trois valeurs obligatoires, le code qui comprend le nom de la classe
de votre applet, la largeur et la hauteur.
Nous verrons par la suite que nous pourrons ajouter d'autres attributs à cette balise.
Si l'applet a été développée dans un package … et il a fallu créer un jar.
<html>
<applet codebase="chemin du jar ou du fichier .class"
code="nomDuPackage.NomApplet.class" archive="fichier.jar" width="pixels"
height="pixels">
</applet>
</html>
cf le paragraphe sur la création d'un jar. Avec NetBeans appuyez sur F11 ou CTRL/F11.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 5
JAVA – LES APPLETS
1.2 PREMIERE APPLET : AFFICHER UN TEXTE

Objectif
Afficher un texte dans un cadre de couleur dans le navigateur.

Le résultat attendu
L'appel du code : http://localhost/p_applets/html/Applet0.html

Le code de l'applet
package PackageApplets;
import
import
import
import
java.awt.Color;
java.awt.Container;
javax.swing.JApplet;
javax.swing.JLabel;
public class Applet0 extends JApplet
{
@Override
public void init()
{
Container c = getContentPane();
c.setBackground(Color.yellow);
c.add(new JLabel("Première JApplet"));
}
}

Le code de la page HTML
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>applet0.html</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<p>Début de la page avant première applet</p>
<applet codebase="../classes/" archive="projetApplet.jar"
code="PackageApplets.Applet0.class" alt="Votre navigateur ne supporte pas les
applets" width="200" height="50">
</applet>
<p>Fin de la page après première applet</p>
</body>
</html>
© Pascal Buguet
Imprimé le 27 mai 2017
Page 6
JAVA – LES APPLETS

Commentaires
Pour cette première applet (JApplet) seules quelques classes ont été importées.
En premier lieu la classe JApplet du package SWING (javax.swing.JApplet) pour créer la classe (qui
devient l'applet) elle-même.
Les autres classes sont importées en fonction des éléments qui seront mis dans l'applet.
De façon générale, en ce qui concerne l'interface graphique, les bibliothèques Swing et AWT seront
incorporées.
La méthode init() fait office de constructeur.
La balise applet est obsolète. http://www.w3.org/TR/REC-html40/struct/objects.html
Donc il faudra utiliser la balise <object>.
<object id="applet1" width="200" height="50" codetype="application/java"
codebase="../classes/" archive="projetApplet.jar"
classid="java:PackageApplets.Applet0.class">
Votre navigateur ne peut pas afficher l'applet
</object>
© Pascal Buguet
Imprimé le 27 mai 2017
Page 7
JAVA – LES APPLETS
1.3 LES ATTRIBUTS DE LA BALISE APPLET
Les attributs en gras sont obligatoires.
code = nomDeClasse.class
width = largeur en pixels
height = hauteur en pixels
alt = texte visible quand l'applet ne l'est pas
codebase = URL
Le répertoire de stockage du code de l'applet. Par exemple "../classes/" si les classes sont dans un
dossier de même niveau que le dossier HTML.
archive = Liste des fichiers d'archive (Le ou les jar(s))
name = nom
Permet de préciser un nom pour pouvoir manipuler l'instance de l'applet dans la page (avec du
JavaScript par exemple).
align = type d'alignement
Indique l'alignement de l'applet par rapport aux autres éléments de la page HTML.
Les attributs sont les suivants :
Valeur
LEFT
RIGHT
TOP
MIDDLE
BOTTOM
BASELINE
ABSBOTTOM
ABSMIDDLE
TEXTTOP
Description
Applet
Applet
Applet
Applet
Applet
idem
Applet
Applet
Applet
à gauche
à droite
en haut
au milieu
en bas
en bas
alignée sur le milieu de l'élément le plus grand de la ligne
alignée sur le texte du haut de la ligne
La balise <br /> permet de mettre fin à la valeur d'alignement pour le reste de la page.
C'est l'attribut CLEAR de cette balise qui le permet.
Les valeurs de cet attribut sont LEFT, RIGHT et ALL.
Exemple : <br clear=all /> rétablit l'alignement standard.
vspace = pixels
Le nombre de pixels qui séparent en haut et en bas l'applet du texte de la page.
hspace = pixels
Le nombre de pixels qui séparent à gauche et à droite l'applet du texte de la page.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 8
JAVA – LES APPLETS
1.4
LA BALISE PARAM LORS DE L'APPEL D'UNE APPLET
La balise Param permet de passer des paramètres (en entrée) à une applet.
Chaque paramètre correspond à l'utilisation d'une méthode getParameter("nomDeParamètre") dans
la méthode init() de l'applet.
Pour communiquer avec des attributs de l'applet nous utiliserons des méthodes publiques (cf plus loin
dans ce chapitre).

Syntaxe de Param
<param name="appletAttribute" value="value" />

Syntaxe de getParameter()
getParameter("nomDuParamètre");
© Pascal Buguet
Imprimé le 27 mai 2017
Page 9
JAVA – LES APPLETS

Exemple
Bleu
Jaune
Code de l'applet
package PackageApplets;
import java.awt.*;
import javax.swing.*;
public class AppletParametree extends JApplet
{
public void init()
{
String lsCouleur = getParameter("couleur");
Container c = getContentPane();
if(lsCouleur.equals("bleu")) { c.setBackground(Color.blue); }
if(lsCouleur.equals("jaune")) { c.setBackground(Color.yellow); }
c.add(new JLabel("Première Applet", JLabel.CENTER),
BorderLayout.CENTER);
}
}
Code de la page HTML
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>appletParametree.html</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<applet codebase="../classes/" archive="projetApplet.jar"
code="PackageApplets.AppletParametree.class" width="300" height="50">
<param name="couleur" value="jaune" />
</applet>
</body>
</html>
Commentaires
Pour simplifier nous importons l'intégralité des bibliothèques Swing et AWT.
La valeur du paramètre est récupérée dans l'applet grâce à getParameter().
String lsCouleur = getParameter("couleur");
L'utilisation du paramètre dans la page HTML :
<param name= "couleur" value="bleu" />
ou bien
<param name= "couleur" value="jaune" />
© Pascal Buguet
Imprimé le 27 mai 2017
Page 10
JAVA – LES APPLETS
1.5 LES METHODES DES APPLETS
1.5.1
Le constructeur
Vous écrivez un constructeur si nécessaire. La méthode init() de toutes façons fait office de
constructeur.
1.5.2 La méthode init()
Elle est appelée par le navigateur juste après le constructeur. Généralement vous récupérez les
valeurs des paramètres dans cette méthode.
1.5.3 La méthode start()
Cette méthode est appelée par le navigateur. Elle démarre l'applet.
1.5.4 La méthode paint()
Elle est appelée par le navigateur après la méthode init() et la méthode start() et à chaque fois que
cela est nécessaire. Cette méthode "dessine" l'interface de l'applet.
1.5.5 La méthode repaint()
Vous appelez cette méthode pour activer par code la méthode paint().
1.5.6 La méthode stop()
Cette méthode est appelée par le navigateur. Elle arrête l'applet, par exemple lorsque l'on change de
page.
1.5.7 La méthode destroy()
Cette méthode, appelée par le navigateur, détruit l'applet et libère l'espace mémoire du navigateur
consacré à l'applet.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 11
JAVA – LES APPLETS
1.5.8 La méthode getParameter()
Permet de récupérer les valeurs des paramètres transmis de la page HTML vers l'applet lors du
chargement de l'applet.
Syntaxe
String = getParameter("paramètre");
1.5.9 La méthode getAppletInfo()
Permet de préciser et de récupérer des informations à propos de l'applet.
Vous surchargez la méthode parent. Cette méthode sera appelée via un script JavaScript.
// ---- La méthode getAppletInfo()
public String getAppletInfo()
{
return "Applet cycle by Pascal Buguet 30.09.2002";
}
<script type="text/javascript">
function afficheGetAppletInfo()
{
alert(ca.getAppletInfo());
}
</script>
<body>
<input type="button" value="getAppletInfo" name="cbAppletInfo"
onclick="afficheGetAppletInfo()" />
<applet codebase="../classes/" code="CycleApplet.class" width="300"
height="550" name="ca">
</applet>
</body>
1.5.10 La méthode showStatus()
Elle permet d'afficher un message dans la barre d'état du navigateur.
Vous pouvez l'insérer dans chaque méthode de l'applet (init(), paint(), …).
Syntaxe
showStatus("Message");
© Pascal Buguet
Imprimé le 27 mai 2017
Page 12
JAVA – LES APPLETS
1.5.11 La méthode getParameterInfo()
Permet de préciser et de récupérer les noms, les types et les descriptions des paramètres. Il faut
surcharger la méthode parent. Cette méthode sera appelée dans l'applet ou via un script JavaScript.
Syntaxe
String[][] = getParameterInfo();
Exemple
// ---- La méthode getParameterInfo()
public String[][] getParameterInfo()
{
String tabParam[][] =
{
{"couleur", "chaine", "couleur du fond de l'applet"},
{"posX", "chaine/int","Position x de l'affichage"},
{"posY", "chaine/int","Position y de l'affichage"}
};
return tabParam;
}
© Pascal Buguet
Imprimé le 27 mai 2017
Page 13
JAVA – LES APPLETS
1.6 LE CYCLE DE VIE D'UNE APPLET

Objectif
Illustrer les méthodes du cycle de vie d'une applet.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 14
JAVA – LES APPLETS

Script de l'applet
package PackageApplets;
// --- Cycle de vie d'une applet
import java.awt.*;
// Pour la classe Graphics, Layout, Color
import javax.swing.*;
// Pour la classe JApplet
@SuppressWarnings("serial")
public class CycleApplet extends JApplet
{
// --- Variables d'instance de l'applet
String lsEtat = "";
JTextArea jta = new JTextArea("Cycle",10,30);
JPanel panneau = new JPanel(new GridLayout(1,1));
Container c;
// --- Les méthodes des Applets
public CycleApplet()
{
lsEtat += "Construct\r\n";
}
@Override
public void init()
{
lsEtat += "Init\r\n";
panneau.setBackground(Color.YELLOW);
panneau.add(jta);
c = getContentPane();
c.add(panneau);
}
@Override
public void start()
{
lsEtat += "Start\r\n";
showStatus(lsEtat);
}
@Override
public void paint(Graphics g)
{
lsEtat += "Paint\r\n";
showStatus(lsEtat);
jta.setText(lsEtat);
}
@Override
public void stop()
{
lsEtat += "Stop\r\n";
showStatus(lsEtat);
}
@Override
public void destroy()
{
lsEtat += "Destroy";
showStatus(lsEtat);
}
}
© Pascal Buguet
Imprimé le 27 mai 2017
Page 15
JAVA – LES APPLETS
1.7

UTILISATION DE QUELQUES METHODES DE BASE
Objectif
Un script avec l'illustration des méthodes suivantes :



getParameter("param"),
getParameterInfo(),
getAppletInfo().
© Pascal Buguet
Imprimé le 27 mai 2017
Page 16
JAVA – LES APPLETS

Code java
package PackageApplets;
import
import
import
import
import
java.awt.Container;
java.awt.GridLayout;
java.awt.Color;
java.awt.event.*;
javax.swing.*;
@SuppressWarnings("serial")
public class AppletMethodesExternes extends JApplet
{
Container c;
JPanel
panneau;
JLabel
lblCp;
JLabel
lblVille;
JButton
cbInfos;
JTextArea taMessage;
String isCp, isVille;
// --------------public void init()
{
isCp
= getParameter("cp");
isVille = getParameter("ville");
lblCp
= new JLabel(isCp);
lblVille = new JLabel(isVille);
cbInfos
= new JButton("Infos");
taMessage = new JTextArea("");
taMessage.setBackground(Color.LIGHT_GRAY);
taMessage.setForeground(Color.RED);
panneau = new JPanel(new GridLayout(1,1));
panneau.setBackground(Color.YELLOW);
cbInfos.addActionListener( new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
afficherParameterInfo();
}
});
c = getContentPane();
c.add(panneau);
panneau.add(lblCp);
panneau.add(lblVille);
panneau.add(cbInfos);
panneau.add(taMessage);
showStatus("Init terminée");
}
// -------------------------public String getAppletInfo()
{
return "Applet cycle by Pascal Buguet 30.09.2002";
}
// --------------------------------public String[][] getParameterInfo()
{
String tabParam[][] =
{
{"cp", "chaine", "Le CP passé en paramètre"},
{"ville", "chaine","La ville passée en paramètre"}
};
return tabParam;
}
// ---------------------------------
© Pascal Buguet
Imprimé le 27 mai 2017
Page 17
JAVA – LES APPLETS
private void afficherParameterInfo()
{
String[][] t = null;
t = getParameterInfo();
taMessage.setText(t[0][2] + "\n\r" + t[1][2]);
}
}

Code html
<html>
<script type="text/javascript">
function afficherInfosInternesApplet()
{
alert(applet.getAppletInfo()); // --- Méthode interne de
l'applet
}
function afficherParamsApplet()
{
var params = new Array();
params = applet.getParameterInfo();
alert(params[0][2]);
alert(params[1][2]);
}
</script>
<applet codebase="../classes/" code="AppletMethodesExternes.class"
width="800" height="30" name="applet" >
<param name="cp" value="75000" />
<param name="ville" value="Paris" />
</applet>
<br />
<input type="button" value="Afficher Infos Internes de l'applet"
onClick="afficherInfosInternesApplet()" />
<input type="button" value="Afficher Params Applet"
onClick="afficherParamsApplet()" />
</html>
© Pascal Buguet
Imprimé le 27 mai 2017
Page 18
JAVA – LES APPLETS
1.8 UNE APPLET POUR CONTROLER UNE SAISIE

Objectif
Ecrire une applet qui permette des contrôles de saisie (Contrôle de surface).
L'exemple, volontairement simple, est le contrôle d'une saisie numérique (un réel). La saisie ne doit
contenir que des chiffres.
L'utilisateur saisit puis valide sur le bouton Valider. Dans le label de droite un message est affiché.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 19
JAVA – LES APPLETS

Code java
package PackageApplets;
// --import
import
import
Applet pour contrôle de saisie
java.awt.*;
java.awt.event.*;
javax.swing.*;
public class ControleSaisie extends JApplet
{
// --- Les composants graphiques
JPanel panneau = new JPanel(new GridLayout(1,4));
JLabel lblCoursDollar
= new JLabel("Cours du dollar aujourd'hui");
JTextField tfCoursDollar = new JTextField("",10);
JButton cbValider
= new JButton("Valider");
JLabel lblMessage
= new JLabel("Message");
// --- Le constructeur
public ControleSaisie()
{
panneau.setBackground(Color.LIGHT_GRAY);
ActionListener al = new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
String lsInter;
char lcCar;
lsInter = tfCoursDollar.getText();
for(int i=0; i<lsInter.length(); i++)
{
lcCar = lsInter.charAt(i);
if(Character.isDigit(lcCar) || lcCar == ',')
lblMessage.setText("Ok numérique");
else
{lblMessage.setText("Pas numérique");break;}
}
}
};
cbValider.addActionListener(al);
panneau.add(lblCoursDollar);
panneau.add(tfCoursDollar);
panneau.add(cbValider);
panneau.add(lblMessage);
getContentPane().add(panneau);
}
}

Commentaires
Sur l'événement click du bouton les caractères du texte sont extraits un par un dans une boucle et
stocké dans un char. On teste le type du caractère avec la méthode isDigit(). On sort de la boucle dès
que l'on rencontre un caractère non numérique.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 20
JAVA – LES APPLETS

Code html
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>controleSaisie.html</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<applet codebase="../classes/" archive="projetApplet.jar"
code="PackageApplets.ControleSaisie.class" width="800" height="50"></applet>
</body>
</html>
© Pascal Buguet
Imprimé le 27 mai 2017
Page 21
JAVA – LES APPLETS
1.9

LIRE UN FICHIER SUR LE WEB
Objectif
Afficher le contenu d'un fichier text dans un [JTextArea].

Démarche
Construire l'interface avec un JButton et un JTextArea.
Récupérer l'URL correspond au fichier avec la méthode getCodeBase().
Pointer sur le fichier avec un objet InputStreamReader et l'ouvrir avec la méthode openStream().
Utiliser un filtre de lecture avec un objet BufferedReader.
Lire les lignes avec la méthode ReadLine().

Citations.txt
Le fichier citations.txt se trouve dans dossier nommé /ressources (Au même niveau que classes).
Mieux vaut tard que jamais
Rien ne sert de courir il faut partir à point
Chi va piano va sano
© Pascal Buguet
Imprimé le 27 mai 2017
Page 22
JAVA – LES APPLETS

Code HTML
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>lectureFichier1.html</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<applet codebase="../classes/" archive="projetApplet.jar"
code="PackageApplets.LectureFichier1.class" alt="Votre navigateur ne supporte pas
les applets" width="400" height="200">
</applet>
</body>
</html>

Code JAVA
package PackageApplets;
// --import
import
import
import
import
Applet pour la lecture d'un fichier texte
java.awt.*;
java.awt.event.*;
javax.swing.*;
java.net.*;
// Pour les URL
java.io.*;
// Pour la gestion de fichiers
@SuppressWarnings("serial")
public class LectureFichier1 extends JApplet
{
// --- Les composants graphiques
JPanel panneau
= new JPanel();
JTextArea taEnr
= new JTextArea("",10,30);
JButton cbValider = new JButton("Valider");
public LectureFichier1()
{
panneau.setBackground(Color.yellow);
ActionListener al = new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
String lsLigne = "";
try
{
URL url = new
URL(getCodeBase(),"../ressources/citations.txt");
taEnr.append(url.toString() + "\r\n\r\n");
InputStreamReader fichier = new
InputStreamReader(url.openStream());
BufferedReader tampon = new
BufferedReader(fichier);
while((lsLigne = tampon.readLine()) != null)
{
taEnr.append(lsLigne + "\r\n");
}
fichier.close();
}
catch(MalformedURLException err)
{
taEnr.append("Erreur io : " + err.getMessage() +
"\n");
}
catch(Exception err)
{
© Pascal Buguet
Imprimé le 27 mai 2017
Page 23
JAVA – LES APPLETS
taEnr.append("Erreur générale : " + err.toString()
+ "\n");
}
}
};
cbValider.addActionListener(al);
panneau.add(cbValider, BorderLayout.NORTH);
panneau.add(taEnr, BorderLayout.SOUTH);
getContentPane().add(panneau);
}
}
© Pascal Buguet
Imprimé le 27 mai 2017
Page 24
JAVA – LES APPLETS
1.10

UNE APPLET POUR ACCEDER A UNE TABLE MYSQL
Objectif
Lire les données d'une table MySQL dans un [Vector] et l'afficher via une [JList] dotée d'un
[JScrollPane] (Ascenseur).

Démarche
Créer l'applet.
Ajouter au projet le jar du pilote MySQL.
Ensuite le jar sera dans le dossier des classes sur le serveur http.

Ecrans
© Pascal Buguet
Imprimé le 27 mai 2017
Page 25
JAVA – LES APPLETS

BdMySQL.html
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>bdMySQL.html</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<applet codebase="../classes/" archive="mysql-connector-java-5.1.5bin.jar,projetApplet.jar" code="PackageApplets.BdMySQL.class" width="200"
height="200">
</applet>
</body>
</html>
L'archive mysql-connector-java-5….jar est stocké dans le dossier classes/lib/.

BDMySQL.java
package PackageApplets;
import
import
import
import
java.util.Vector;
java.sql.*;
java.awt.*;
javax.swing.*;
public class BdMySQL extends JApplet
{
Vector<String> vecteur = new Vector<String>();
public static final String DRIVER = "org.gjt.mm.mysql.Driver";
public static final String DBURL = "jdbc:mysql://localhost/cours";
public void init()
{
JList lbxResultats
= new JList(vecteur);
JScrollPane ascenseur = new JScrollPane(lbxResultats);
JPanel panneau
= new JPanel(new GridLayout(2,2));
panneau.add(ascenseur);
try
{
Class.forName(DRIVER);
Connection cn = DriverManager.getConnection(DBURL,"root","");
Statement lstSQL = cn.createStatement();
ResultSet lrs = lstSQL.executeQuery("SELECT * FROM villes");
while(lrs.next())
{
vecteur.addElement(lrs.getString(1) + "-" +
lrs.getString(2));
}
lrs.close();
cn.close();
}
catch(SQLException erreur)
{
vecteur.addElement(erreur.getMessage());
}
catch(Exception erreur)
{
vecteur.addElement(erreur.getMessage());
}
getContentPane().add(panneau);
}
}
© Pascal Buguet
Imprimé le 27 mai 2017
Page 26
JAVA – LES APPLETS
1.11 COMMUNICATION APPLET-HTML : LE CONVERTISSEUR

Objectif
Récupérer dans la page HTML les valeurs gérées dans l'applet.
Ecrire une applet qui permet la conversion Euros/Dollars.
Cette page est composée de deux parties : en haut l'applet et en bas un "formulaire" HTML.
Cette applet contient trois JTextFields pour saisir les valeurs du cours, du montant en Euros et du
montant en Dollars, et deux boutons de commande pour les conversions et des JLabels pour
récupérer les résultats des conversions.
L'interface HTML comporte en plus deux boutons de commande et deux <label>. Il s'agit de
récupérer dans la page HTML les valeurs manipulées dans l'applet.

L'applet

L'applet dans la page HTML
L'applet
La "Form"

Fonctionnement
L'utilisateur saisit dans l'applet le cours du dollar, le montant d'Euros ou de Dollars et clique sur un
des boutons de conversions.
S'il veut récupérer les valeurs dans la page HTML il clique sur le ou les boutons correspondants.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 27
JAVA – LES APPLETS

Script de l'applet
// --import
import
import
Applet et Convertisseur Euros-Dollars
java.awt.*;
java.awt.event.*;
javax.swing.*;
public class EurosDollars extends JApplet
{
// --- Les composants graphiques
JPanel panneau = new JPanel(new GridLayout(3,4));
// --- Ligne 1
JLabel lblCoursDollar
JTextField tfCoursDollar
JLabel lblVide1
JLabel lblVide2
=
=
=
=
// --- Ligne 2
JLabel lblEuro
JTextField tfEuros
JButton cbDollars
JLabel lblEuros
JLabel("Euros?");
JTextField("10",10);
JButton("$");
JLabel("");
=
=
=
=
// --- Ligne 3
JLabel lblDollar
JTextField tfDollars
JButton cbEuros
JLabel lblDollars
new
new
new
new
=
=
=
=
new
new
new
new
new
new
new
new
JLabel("Cours du dollar oggi");
JTextField("1.35",10);
JLabel("");
JLabel("");
JLabel("Dollars?");
JTextField("10",10);
JButton("€");
JLabel("");
// --- Le constructeur
public EurosDollars()
{
panneau.setBackground(Color.cyan);
ActionListener al = new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
float lfDollars, lfEuros, lfInter, lfCoursDollar;
lfCoursDollar = Float.parseFloat(tfCoursDollar.getText());
// --- On clique sur le bouton dollars pour obtenir le montant de
dollars correspondant
if(e.getSource() == cbDollars)
{
lfEuros = Float.parseFloat(tfEuros.getText());
lfInter = lfEuros * lfCoursDollar;
lblDollars.setText(Float.toString(lfInter));
}
// --- On clique sur le bouton euros pour obtenir le montant
d'euros correspondant
if(e.getSource() == cbEuros)
{
lfDollars = Float.parseFloat(tfDollars.getText());
lfInter
= lfDollars / lfCoursDollar;
lblEuros.setText(Float.toString(lfInter));
}
}
};
cbDollars.addActionListener(al);
cbEuros.addActionListener(al);
panneau.add(lblCoursDollar);
panneau.add(tfCoursDollar);
panneau.add(lblVide1);
© Pascal Buguet
Imprimé le 27 mai 2017
Page 28
JAVA – LES APPLETS
panneau.add(lblVide2);
panneau.add(lblEuro);
panneau.add(tfEuros);
panneau.add(cbDollars);
panneau.add(lblDollars);
panneau.add(lblDollar);
panneau.add(tfDollars);
panneau.add(cbEuros);
panneau.add(lblEuros);
getContentPane().add(panneau);
}
// --- Les méthodes ad hoc
public String getDollarsEuros()
{
return tfDollars.getText() + " Dollars valent " + lblEuros.getText() + "
Euros";
}
// --------------------public String getEurosDollars()
{
return tfEuros.getText() + " Euros valent " + lblDollars.getText() + "
Dollars";
}
}

Commentaires
Le schéma de la classe
EurosDollars
(-)panneau
(-)lblCoursDollar
(-) …
(+)getDollarsEuros()
(+)getEurosDollars()
Le corps de la classe
Les composants graphiques sont instanciés dans le constructeur.
Les conversions sont traitées dans l'événement clic des boutons de commande.
Les méthodes particulières
Les méthodes getEurosDollars() et getDollarsEuros() sont des méthodes publiques qui vont permettre
à un utilisateur de la classe, ici la page HTML, de récupérer les valeurs des JTextFields et des JLabels.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 29
JAVA – LES APPLETS

Code de la page HTML
<html>
<head><title>EurosDollars</title></head>
<body>
<applet codebase="../classes/" code="EurosDollars.class" width="500"
height="75" name="convertisseur" id="convertisseur">
</applet>
<script type="text/javascript">
function affecter(etiquette)
{
if(etiquette=="euros") {
document.getElementById("lblEurosDollars").innerHTML =
document.getElementById("convertisseur").getEurosDollars(); }
if(etiquette=="dollars") {
document.getElementById("lblDollarsEuros").innerHTML =
document.getElementById("convertisseur").getDollarsEuros(); }
}
</script>
<br />
<input
<label
<input
<label
</body>
</html>

type="button" value="Euros" onclick="affecter('euros')" />
id="lblEurosDollars"></label><br />
type="button" value="Dollars" onclick="affecter('dollars')" />
id="lblDollarsEuros"></label>
Commentaires
Ce code contient trois parties : l'applet, un script JavaScript et des éléments HTML(button, label).
La fonction affecter(destinataire) JavaScript permet de récupérer les valeurs des JTextFields et des
JLabels via des méthodes de classe et de les affecter aux <labels>.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 30
JAVA – LES APPLETS
1.12 LE GRAPHISME DANS LES APPLETS

Objectif
Introduire au graphisme en java et plus particulièrement dans les applets.

Méthodes utilisées
Méthodes
drawString(chaîne, x, y)
drawLine(x1, y1, x2, y2)
drawRect(x1,y1,largeur, hauteur)
fillRect(x1,y1,largeur, hauteur)
drawRoundRect(x1, y1, largeur, hauteur, largeur_coin,
hauteur_coin)
fillRoundRect(x1, y1, largeur, hauteur, largeur_coin,
hauteur_coin)
drawOval(x,y,largeur,hauteur)
fillOval(x,y,largeur,hauteur)
drawArc(x, y , largeur, hauteur, angle de départ, degrés)
fillArc(x, y , largeur, hauteur, angle de départ, degrés)
drawPolygon(Polygone)
clearRect(x, y , largeur, hauteur)
copyArea( x, y, largeur, hauteur ,déplacement x ,
déplacement y)
© Pascal Buguet
Dessine
Dessine
Dessine
Dessine
Dessine
Description
du texte
une ligne
un rectangle
un rectangle plein
un rectangle aux coins arrondis
Dessine un rectangle plein aux coins
arrondis
Dessine un oval
Dessine un oval plein
Dessine un arc
Dessine un arc plein
Dessin un polygone
Efface un rectangle
Copie un rectangle
Imprimé le 27 mai 2017
Page 31
JAVA – LES APPLETS

Code Java
import java.awt.*;
import javax.swing.JApplet;
// Pour la classe Graphics, Polygon, …
// Pour la classe JApplet
public class Dessins1 extends JApplet
{
public void init() {}
public void paint(Graphics g)
{
//--- g.drawString("string",x,y);
g.drawString("drawLine",10,10);
// --- g.drawLine(x1, y1, x2, y2);
g.drawLine(150,20,200,20);
// --- g.drawRect(x1,y1,larg, ht);
g.drawString("drawRect",10,50);
g.drawRect(150,50,100,20);
// --- g.fillRect(x1,y1,larg, ht);
g.drawString("fillRect",300,50);
g.fillRect(450,50,100,20);
// --- g.drawRoundRect(x1, y1, larg, ht, largeurCoin, hauteurCoin);
g.drawString("drawRoundRect",10,100);
g.drawRoundRect(150,100,85,30,8,8);
// --- g.fillRoundRect(x1, y1, larg, ht, largeurCoin, hauteurCoin);
g.drawString("fillRoundRect",300,100);
g.fillRoundRect(450,100,123,35,15,15);
// --- g.drawOval(x,y,larg,ht);
g.drawString("drawOval",10,150);
g.drawOval(150,150,50,30);
g.drawString("fillOval",300,150);
g.fillOval(450,150,70,30);
// --- g.drawArc(x, y , larg, ht, angle de départ, degrés)
g.drawString("drawArc",10,200);
g.drawArc(150, 200 , 50, 40, 90, 96);
g.drawString("fillArc",300,200);
g.fillArc(450,200,90,10,0,-120);
// --- Coordonnées du polygone tête de marteau
g.drawString("Polygon Marteau",10,300);
int xMarteau[] = {150,200,250,150};
int yMarteau[] = {300,300,320,320};
int liPointsMarteau = xMarteau.length;
Polygon lPolyMarteau = new Polygon(xMarteau,yMarteau,liPointsMarteau);
// --- drawPolygon(Polygone)
g.drawPolygon(lPolyMarteau);
// --- Coordonnées du polygone marche escalier
g.drawString("Polygon Escalier",300,300);
int xEscalier[] = {450,500,500,600,600,450};
int yEscalier[] = {300,300,320,320,340,340};
int liPointsEscalier = xEscalier.length;
Polygon lPolyEscalier = new
Polygon(xEscalier,yEscalier,liPointsEscalier);
g.drawPolygon(lPolyEscalier);
}
}
© Pascal Buguet
Imprimé le 27 mai 2017
Page 32
JAVA – LES APPLETS
1.13 LE GRAPHISME ANIME DANS UNE APPLET

Objectif
Introduire à l'animation dans une applet. Par ajout d'un thread.

Démarche
Utilisation d'un thread pour dessiner.
Le thread est créé au démarrage de l'applet, dans la méthode start().
La méthode run() contient une boucle infinie qui appelle la méthode repaint() qui redessine la balle et
marque une pause d'une seconde.
Utilisation des méthodes fillOval() pour dessiner la balle clearRect() et pour effacer la balle.
Le thread est détruit dans la méthode stop() de l'applet.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 33
JAVA – LES APPLETS

Code java
// ---- Dessiner n sphères
import java.awt.*;
// --- Pour la classe Graphics
import javax.swing.*;
// --- Pour la classe JApplet
public class DessinsDyn2 extends JApplet implements Runnable
{
int liX = 10, liY = 10;
Thread troncheDeProcessus;
// ----------------public void init(){}
// ----------------public void start()
{
liX = 10; liY = 10;
troncheDeProcessus = new Thread(this);
troncheDeProcessus.start();
}
// -------------public void run()
{
boolean lbRouler = true;
while(lbRouler)
{
repaint();
pause(1000);
}
}
// -------------------------public void paint(Graphics g)
{
// --- g.drawOval(x,y,larg,ht);
g.clearRect(liX,liY,30,30);
liX += 10; liY += 10;
g.fillOval(liX,liY,30,30);
}
// --------------------------public void pause(int aiDuree)
{
try { troncheDeProcessus.sleep(aiDuree); }
catch(InterruptedException e) { }
}
// --------------public void stop()
{
troncheDeProcessus = null;
}
}
© Pascal Buguet
Imprimé le 27 mai 2017
Page 34
JAVA – LES APPLETS
1.14 DES IMAGES DANS UNE APPLET

Objectif
Gérer les Images et les ImageIcons dans les applets.
Les fichiers *.jpg sont stockés dans un dossier nommé /images qui est un sous-dossier du dossier des
classes.
L'appel du code : http://localhost/p_applets/AppletImage.html

Classes utilisées
Classe
Image (package AWT)
ImageIcon (package SWING)
URL

Description
Une image (jpg, gif)
Une icône créée à partir d'une image (jpg, gif)
Une URL
Méthodes utilisées
Méthodes
Constructeur URL(Contexte URL, spécification)
Constructeur ImageIcon(URL[,"Description"])
Constructeur ImageIcon(nom_du_fichier[,"Description"])
getImage(chemin, nom_du_fichier)
getDocumentBase()
getCodeBase()
objetGraphics.drawImage(image, x, y , container)
ImageIcon.paintIcon( container, objet Graphics, x, y)
© Pascal Buguet
Description
Crée une nouvelle URL
Dans une applet seulement une URL.
Dans une application les deux
possibilités.
Renvoie une image
Renvoie l'URL du dossier du document
HTML qui appelle l'applet
Renvoie l'URL de l'applet
Dessine une image
Dessine une icône
Imprimé le 27 mai 2017
Page 35
JAVA – LES APPLETS

Code java
// Applet et images
import java.awt.*
;
import javax.swing.*;
import java.net.*;
public class AppletImage
{
private Image
private ImageIcon
private URL
// Pour les images
// Pour les ImageIcon
// Pour les URL
extends JApplet
imgPhoto1;
iconePhoto2;
urlPhoto2;
public void init()
{
String lsCheminPhoto1 = "images/l.jpg";
String lsCheminPhoto2 = "images/2.jpg";
// La classe Image étant abstraite il faut passer par une méthode de
la classe JApplet : getImage par exemple
// getImage (emplacement de mémorisation sur le serveur, nom de
l'image)
imgPhoto1 = this.getImage(getDocumentBase(), lsCheminPhoto1);
try
{
// Récupère une URL(lieu du code , chemin)
urlPhoto2 = new URL(getCodeBase(), lsCheminPhoto2);
}
catch(java.net.MalformedURLException e)
{
System.err.println("Création d'image impossible : " + "URL
incorrecte");
}
// --- ImageIcon(url, texte)
iconePhoto2 = new ImageIcon(urlPhoto2, "La couverture");
}
public void paint(Graphics g)
{
// --- drawImage(Image, x, y, le container)
g.drawImage(imgPhoto1,0,0,this);
// --- paintIcon(Le container, l'objet graphics , x, y)
iconePhoto2.paintIcon(this,g,300,0);
}
}

Script de la page HTML
<html>
<applet code="AppletImage.class" width="700" height="200">
</applet>
</html>
© Pascal Buguet
Imprimé le 27 mai 2017
Page 36
JAVA – LES APPLETS

Commentaires
On utilise dans cette applet les méthodes "automatiques" appelées par le navigateur( init() et paint()).
Pour récupérer la première photo (que l'on traitera comme une image) nous utilisons la méthode
getImage() qui renvoie une image. Cette méthode exige deux paramètres : l'URL absolue de
stockage du fichier image et le nom du fichier. Pour le lieu nous sollicitons la méthode
getDocumentBase() qui renvoie une URL correspondant au dossier d'origine de l'applet.
imgPhoto1 = this.getImage(getDocumentBase(), lsCheminPhoto1);
Pour récupérer la deuxième photo (que l'on traitera comme une icône) nous récupérons l'URL du
fichier en créant un objet URL. Nous devons passer en argument l'URL de l'applet que nous
récupérons avec la méthode getCodeBase() et le nom du fichier.
urlPhoto2 = new URL(getCodeBase(), lsCheminPhoto2);
Ensuite nous créons un objet icône en passant en argument l'URL précédente et une description.
iconePhoto2 = new ImageIcon(urlPhoto2, "La couverture");
Enfin dans la méthode paint() nous dessinons les images avec respectivement les méthodes
drawImage() et paintIcon()
// --- objetGraphics.drawImage(image, x, y, le container)
g.drawImage(imgPhoto1,0,0,this);
// --- ObjetIcone.paintIcon(Le container, l'objet graphics, x, y)
iconePhoto2.paintIcon(this,g,300,0);
© Pascal Buguet
Imprimé le 27 mai 2017
Page 37
JAVA – LES APPLETS
1.15 UNE ANIMATION AVEC DES JPEG DANS UNE APPLET

Objectif
Une animation (girouette) avec des JPEG (ImageIcon de Swing).
© Pascal Buguet
Imprimé le 27 mai 2017
Page 38
JAVA – LES APPLETS

Le JLabel à quatre faces
import java.awt.*;
import javax.swing.*;
import java.net.URL; // --- Pour les URL
public class AppletAnim1 extends JApplet implements Runnable
{
private ImageIcon photos[] = new ImageIcon[4]; // 4 photos
Thread troncheDeProcessus;
JPanel panneau;
JLabel lblImageIcon;
// --------------public void init()
// --------------{
String lsFichiers[] = {"1.jpg","2.jpg","3.jpg","4.jpg"};
panneau
= new JPanel(new GridLayout(1,1));
lblImageIcon = new JLabel();
panneau.add(lblImageIcon);
getContentPane().add(panneau);
try
{
for(int i=0; i<photos.length; i++)
{
URL urlIcon = new URL(getCodeBase(), "../images/" +
lsFichiers[i]);
photos[i]=new ImageIcon(urlIcon,lsFichiers[i]);
}
}
catch(Exception e) { System.err.println(e.getMessage()); }
}
// ---------------public void start()
// ---------------{
troncheDeProcessus = new Thread(this);
troncheDeProcessus.start();
}
// --------------public void stop()
// --------------{
troncheDeProcessus = null;
}
// -------------public void run()
// -------------{
int i=0;
while(true)
{
lblImageIcon.setIcon(photos[i]);
try { Thread.sleep(1000); }
catch(InterruptedException e) { }
i++;
if(i == photos.length) i = 0;
}
}
}
Note : si vous créez un dossier images au même niveau que le dossier des classes le chemin sera ../images/
© Pascal Buguet
Imprimé le 27 mai 2017
Page 39
JAVA – LES APPLETS

Exercice : Le bandeau déroulant
© Pascal Buguet
Imprimé le 27 mai 2017
Page 40
JAVA – LES APPLETS

Le code java
// --import
import
import
import
Applet et animation d'images (Des icônes en série dans quatre labels)
java.awt.GridLayout;
java.awt.Color;
javax.swing.*;
java.net.*; // Pour les URL
@SuppressWarnings("serial")
public class AppletAnim4 extends JApplet implements Runnable
{
final static int MAX_IMAGES = 7;
final static int MAX_LABELS = 4;
Thread troncheDeProcessus;
JPanel panneau
= new JPanel(new GridLayout(1,MAX_LABELS));
JLabel lblImage[]
= new JLabel[MAX_LABELS];
ImageIcon icIcones[] = new ImageIcon[MAX_IMAGES];
URL urlIcon;
String isFichiers[] =
{
"1.jpg","2.jpg","3.jpg","4.jpg","5.jpg","6.jpg","7.jpg"
};
public AppletAnim4()
{
super();
}
// --------------public void init()
// --------------{
for(int i=0; i<icIcones.length; i++)
{
try
{
// Récupère une URL (lieu du code s'exécutant, chemin)
urlIcon = new URL(getCodeBase(), "../images/" +
isFichiers[i]);
}
catch(java.net.MalformedURLException e)
{
System.err.println("Création d'image impossible : " +
"URL incorrecte");
}
// --- ImageIcon ( url, texte)
icIcones[i] = new ImageIcon(urlIcon, isFichiers[i]);
}
for(int i=0; i<=MAX_LABELS-1; i++)
{
lblImage[i] = new JLabel();
panneau.add(lblImage[i]);
}
panneau.setBackground(Color.BLACK);
getContentPane().add(panneau);
}
// ---------------public void start()
// ---------------{
troncheDeProcessus = new Thread(this);
troncheDeProcessus.start();
}
// -------------public void run()
// --------------
© Pascal Buguet
Imprimé le 27 mai 2017
Page 41
JAVA – LES APPLETS
{
int liPosition = 0;
while(true)
{
liPosition++;
changerImage(liPosition, liPosition + MAX_LABELS - 1);
if(liPosition == MAX_IMAGES-1) liPosition = 0;
}
}
// -------------------------------------public void changerImage(int aiDebut, int aiFin)
// -------------------------------------{
for(int i=0; i<=MAX_LABELS-1; i++)
{
if(aiDebut+i > MAX_IMAGES-1) aiDebut = aiDebut - MAX_LABELS;
lblImage[i].setIcon(icIcones[aiDebut+i]);
}
try { Thread.sleep(1000); }
catch(InterruptedException e) { }
}
// --------------public void stop()
// --------------{
troncheDeProcessus = null;
}
}
© Pascal Buguet
Imprimé le 27 mai 2017
Page 42
JAVA – LES APPLETS
1.16 UNE APPLET DANS UNE APPLICATION

Objectif
Un code d'applet Java peut être aussi exécuté soit comme une application soit comme une applet.
Ce qui nous nous donne deux types d'utilisation pour deux types de clients.

En mode application

En mode navigateur
© Pascal Buguet
Imprimé le 27 mai 2017
Page 43
JAVA – LES APPLETS

Principes
Le principe de base est que la classe principale doit hériter de la classe JApplet.
Cette classe doit posséder une procédure main().
La méthode init() doit être redéfinie en instanciant un objet de type JFrame.
L'application tournera en mode application.
L'application tournera au travers d'un appel à partir d'une applet contenue dans une page HTML.

Code Java
// --- Applet et Convertisseur Euros-Dollars en Applet - Application
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
//import java.lang.*;
// ----------- La fenêtre JFrame
class WPrincipale extends JFrame
// ----------- La fenêtre JFrame
{
private String isCours, isDollars, isEuros;
// --- Les composants graphiques
JPanel panneau = new JPanel(new GridLayout(3,3));
JLabel lblCoursDollar
= new JLabel("Cours du dollar oggi");
JTextField tfCoursDollar = new JTextField("",10);
JLabel lblDollars
= new JLabel("");
JLabel lblEuros
= new JLabel("Euros");
JTextField tfEuros = new JTextField("",10);
JButton cbDollars = new JButton("$");
JLabel lblDollars
= new JLabel("Dollars");
JTextField tfDollars = new JTextField("",10);
JButton cbEuros
= new JButton("e");
// --- Le constructeur
public WPrincipale()
{
panneau.setBackground(Color.cyan);
ActionListener al = new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
String lsInter;
float lfDollars, lfEuros, lfInter, lfCours;
lsInter = tfCoursDollar.getText();
lfCours = Float.parseFloat(lsInter);
if(e.getSource() == cbDollars)
{
lfEuros
= Float.parseFloat(tfEuros.getText());
lfInter
= lfEuros * lfCours;
isDollars = Float.toString(lfInter);
tfDollars.setText(isDollars);
}
if(e.getSource() == cbEuros)
{
lfDollars = Float.parseFloat(tfDollars.getText());
lfInter
= lfDollars / lfCours;
isEuros
= Float.toString(lfInter);
© Pascal Buguet
Imprimé le 27 mai 2017
Page 44
JAVA – LES APPLETS
tfEuros.setText(isEuros);
}
}
};
cbDollars.addActionListener(al);
cbEuros.addActionListener(al);
panneau.add(lblCoursDollar);
panneau.add(tfCoursDollar);
panneau.add(lblDollars);
panneau.add(lblEuros);
panneau.add(tfEuros);
panneau.add(cbDollars);
panneau.add(lblDollars);
panneau.add(tfDollars);
panneau.add(cbEuros);
getContentPane().add(panneau);
pack();
setVisible(true);
}
// --- Les méthodes ad hoc de l'appli
public String getDollars()
{
return tfDollars.getText();
}
}
// --- L'applet
public class AppletAppli extends JApplet
// --- L'applet
{
WPrincipale lWPrincipale;
// --- La méthode main
public static void main(String args[])
{
new WPrincipale();
}
// --- La méthode init()
public void init()
{
lWPrincipale = new WPrincipale();
}
// --- Les méthodes ad hoc de l'applet
public String getDollars()
{
return lWPrincipale.getDollars();
}
// --------------------public String getEuros()
{
return lWPrincipale.tfEuros.getText();
}
// --------------------public String getCours()
{
return lWPrincipale.tfCoursDollar.getText();
}
}
© Pascal Buguet
Imprimé le 27 mai 2017
Page 45
JAVA – LES APPLETS

Commentaires
Le code est composé :


D'une classe JFrame
D'une classe JApplet
Le code de la classe JFrame est tout à fait standard. Il dispose de trois méthodes getXXX() pour les
besoins de l'applet mais ce pourrait être pour d'autres besoins.
Le code de la JApplet est celui qui différencie le tout.
Il comporte deux méthodes d'initialisation :


La méthode init() pour l'utilisation Applet
La méthode main() pour l'utilisation application.
La classe principale dérivée de JApplet :
public class AppletAppli extends JApplet
La méthode main() instancie une fenêtre lorsque l'utilisation se fait en mode application.
public static void main(String args[])
{
new WPrincipale();
}
La méthode init() instancie la même fenêtre dans le cas d'une utilisation de type Applet.
public void init()
{
lWPrincipale = new WPrincipale();
}
La récupération des valeurs
Elle est faite


soit via l'appel d'une méthode
soit via la récupération de la valeur de la propriété du JTextField.
La première technique est plus FullObject.
return lWPrincipale.getDollars();
return lWPrincipale.tfCoursDollar.getText();
© Pascal Buguet
Imprimé le 27 mai 2017
Page 46
JAVA – LES APPLETS
1.17 UTILISER UN FICHIER JAR POUR UNE APPLET

Objectif
L'utilisation d'un fichier JAR est fortement recommandée pour les applets.
Lorsque l'applet est chargée, elle utilise une connexion WEB. Si cette applet utilise des classes
auxiliaires, des fichiers image,… chaque fichier utilisera une connexion vers le serveur WEB, ce qui
s'avère coûteux en connexions, en temps de téléchargement et en temps d'exécution de l'applet. Les
fichiers JAR sont compressés.
La solution consiste à créer et à utiliser un fichier JAR.
Un fichier archive de type JAR est créé avec l'utilitaire JAR.EXE fournit avec le JDK.
Les syntaxes sont les suivantes :
Jar [options]
Jar
cf
fichierAArchiver
fichier.jar
fichiersAArchiver
*.class
L'option c crée le fichier d'archives.
L'option f spécifie que le nom du fichier d'archives est un argument de la ligne de commandes.
Pour de plus amples informations sur cet utilitaire tapez jar /? après l'invite de commandes.

Jar
Jar

Exemples
cf
cf
archive1.jar *.class *.jpg
Applet4.jar
Applet4.class julia4.jpg sandra2.jpg
La balise Applet modifiée
<applet code="Applet4b.class" archive="Applet4b.jar" width="700" height="200" />
Vous ajoutez l'attribut archive="valeur" à la balise.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 47
JAVA – LES APPLETS
1.18
ANNEXE : STRUCTURE DU CODE D'UNE APPLET V1
A titre d'information vous trouverez ci-dessous le code minimal d'une applet dérivée de la classe
Applet.

Code
import java.applet.*;
import java.awt.*;
public class Applet00 extends Applet
{
public void init()
{
setBackground(Color.yellow);
add(new Label("Première Applet"));
}
}

Commentaires
Le code de la classe qui est proposé ici utilise les bibliothèques de classes java.applet et java.awt pour
les composants et la couleur.
La classe est dérivée de la classe Applet.
© Pascal Buguet
Imprimé le 27 mai 2017
Page 48