t
t
t
t
t t   13) Création de fenêtres & d'Applets
tttt
t
carrea) Préface carreb) Avant-propos carre1) Introduction sur les &laqo; objets » carre2) Tout est &laqo; objet » carre3) Contrôle du flux du programme carre4) Initialization & Cleanup carre5) Cacher l'implémentation carre6) Réutiliser les classes carre7) Polymorphisme carre8) Interfaces & classes internes carre9) Stockage des objets carre10) Error Handling with Exceptions carre11) Le système d’E/S de Java carre12) Identification dynamique de type 13) Création de fenêtres & d'Applets carre14) Les &laqo; Threads » multiples carre15) Informatique distribuée carreA) Passage et retour d'objets carreB) L'Interface Java Natif (JNI) carreC) Conseils pour une programation stylée en Java carreD) Resources
Texte original t Traducteur : P. Boite
t
t
    
Ce chapitre contient 14 pages
1 2 3 4 5 6 7 8 9 10 11 12 13 14
\\\
t t t
t t t
t
05.07.01 - version 0.3 [Armel] :
- Ajout des tags pour la séparation des pages sur le site.
07.05.2001 - Version 0.2 :
- espaces des guillemets « ajoutés. »;
- colorisation du code (armel)
12.11.2000 - Version 0.1 :
- Dernière mise à jour de la version française.
Traducteur :
- Philippe BOITE
Texte original :
-Thinking in Java, 2nd edition, Revision 10
© 2000 by Bruce Eckel
t t t
13: Creating Windows
& Applets
t 13: Création de Fenêtres et Applets
t t t
A fundamental design guideline is “make simple things easy, and difficult things possible.” [61]
t Une directive de conception fondamentale est « rendre les choses simples faciles, et les choses difficiles possibles ».
t t t
The original design goal of the graphical user interface (GUI) library in Java 1.0 was to allow the programmer to build a GUI that looks good on all platforms. That goal was not achieved. Instead, the Java 1.0 Abstract Window Toolkit (AWT) produces a GUI that looks equally mediocre on all systems. In addition, it’s restrictive: you can use only four fonts and you cannot access any of the more sophisticated GUI elements that exist in your operating system. The Java 1.0 AWT programming model is also awkward and non-object-oriented. A student in one of my seminars (who had been at Sun during the creation of Java) explained why: the original AWT had been conceptualized, designed, and implemented in a month. Certainly a marvel of productivity, and also an object lesson in why design is important. t L'objectif initial de la conception de la bibliothèque d'interface utilisateur graphique [graphical user interface (GUI)] en Java 1.0 était de permettre au programmeur de construire une GUI qui a un aspect agréable sur toutes les plateformes. Ce but n'a pas été atteint. L'Abstract Window Toolkit (AWT) de Java 1.0 produit au contraire une GUI d'aspect aussi mé diocre sur tous les systèmes. De plus, elle est restrictive : on ne peut utiliser que quatre fontes, et on n'a accès à aucun des éléments de GUI sophistiqués disponibles dans son système d'exploitation.Le modèle de programmation de l'AWT Java 1.0 est aussi maladroit et non orienté objet. Un étudiant d'un de mes séminaires (qui était chez Sun lors de la création de Java) m'a expliqué pourquoi : l'AWT original avait été imaginé, conçu, et implémenté en un mois. Certainement une merveille de productivité, mais aussi un exemple du fait que la conception est importante.
t t t
The situation improved with the Java 1.1 AWT event model, which takes a much clearer, object-oriented approach, along with the addition of JavaBeans, a component programming model that is oriented toward the easy creation of visual programming environments. Java 2 finishes the transformation away from the old Java 1.0 AWT by essentially replacing everything with the Java Foundation Classes (JFC), the GUI portion of which is called “Swing.” These are a rich set of easy-to-use, easy-to-understand JavaBeans that can be dragged and dropped (as well as hand programmed) to create a GUI that you can (finally) be satisfied with. The “revision 3” rule of the software industry (a product isn’t good until revision 3) seems to hold true with programming languages as well. t La situation s'est améliorée avec le modèle d'événements de l'AWT de Java 1.1, qui a une approche beaucoup plus claire et orientée objet, avec également l'ajout des JavaBeans, un modèle de programmation par composants qui est tourné vers la création facile d'environnements de programmation visuels. Java 2 termine la transformation depuis l'ancien AWT de Java 1.0 en remplaçant à peu près tout par les Java Foundation Classes (JFC), dont la partie GUI est appelée « Swing ». Il s'agit d'un ensemble riche de JavaBeans faciles à utiliser et faciles à comprendre, qui peuvent être glissés et déposés (ou programmés manuellement) pour créer une GUI qui vous donnera (enfin) satisfaction. La règle de la « version 3 » de l'industrie du logiciel (un produit n'est bon qu'à partir de la version 3) semble également se vérifier pour les langages de programmation.
t t t
This chapter does not cover anything but the modern, Java 2 Swing library, and makes the reasonable assumption that Swing is the final destination GUI library for Java. If for some reason you need to use the original “old” AWT (because you’re supporting old code or you have browser limitations), you can find that introduction in the first edition of this book, downloadable at www.BruceEckel.com (also included on the CD ROM bound with this book). t Ce chapitre ne couvre que la bibliothèque moderne Swing de Java 2, et fait l'hypothèse raisonnable que Swing est la bibliothèque finale pour les GUI Java. Si pour une quelconque raison vous devez utiliser le « vieux » AWT d'origine (parce que vous maintenez du code ancien ou que vous avez des limitations dans votre browser), vous pouvez trouver cette présentation dans la première édition de ce livre, téléchargeable à www.BruceEckel.com (également incluse sur le CD ROM fourni avec ce livre).
t t t
Early in this chapter, you’ll see how things are different when you want to create an applet vs. a regular application using Swing, and how to create programs that are both applets and applications so they can be run either inside a browser or from the command line. Almost all the GUI examples in this book will be executable as either applets or applications. t Dès le début de ce chapitre, vous verrez combien les choses sont différentes selon que vous voulez créer une applet ou une application normale utilisant Swing, et comment créer des programmes qui sont à la fois des applets et des applications, de sorte qu'ils puissent être exécutés soit dans un browser soit depuis la ligne de commande. Presque tous les exemples de GUI seront exécutables aussi bien comme des applets que comme des applications.
t t t
Please be aware that this is not a comprehensive glossary of either all the Swing components, or all the methods for the described classes. What you see here is intended to be simple. The Swing library is vast, and the goal of this chapter is only to get you started with the essentials and comfortable with the concepts. If you need to do more, then Swing can probably give you what you want if you’re willing to do the research. t Soyez conscients que ceci n'est pas un glossaire complet de tous les composants Swing, ou de toutes les méthodes pour les classes décrites. Ce qui se trouve ici a pour but d'être simple. La bibliothèque Swing est vaste, et le but de ce chapitre est uniquement de vous permettre de démarrer avec les notions essentielles et d'être à l'aise avec les concepts. Si vous avez besoin de plus, alors Swing peut probablement vous donner ce que vous voulez si vous avez la volonté de faire des recherches.
t t t
I assume here that you have downloaded and installed the (free) Java library documents in HTML format from java.sun.com and will browse the javax.swing classes in that documentation to see the full details and methods of the Swing library. Because of the simplicity of the Swing design, this will often be enough information to solve your problem. There are numerous (rather thick) books dedicated solely to Swing and you’ll want to go to those if you need more depth, or if you want to modify the default Swing behavior. t Je suppose ici que vous avez téléchargé et installé les documents (gratuits) de la bibliothèque Java au format HTML depuis java.sun.com et que vous parcourrez les classes javax.swing dans cette documentation pour voir tous les détails et toutes les méthodes de la bibliothèque Swing. Grâce à la simplicité de la conception de Swing, ceci sera souvent suffisant pour régler votre problème. Il y a de nombreux livres (assez épais) dédiés uniquement à Swing et vous vous y réfèrerez si vous avez besoin d'approfondir, ou si vous voulez modifier le comportement par défaut de Swing.
t t t
As you learn about Swing you’ll discover: t En apprenant Swing vous découvrirez que :
t t t
  1. Swing is a much better programming model than you’ve probably seen in other languages and development environments. JavaBeans (which will be introduced toward the end of this chapter) is the framework for that library.
  2. “GUI builders” (visual programming environments) are a de rigueur aspect of a complete Java development environment. JavaBeans and Swing allow the GUI builder to write code for you as you place components onto forms using graphical tools. This not only rapidly speeds development during GUI building, but it allows for greater experimentation and thus the ability to try out more designs and presumably come up with a better one.
  3. The simplicity and well-designed nature of Swing means that even if you do use a GUI builder rather than coding by hand, the resulting code will still be comprehensible—this solves a big problem with GUI builders from the past, which could easily generate unreadable code.
t
  1. Swing est un bien meilleur modèle de programmation que ce que vous avez probablement vu dans d'autres langages et environnements de développement. Les JavaBeans (qui seront présentées vers la fin de ce chapitre) constituent l'ossature de cette bibliothèque.
  2. Les « GUI builders »(environnements de programmation visuels) sont un must-have d'un environnement de développement Java complet. Les JavaBeans et Swing permettent au « builder » d'écrire le code pour vous lorsque vous placez les composants sur des formulaires à l'aide d'outils graphiques. Ceci permet non seulement d'accélérer le développement lors de la création de GUI, mais aussi d'expérimenter plus et de ce fait d'essayer plus de modèles et probablement d'en obtenir un meilleur.
  3. La simplicité et la bonne conception de Swing signifie que même si vous utilisez un GUI builder plutôt que du codage manuel, le code résultant sera encore compréhensible ; ceci résout un gros problème qu'avaient les GUI builders, qui généraient souvent du code illisible.
t t t
Swing contains all the components that you expect to see in a modern UI, everything from buttons that contain pictures to trees and tables. It’s a big library, but it’s designed to have appropriate complexity for the task at hand—if something is simple, you don’t have to write much code but as you try to do more complex things, your code becomes proportionally more complex. This means an easy entry point, but you’ve got the power if you need it. t Swing contient tous les composants attendus dans une interface utilisateur moderne, depuis des boutons contenant des images jusqu'à des arborescences et des tables. C'est une grosse bibliothèque mais elle est conçue pour avoir la complexité appropriée pour la tâche à effectuer ; si quelque chose est simple, vous n'avez pas besoin d'écrire beaucoup de code, mais si vous essayez de fairedes choses plus compliquées, votre code devient proportionnellemnt plus complexe. Ceci signifie qu'il y a un point d'entrée facile, mais que vous avez la puissance à votre disposition si vous en avez besoin.
t t t
Much of what you’ll like about Swing could be called “orthogonality of use.” That is, once you pick up the general ideas about the library you can apply them everywhere. Primarily because of the standard naming conventions, much of the time that I was writing these examples I could guess at the method names and get it right the first time, without looking anything up. This is certainly the hallmark of a good library design. In addition, you can generally plug components into other components and things will work correctly. t Ce que vous aimerez dans Swing est ce qu'on pourrait appeler l' « orthogonalité d'utilisation ». C'est à dire, une fois que vous avez compris les idées générales de la bibliothèque, vous pouvez les appliquer partout. Principalement grâce aux conventions de nommage standards, en écrivant ces exemples je pouvais la plupart du temps deviner le nom des méthodes et trouver juste du premier coup, sans rechercher quoi que ce soit. C'est certainement la marque d'une bonne conception de la bibliothèque. De plus, on peut en général connecter des composants entre eux et les choses fonctionnent correctement.
t t t
For speed, all the components are “lightweight,” and Swing is written entirely in Java for portability. t Pour des question de rapidité, tous les composants sont « légers » , et Swing est écrit entièrement en Java pour la portabilité.
t t t
Keyboard navigation is automatic—you can run a Swing application without using the mouse, and this doesn’t require any extra programming. Scrolling support is effortless—you simply wrap your component in a JScrollPane as you add it to your form. Features such as tool tips typically require a single line of code to use. t La navigation au clavier est automatique ; vous pouvez exécuter une application Swing sans utiliser la souris, et ceci ne réclame aucune programmation supplémentaire. Le scrolling se fait sans effort, vous emballez simplement votre composant dans un JScrollPane lorque vous l'ajoutez à votre formulaire. Des fonctionnalités telles que les « infobulles » [tool tips] ne demandent qu'une seule ligne de code pour les utiliser.
t t t
Swing also supports a rather radical feature called “pluggable look and feel,” which means that the appearance of the UI can be dynamically changed to suit the expectations of users working under different platforms and operating systems. It’s even possible (albeit difficult) to invent your own look and feel.
t Swing possède également une fonctionnalité assez avancée, appelée le « pluggable look and feel », qui signifie que l'apparence de l'interface utilisateur peut être modifiée dynamiquement pour s'adapter aux habitudes des utilisateurs travaillant sur des plateformes et systèmes d'exploitation différents. Il est même possible (quoique difficile) d'inventer son propre « look and feel ».
t t t

The basic applet

t

L'applet de base

t t t
One of Java’s design goals is to create applets, which are little programs that run inside a Web browser. Because they must be safe, applets are limited in what they can accomplish. However, applets are a powerful tool that support client-side programming, a major issue for the Web.
t Un des buts de la conception Java est de créer des applets, qui sont des petits programmes s'exécutant à l'intérieur d'un browser Web. Parce qu'ils doivent être sûrs, les applets sont limitées dans ce qu'ils peuvent accomplir. Toutefois, les applets sont un outil puissant de programmation côté client, un problème majeur pour le Web.
t t t

Applet restrictions

t

Les restrictions des applets

t t t
Programming within an applet is so restrictive that it’s often referred to as being “inside the sandbox,” since you always have someone—that is, the Java run-time security system—watching over you. t Programmer dans un applet est tellement restrictif qu'on en parle souvent comme étant « dans le bac à sable », car il y a toujours quelqu'un (le système de sécurité Java lors de l'exécution [Java run-time security system] ) qui vous surveille.
t t t
However, you can also step outside the sandbox and write regular applications rather than applets, in which case you can access the other features of your OS. We’ve been writing regular applications all along in this book, but they’ve been console applications without any graphical components. Swing can also be used to build GUI interfaces for regular applications. t Cependant, on peut aussi sortir du bac à sable et écrire des applications normales plutôt que des applets ; dans ce cas on accède aux autres fonctionnalités de son OS. Nous avons écrit des applications tout au long de ce livre, mais il s'agissait d'applications console, sans aucun composant graphique. Swing peut aussi être utilisé pour construire des interfaces utilisateur graphiques pour des applications normales.
t t t
You can generally answer the question of what an applet is able to do by looking at what it is supposed to do: extend the functionality of a Web page in a browser. Since, as a Net surfer, you never really know if a Web page is from a friendly place or not, you want any code that it runs to be safe. So the biggest restrictions you’ll notice are probably: t On peut en général répondre à la question de savoir ce qu'une applet peut faire en considérant ce qu'elle est supposée faire : étendre les fonctionnalités d'une page Web dans un browser. Comme en tant que surfeur sur le Net on ne sait jamais si une page Web vient d'un site amical ou pas, on veut que tout le code qu'il exécute soit sûr. De ce fait, les restrictions les plus importantes sont probablement :
t t t
  1. An applet can’t touch the local disk. This means writing or reading, since you wouldn’t want an applet to read and transmit private information over the Internet without your permission. Writing is prevented, of course, since that would be an open invitation to a virus. Java offers digital signing for applets. Many applet restrictions are relaxed when you choose to allow trusted applets (those signed by a trusted source) to have access to your machine.
  2. Applets can take longer to display, since you must download the whole thing every time, including a separate server hit for each different class. Your browser can cache the applet, but there are no guarantees. Because of this, you should always package your applets in a JAR (Java ARchive) file that combines all the applet components (including other .class files as well as images and sounds) together into a single compressed file that can be downloaded in a single server transaction. “Digital signing” is available for each individual entry in the JAR file.
t
  1. Une applet ne peut pas toucher au disque local. Ceci signifie écrire ou lire, puisqu'on ne voudrait pas qu'une applet lise et transmette des informations privées sur Internet sans notre permission. Ecrire est interdit, bien sûr car ce serait une invitation ouverte aux virus. Java permet une signature digitale des applets. Beaucoup de restrictions des applets sont levées si on autorise des applets de confiance [trusted applets] (celles qui sont signées par une source dans laquelle on a confiance) à accéder à sa machine.
  2. Les applets peuvent mettre du temps à s'afficher, car il faut les télécharger complètement à chaque fois, nécesitant un accès au serveur pour chacune des classes. Le browser peut mettre l'applet dans son cache, mais ce n'est pas garanti. Pour cette raison, on devrait toujours empaqueter ses applets dans un fichier JAR (Java ARchive) qui rassemble tous les composants de l'applet (y compris d'autres fichiers .class ainsi que les images et les sons) en un seul fichier compressé qui peut être téléchargé en une seule transaction avec le serveur. La « signature digitale » existe pour chacun des fichiers contenus dans le fichier JAR.
t t t

Applet advantages

t

Les avantages d'une applet

t t t
If you can live within the restrictions, applets have definite advantages, especially when building client/server or other networked applications: t Si on admet ces restrictions, les applets ont des avantages, en particulier pour la création d'applications client/serveur ou réseaux :
t t t
  1. There is no installation issue. An applet has true platform independence (including the ability to easily play audio files, etc.) so you don’t need to make any changes in your code for different platforms nor does anyone have to perform any “tweaking” on installation. In fact, installation is automatic every time the user loads the Web page that contains applets, so updates happen silently and automatically. In traditional client/server systems, building and installing a new version of the client software is often a nightmare.
  2. You don’t have to worry about bad code causing damage to someone’s system, because of the security built into the core Java language and applet structure. This, along with the previous point, makes Java popular for so-called intranet client/server applications that live only within a company or restricted arena of operation where the user environment (Web browser and add-ins) can be specified and/or controlled.
t
  1. Il n'y a pas de problème d'installation. Une applet est réellement indépendante de la plateforme (y compris pour jouer des fichiers audio, etc.) et donc il n'est pas nécessaire de modifier le code en fonction des plateformes ni d'effectuer des « réglages » à l'installation. En fait, l'installation est automatique chaque fois qu'un utilisateur charge la page Web qui contient les applets, de sorte que les mises à jour se passent en silence et automatiquement. Dans les systèmes client/serveur traditionnels, créer et installer une nouvelle version du logiciel client est souvent un cauchemar.
  2. On ne doit pas craindre un code défectueux affectant le système de l'utilisateur, grâce au système de sécurité inclus au coeur du langage Java et de la structure de l'applet. Ceci, ainsi que le point précédent, rend Java populaire pour les applications intranet client/serveur qui n'existent qu'à l'intérieur d'une société ou dans une zone d'opérations réduite, où l'environnement utilisateur (le navigateur Web et ses extensions) peut être spécifié et/ou contrôlé.
t t t
Because applets are automatically integrated with HTML, you have a built-in platform-independent documentation system to support the applet. It’s an interesting twist, since we’re used to having the documentation part of the program rather than vice versa.
t Comme les applets s'intègrent automatiquement dans le code HTML, on dispose d'un système de documentation intégré et indépendant de la plateforme pour le support de l'applet. C'est une astuce intéressante, car on a plutôt l'habitude d'avoir la partie documentation du programme plutôt que l'inverse.
t t t

Application frameworks

t

Les squelettes d'applications

t t t
Libraries are often grouped according to their functionality. Some libraries, for example, are used as is, off the shelf. The standard Java library String and ArrayList classes are examples of these. Other libraries are designed specifically as building blocks to create other classes. A certain category of library is the application framework, whose goal is to help you build applications by providing a class or set of classes that produces the basic behavior that you need in every application of a particular type. Then, to customize the behavior to your own needs, you inherit from the application class and override the methods of interest. The application framework’s default control mechanism will call your overridden methods at the appropriate time. An application framework is a good example of “separating the things that change from the things that stay the same,” since it attempts to localize all the unique parts of a program in the overridden methods[62]. t Les bibliothèques sont souvent groupées selon leurs fonctionnalités. Certaines bibliothèques, par exemple, sont utilisées telles quelles. Les classes String et ArrayList de la bibliothèque standard Java en sont des exemples. D'autres bibliothèques sont conçues comme des briques de construction pour créer d'autres classes. Une certaine catégorie de bibliothèques est le squelette d'applications [application framework], dont le but est d'aider à la construction d'applications en fournissant une classe ou un ensemble de classes reproduisant le comportement de base dont vous avez besoin dans chaque application d'un type donné. Ensuite, pour particulariser le comportement pour ses besoins propres, on hérite de la classe et on redéfinit les méthodes qui nous intéressent. Un squelette d'application est un bon exemple de la règle « séparer ce qui change de ce qui ne change pas », car on essaie de localiser les parties spécifiques d'un programme dans les méthodes redéfinies [62].
t t t
Applets are built using an application framework. You inherit from class JApplet and override the appropriate methods. There are a few methods that control the creation and execution of an applet on a Web page: t les applets sont construites à l'aide d'un squelette d'application. On hérite de la classe JApplet et on redéfinit les méthodes adéquates. Quelques méthodes contrôlent la création et l'exécution d'une applet dans une page Web :
t t t
Method Operation
init( ) Automatically called to perform first-time initialization of the applet, including component layout. You’ll always override this method.
start( ) Called every time the applet moves into sight on the Web browser to allow the applet to start up its normal operations (especially those that are shut off by stop( )). Also called after init( ).
stop( ) Called every time the applet moves out of sight on the Web browser to allow the applet to shut off expensive operations. Also called right before destroy( ).
destroy( ) Called when the applet is being unloaded from the page to perform final release of resources when the applet is no longer used
t
Method Operation
init() Appelée automatiquement pour effectuer la première initialisation de l'applet, y compris la disposition des composants. Il faut toujours redéfinir cette méthode.
start() Appelée chaque fois que l'applet est rendue visible du navigateur Web, pour permettre à l'applet de démarrer ses opérations normales (en particuliers celles qui sont arrêtées par stop()). Appelée également après init().
stop() Appelée chaque fois que l'applet redevient invisible du navigateur Web, pour permettre à l'applet d'arrêter les opérations coûteuses. Appelée également juste avant destroy().
destroy() Appelée lorsque l'applet est déchargée de la page pour effectuer la libération finale des ressources lorsque l'applet n'est plus utilisée.
t t t
With this information you are ready to create a simple applet: t Avec ces informations nous sommes prêts à créer une applet simple :
t t t
//: c13:Applet1.java // Very simple applet. import javax.swing.*; import java.awt.*; public class Applet1 extends JApplet { public void init() { getContentPane().add(new JLabel("Applet!")); } } ///:~ t
//: c13:Applet1.java
// Très simple applet.
import javax.swing.*;
import java.awt.*;

public class Applet1 extends JApplet {
  public void init() {
  getContentPane().add(new JLabel("Applet!"));
}
} ///:~
t t t
Note that applets are not required to have a main( ). That’s all wired into the application framework; you put any startup code in init( ). t Remarquons qu'il n'est pas obligatoire qu'une applet ait une méthode main(). C'est complètement câblé dans le squelette d'application ; on met tout le code de démarrage dans init().
t t t
In this program, the only activity is putting a text label on the applet, via the JLabel class (the old AWT appropriated the name Label as well as other names of components, so you will often see a leading “J” used with Swing components). The constructor for this class takes a String and uses it to create the label. In the above program this label is placed on the form. t Dans ce programme, la seule activité consiste à mettre un label de texte sur l'applet, à l'aide de la classe JLabel (l'ancien AWT s'était approprié le nom Label ainsi que quelques autres noms de composants, de sorte qu'on verra souvent un « J » au début des composants Swing). Le constructeur de cette classe reçoit une String et l'utilise pour créer le label. Dans le programme ci-dessus ce label est placé dans le formulaire.
t t t
The init( ) method is responsible for putting all the components on the form using the add( ) method. You might think that you ought to be able to simply call add( ) by itself, and in fact that’s the way it used to be in the old AWT. However, Swing requires you to add all components to the “content pane” of a form, and so you must call getContentPane( ) as part of the add( ) process.
t La méthode init() est responsable du placement de tous les composants du formulaire en utilisant la méthode add(). On pourrait penser qu'il devrait être suffisant d'appeler simplement add(), et c'est ainsi que cela se passait dans l'ancien AWT. Swing exige quant à lui qu'on ajoute tous les composants sur la « vitre de contenu » [content pane] d'un formulaire, et il faut donc appeler getContentPane() au cours de l'opération add().
t t t

Running applets inside a Web browser

t

Exécuter des applets dans un navigateur Web

t t t
To run this program you must place it inside a Web page and view that page inside your Java-enabled Web browser. To place an applet inside a Web page you put a special tag inside the HTML source for that Web page[63] to tell the page how to load and run the applet. t Pour exécuter ce programme, il faut le placer dans une page Web et visualiser cette page à l'aide d'un navigateur Web configuré pour exécuter des applets Java. Pour placer une applet dans une page Web, on place un tag spécial dans le source HTML de cette page [63] pour dire à la page comment charger et exécuter cette applet.
t t t
This process used to be very simple, when Java itself was simple and everyone was on the same bandwagon and incorporated the same Java support inside their Web browsers. Then you might have been able to get away with a very simple bit of HTML inside your Web page, like this: t Ce système était très simple lorsque Java lui-même était simple et que tout le monde était dans le même bain et incorporait le même support de Java dans les navigateurs Web. Il suffisait alors d'un petit bout de code HTML dans une page Web, tel que :
t t t
<applet code=Applet1 width=100 height=50> </applet> t
<applet code=Applet1 width=100 height=50>
</applet>
t t t
Then along came the browser and language wars, and we (programmers and end users alike) lost. After awhile, JavaSoft realized that we could no longer expect browsers to support the correct flavor of Java, and the only solution was to provide some kind of add-on that would conform to a browser’s extension mechanism. By using the extension mechanism (which a browser vendor cannot disable—in an attempt to gain competitive advantage—without breaking all the third-party extensions), JavaSoft guarantees that Java cannot be shut out of the Web browser by an antagonistic vendor. t Ensuite vint la guerre des navigateurs et des langages, et nous (programmeurs aussi bien qu'utilisateurs finaux) y avons perdu. Au bout d'un moment, JavaSoft s'est rendu compte qu'on ne pouvait plus supposer que les navigateurs supportaient la version correcte de Java, et que la seule solution était de fournir une sorte d'extension qui se conformerait au mécanisme d'extension des navigateurs. En utilisant ce mécanisme d'extensions (qu'un fournisseur de navigateur ne peut pas supprimer -dans l'espoir d'y gagner un avantage sur la concurrence- sans casser aussi toutes les autres extensions), JavaSoft garantit que Java ne pourra pas être supprimé d'un navigateur Web par un fournisseur qui y serait hostile.
t t t
With Internet Explorer, the extension mechanism is the ActiveX control, and with Netscape it is the plug-in. In your HTML code, you must provide tags to support both. Here’s what the simplest resulting HTML page looks like for Applet1:[64]
t Avec Internet Explorer, le mécanisme d'extensions est le contrôle ActiveX, et avec Netscape c'est le plug-in. Dans le code HTML, il faut fournir les tags qui supportent les deux. Voici à quoi ressemble la page HTML la plus simple pour Applet1 : [64]
t t t
//:! c13:Applet1.html <html><head><title>Applet1</title></head><hr> <OBJECT classid="clsid:8AD9C840-044E-11D1-B3E9-00805F499D93" width="100" height="50" align="baseline" codebase="http://java.sun.com/products/plugin/1.2.2/jinstall-1_2_2-win.cab#Version=1,2,2,0"> <PARAM NAME="code" VALUE="Applet1.class"> <PARAM NAME="codebase" VALUE="."> <PARAM NAME="type" VALUE="application/x-java-applet;version=1.2.2"> <COMMENT> <EMBED type= "application/x-java-applet;version=1.2.2" width="200" height="200" align="baseline" code="Applet1.class" codebase="." pluginspage="http://java.sun.com/products/plugin/1.2/plugin-install.html"> <NOEMBED> </COMMENT> No Java 2 support for APPLET!! </NOEMBED> </EMBED> </OBJECT> <hr></body></html> ///:~ t
//:! c13:Applet1.html
<html><head><title>Applet1</title></head><hr>
<OBJECT
classid="clsid:8AD9C840-044E-11D1-B3E9-00805F499D93"
width="100" height="50" align="baseline"  codebase="http://java.sun.com/products/plugin/1.2.2/jinstall-1_2_2-win.cab#Version=1,2,2,0">
<PARAM NAME="code" VALUE="Applet1.class">
<PARAM NAME="codebase" VALUE=".">
<PARAM NAME="type" VALUE="application/x-java-applet;version=1.2.2">
<COMMENT>
<EMBED type=  "application/x-java-applet;version=1.2.2"
  width="200" height="200" align="baseline"
  code="Applet1.class" codebase="."
pluginspage="http://java.sun.com/products/plugin/1.2/plugin-install.html">
<NOEMBED>
</COMMENT>
No Java 2 support for APPLET!!
</NOEMBED>
</EMBED>
</OBJECT>
<hr></body></html>
///:~
t t t
Some of these lines were too long and had to be wrapped to fit on the page. The code in this book’s source code (on the book’s CD ROM, and downloadable from www.BruceEckel.com) will work without having to worry about correcting line wraps. t Certaines de ces lignes étaient trop longues et ont été coupées pour être insérées dans cette page. Le code inclus dans les sources de ce livre (sur le CD ROM de ce livre, et téléchargeable sur www.BruceEckel.com) fonctionne sans qu'on doive s'occuper de corriger les sauts de lignes.
t t t
The code value gives the name of the .class file where the applet resides. The width and height specify the initial size of the applet (in pixels, as before). There are other items you can place within the applet tag: a place to find other .class files on the Internet (codebase), alignment information (align), a special identifier that makes it possible for applets to communicate with each other (name), and applet parameters to provide information that the applet can retrieve. Parameters are in the form: t Le contenu de code fournit le nom du fichier .class dans lequel se trouve l'applet. Les paramètres width et height spécifient la taille initiale de l'applet (en pixels, comme avant). Il y a d'autres éléments qu'on peut placer dans le tag applet : un endroit où on peut trouver d'autres fichiers .class sur Internet (codebase), des informations d'alignement (align), un identificateur spécial permettant à des applets de communiquer entre eux (name), et des paramètres des applets pour fournir des informations que l'applet peut récupérer. Les paramètres sont de la forme :
t t t
<param name="identifier" value = "information"> t
<param name="identifier" value = "information">
t t t
and there can be as many as you want. t et il peut y en avoir autant qu'on veut.
t t t
The source code package for this book provides an HTML page for each of the applets in this book, and thus many examples of the applet tag. You can find a full and current description of the details of placing applets in Web pages at java.sun.com.
t Le package de codes source de ce livre fournit une page HTML pour chacune des applets de ce livre, et de ce fait de nombreux exemples du tag applet. Vous pouvez trouver une description complète et à jour des détails concernant le placement d'applets dans des pages web à l'adresse java.sun.com.
t t t

Using Appletviewer

t

Utilisation de Appletviewer

t t t
Sun’s JDK (freely downloadable from java.sun.com) contains a tool called the Appletviewer that picks the <applet> tags out of the HTML file and runs the applets without displaying the surrounding HTML text. Because the Appletviewer ignores everything but APPLET tags, you can put those tags in the Java source file as comments: t Le JDK de Sun (en téléchargement libre depuis java.sun.com) contient un outil appelé l'Appletviewer qui extrait le tag du fichier HTML et exécute les applets sans afficher le texte HTML autour. Comme l'Appletviewer ignore tout ce qui n'est pas tags APPLET, on peut mettre ces tags dans le source Java en commentaires :
t t t
// <applet code=MyApplet width=200 height=100> // </applet> t
// <applet code=MyApplet width=200 height=100>
// </applet>
t t t
This way, you can run “appletviewer MyApplet.java” and you don’t need to create tiny HTML files to run tests. For example, you can add the commented HTML tags to Applet1.java: t De cette manière, on peut lancer « appletviewer MyApplet.java » et il n'est pas nécessaire de créer de petits fichiers HTML pour lancer des tests. Par exemple, on peut ajouter ces tags HTML en commentaires dans Applet1.java:
t t t
//: c13:Applet1b.java // Embedding the applet tag for Appletviewer. // <applet code=Applet1b width=100 height=50> // </applet> import javax.swing.*; import java.awt.*; public class Applet1b extends JApplet { public void init() { getContentPane().add(new JLabel("Applet!")); } } ///:~ t
//: c13:Applet1b.java
// Embedding the applet tag for Appletviewer.
// <applet code=Applet1b width=100 height=50>
// </applet>
import javax.swing.*;
import java.awt.*;

public class Applet1b extends JApplet {>
  public void >init() {
  getContentPane().add(new JLabel("Applet!"));
}
} ///:~
t t t
Now you can invoke the applet with the command t Maintenant on peut invoquer l'applet avec la commande
t t t
appletviewer Applet1b.java t
appletviewer Applet1b.java
t t t
t t t
t t
    
///
t t t
t
     
Sommaire Le site de Bruce Eckel