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
t t t
This reveals most of what the Introspector sees as it produces a BeanInfo object from your Bean. You can see that the type of the property and its name are independent. Notice the lowercasing of the property name. (The only time this doesn’t occur is when the property name begins with more than one capital letter in a row.) And remember that the method names you’re seeing here (such as the read and write methods) are actually produced from a Method object that can be used to invoke the associated method on the object. t Ceci révèle la plus grosse partie de ce que voit l'Introspector lorsqu'il produit un objet BeanInfo à partir d'un Bean. On peut voir que le type de la propriété et son nom sont indépendants. Remarquons la minuscule du nom de la propriété (la seule fois où ceci ne se produit pas est lorsque le nom de la propriété commence par plus d'une majuscule l'une derrière l'autre). Il faut également retenir que les noms de méthodes qu'on voit ici (tels que les noms des méthodes de lecture et d'écriture) sont en fait obtenues à partir d'un objet Method qui peut être utilisé pour invoquer les méthodes corrrespondantes de l'objet.
t t t
The public method list includes the methods that are not associated with a property or event, such as croak( ), as well as those that are. These are all the methods that you can call programmatically for a Bean, and the application builder tool can choose to list all of these while you’re making method calls, to ease your task. t La liste des méthodes public contient les méthodes qui ne sont pas associées à une propriété ou un événement, telles que croak(), ainsi que celles qui le sont. Ce sont toutes les méthodes pouvant être appelées par programme pour un Bean, et l'outil de construction d'applications peut décider de les lister toutes lors de la création des appels de méthodes, pour nous faciliter la tâche.
t t t
Finally, you can see that the events are fully parsed out into the listener, its methods, and the add- and remove-listener methods. Basically, once you have the BeanInfo, you can find out everything of importance for the Bean. You can also call the methods for that Bean, even though you don’t have any other information except the object (again, a feature of reflection).
t Enfin, on peut voir que les événements sont tous triés entre le listener, ses méthodes et les méthodes pour ajouter et supprimer les listeners. Fondamentalement, une fois obtenu le BeanInfo, on peut trouver tout ce qui est important pour un Bean. On peut également appeler les méthodes de ce Bean, bien qu'on n'ait aucune autre information à l'exception de l'objet (ceci est également une caractéristique de la réflexion).
t t t

A more sophisticated Bean

t

Un Bean plus complexe

t t t
This next example is slightly more sophisticated, albeit frivolous. It’s a JPanel that draws a little circle around the mouse whenever the mouse is moved. When you press the mouse, the word “Bang!” appears in the middle of the screen, and an action listener is fired. t L'exemple suivant est un peu plus compliqué, bien que futile. Il s'agit d'un JPanel qui dessine un petit cercle autour de la souris chaque fois qu'elle se déplace. Lorsqu'on clique, le mot Bang! apparaît au milieu de l'écran, et un action listener est appelé.
t t t
The properties you can change are the size of the circle as well as the color, size, and text of the word that is displayed when you press the mouse. A BangBean also has its own addActionListener( ) and removeActionListener( ) so you can attach your own listener that will be fired when the user clicks on the BangBean. You should be able to recognize the property and event support: t Les propriétés modifiables sont la taille du cercle, ainsi que la couleur, la taille et le texte du mot affiché lors du clic. Un BangBean a également ses propres addActionListener() et removeActionListener(), de sorte qu'on peut y attacher son propre listener qui sera appelé lorsque l'utilisateur clique sur le BangBean. Vous devriez être capables de reconnaître le support des propriétés et événements :
t t t
//: bangbean:BangBean.java // A graphical Bean. package bangbean; import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.io.*; import java.util.*; import com.bruceeckel.swing.*; public class BangBean extends JPanel implements Serializable { protected int xm, ym; protected int cSize = 20; // Circle size protected String text = "Bang!"; protected int fontSize = 48; protected Color tColor = Color.red; protected ActionListener actionListener; public BangBean() { addMouseListener(new ML()); addMouseMotionListener(new MML()); } public int getCircleSize() { return cSize; } public void setCircleSize(int newSize) { cSize = newSize; } public String getBangText() { return text; } public void setBangText(String newText) { text = newText; } public int getFontSize() { return fontSize; } public void setFontSize(int newSize) { fontSize = newSize; } public Color getTextColor() { return tColor; } public void setTextColor(Color newColor) { tColor = newColor; } public void paintComponent(Graphics g) { super.paintComponent(g); g.setColor(Color.black); g.drawOval(xm - cSize/2, ym - cSize/2, cSize, cSize); } // This is a unicast listener, which is // the simplest form of listener management: public void addActionListener ( ActionListener l) throws TooManyListenersException { if(actionListener != null) throw new TooManyListenersException(); actionListener = l; } public void removeActionListener( ActionListener l) { actionListener = null; } class ML extends MouseAdapter { public void mousePressed(MouseEvent e) { Graphics g = getGraphics(); g.setColor(tColor); g.setFont( new Font( "TimesRoman", Font.BOLD, fontSize)); int width = g.getFontMetrics().stringWidth(text); g.drawString(text, (getSize().width - width) /2, getSize().height/2); g.dispose(); // Call the listener's method: if(actionListener != null) actionListener.actionPerformed( new ActionEvent(BangBean.this, ActionEvent.ACTION_PERFORMED, null)); } } class MML extends MouseMotionAdapter { public void mouseMoved(MouseEvent e) { xm = e.getX(); ym = e.getY(); repaint(); } } public Dimension getPreferredSize() { return new Dimension(200, 200); } } ///:~ t
//: bangbean:BangBean.java
// Un Bean graphique.
package bangbean;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import com.bruceeckel.swing.*;

public class BangBean extends JPanel
     implements Serializable {
  protected int xm, ym;
  protected int cSize = 20; // Taille du cercle
  protected String text = "Bang!";
  protected int fontSize = 48;
  protected Color tColor = Color.red;
  protected ActionListener actionListener;
  public BangBean() {
    addMouseListener(new ML());
    addMouseMotionListener(new MML());
  }
  public int getCircleSize() { return cSize; }
  public void setCircleSize(int newSize) {
    cSize = newSize;
  }
  public String getBangText() { return text; }
  public void setBangText(String newText) {
    text = newText;
  }
  public int getFontSize() { return fontSize; }
  public void setFontSize(int newSize) {
    fontSize = newSize;
  }
  public Color getTextColor() { return tColor; }
  public void setTextColor(Color newColor) {
    tColor = newColor;
  }
  public void paintComponent(Graphics g) {
    super.paintComponent(g);
    g.setColor(Color.black);
    g.drawOval(xm - cSize/2, ym - cSize/2,
      cSize, cSize);
  }
  // Ceci est un "unicast listener", qui est
  // la forme la plus simple de gestion des listeners :
  public void addActionListener (
      ActionListener l)
        throws TooManyListenersException {
    if(actionListener != null)
      throw new TooManyListenersException();
    actionListener = l;
  }
  public void removeActionListener(
      ActionListener l) {
    actionListener = null;
  }
  class ML extends MouseAdapter {
    public void mousePressed(MouseEvent e) {
      Graphics g = getGraphics();
      g.setColor(tColor);
      g.setFont(
        new Font(
          "TimesRoman", Font.BOLD, fontSize));
      int width =
        g.getFontMetrics().stringWidth(text);
      g.drawString(text,
        (getSize().width - width) /2,
        getSize().height/2);
      g.dispose();
      // Appel de la méthode du listener :
      if(actionListener != null)
        actionListener.actionPerformed(
          new ActionEvent(BangBean.this,
            ActionEvent.ACTION_PERFORMED, null));
    }
  }
  class MML extends MouseMotionAdapter {
    public void mouseMoved(MouseEvent e) {
      xm = e.getX();
      ym = e.getY();
      repaint();
    }
  }
  public Dimension getPreferredSize() {
    return new Dimension(200, 200);
  }
} ///:~
t t t
The first thing you’ll notice is that BangBean implements the Serializable interface. This means that the application builder tool can “pickle” all the information for the BangBean using serialization after the program designer has adjusted the values of the properties. When the Bean is created as part of the running application, these “pickled” properties are restored so that you get exactly what you designed. t La première chose qu'on remarquera est que BangBean implémente l'interface Serializable. Ceci signifie que l'outil de construction d'applications peut conserver toutes les informations sur le BangBean en utilisant la sérialisation, lorsque les valeurs des propriétés ont été ajustées par l'utilisateur. Lors de la création du Bean au moment de l'exécution du programme, ces propriétés sauvegardées sont restaurées de manière à obtenir exactement ce qu'elles valaient lors de la conception.
t t t
You can see that all the fields are private, which is what you’ll usually do with a Bean—allow access only through methods, usually using the “property” scheme. t On peut voir que tous les champs sont private, ce qu'on fait en général avec un Bean : autoriser l'accès uniquement à travers des méthodes, normalement en utilisant le système de propriétés.
t t t
When you look at the signature for addActionListener( ), you’ll see that it can throw a TooManyListenersException. This indicates that it is unicast, which means it notifies only one listener when the event occurs. Ordinarily, you’ll use multicast events so that many listeners can be notified of an event. However, that runs into issues that you won’t be ready for until the next chapter, so it will be revisited there (under the heading “JavaBeans revisited”). A unicast event sidesteps the problem. t En observant la signature de addActionListener(), on voit qu'il peut émettre une TooManyListenersException. Ceci indique qu'il est unicast, ce qui signifie qu'il signale à un seul listener l'arrivée d'un événement. En général on utilise des événements multicast, de sorte que de nombreux listeners puissent être notifiés de l'arrivée d'un événement. Cependant on entre ici dans des problèmes que vous ne pouvez pas comprendre avant le chapitre suivant; on en reparlera donc (sous le titre «JavaBeans revisited»). Un événement unicast contourne le problème.
t t t
When you click the mouse, the text is put in the middle of the BangBean, and if the actionListener field is not null, its actionPerformed( ) is called, creating a new ActionEvent object in the process. Whenever the mouse is moved, its new coordinates are captured and the canvas is repainted (erasing any text that’s on the canvas, as you’ll see). t Lorsqu'on clique avec la souris, le texte est placé au milieu du BangBean, et si le champ de l'actionListener n'est pas nul, on appelle son actionPerformed(), ce qui crée un nouvel objet ActionEvent. Lorsque la souris est déplacée, ses nouvelles coordonnées sont lues et le panneau est redessiné (ce qui efface tout texte sur ce panneau, comme on le remarquera).
t t t
Here is the BangBeanTest class to allow you to test the bean as either an applet or an application: t Voici la classe BangBeanTest permettant de tester le bean en tant qu'applet ou en tant qu'application :
t t t
//: c13:BangBeanTest.java // <applet code=BangBeanTest // width=400 height=500></applet> import bangbean.*; import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.util.*; import com.bruceeckel.swing.*; public class BangBeanTest extends JApplet { JTextField txt = new JTextField(20); // During testing, report actions: class BBL implements ActionListener { int count = 0; public void actionPerformed(ActionEvent e){ txt.setText("BangBean action "+ count++); } } public void init() { BangBean bb = new BangBean(); try { bb.addActionListener(new BBL()); } catch(TooManyListenersException e) { txt.setText("Too many listeners"); } Container cp = getContentPane(); cp.add(bb); cp.add(BorderLayout.SOUTH, txt); } public static void main(String[] args) { Console.run(new BangBeanTest(), 400, 500); } } ///:~ t
//: c13:BangBeanTest.java
// <applet code=BangBeanTest
// width=400 height=500></applet>
import bangbean.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import com.bruceeckel.swing.*;

public class BangBeanTest extends JApplet {
  JTextField txt = new JTextField(20);
  // Affiche les actions lors des tests :
  class BBL implements ActionListener {
    int count = 0;
    public void actionPerformed(ActionEvent e){
      txt.setText("BangBean action "+ count++);
    }
  }
  public void init() {
    BangBean bb = new BangBean();
    try {
      bb.addActionListener(new BBL());
    } catch(TooManyListenersException e) {
      txt.setText("Too many listeners");
    }
    Container cp = getContentPane();
    cp.add(bb);
    cp.add(BorderLayout.SOUTH, txt);
  }
  public static void main(String[] args) {
    Console.run(new BangBeanTest(), 400, 500);
  }
} ///:~
t t t
When a Bean is in a development environment, this class will not be used, but it’s helpful to provide a rapid testing method for each of your Beans. BangBeanTest places a BangBean within the applet, attaching a simple ActionListener to the BangBean to print an event count to the JTextField whenever an ActionEvent occurs. Usually, of course, the application builder tool would create most of the code that uses the Bean. t Lorsqu'un Bean est dans un environnement de développement, cette classe n'est pas utilisée, mais elle est utile pour fournir une méthode de test rapide pour chacun de nos Beans. BangBeanTest place un BangBean dans une applet, attache un simple ActionListener au BangBean pour afficher un compteur d'événements dans le JTextField chaque fois qu'un ActionEvent arrive. En temps normal, bien sûr, l'outil de construction d'applications créerait la plupart du code d'utilisation du Bean.
t t t
When you run the BangBean through BeanDumper or put the BangBean inside a Bean-enabled development environment, you’ll notice that there are many more properties and actions than are evident from the above code. That’s because BangBean is inherited from JPanel, and JPanel is also Bean, so you’re seeing its properties and events as well.
t Lorsqu'on utilise le BangBean avec le BeanDumper, ou si on place le BangBean dans un environnement de développement acceptant les Beans, on remarquera qu'il y a beaucoup plus de propriétés et d'actions que ce qui n'apparaît dans le code ci-dessus. Ceci est dû au fait que BangBean hérite de JPanel, et comme JPanel est également un Bean, on en voit également ses propriétés et événements.
t t t

Packaging a Bean

t

Empaquetage d'un Bean

t t t
Before you can bring a Bean into a Bean-enabled visual builder tool, it must be put into the standard Bean container, which is a JAR file that includes all the Bean classes as well as a “manifest” file that says “This is a Bean.” A manifest file is simply a text file that follows a particular form. For the BangBean, the manifest file looks like this (without the first and last lines): t Pour installer un Bean dans un outil de développement visuel acceptant les Beans, le Bean doit être mis dans le conteneur standard des Beans, qui est un fichier JAR contenant toutes les classes, ainsi qu'un fichier manifest qui dit «ceci est un Bean». Un fichier manifest est un simple fichier texte avec un format particulier. Pour le BangBean, le fichier manifest ressemble à ceci (sans la première et la dernière ligne) :
t t t
//:! :BangBean.mf Manifest-Version: 1.0 Name: bangbean/BangBean.class Java-Bean: True ///:~ t
//:! :BangBean.mf
Manifest-Version: 1.0

Name: bangbean/BangBean.class
Java-Bean: True
///:~
t t t
The first line indicates the version of the manifest scheme, which until further notice from Sun is 1.0. The second line (empty lines are ignored) names the BangBean.class file, and the third says, “It’s a Bean.” Without the third line, the program builder tool will not recognize the class as a Bean. t La première ligne indique la version de la structure du fichier manifest, qui est 1.0 jusqu'à nouvel ordre de chez Sun. la deuxième ligne (les lignes vides étant ignorées) nomme le fichier BangBean.class, et la troisième précise que c'est un Bean. Sans la troisième ligne, l'outil de construction de programmes ne reconnaîtra pas la classe en tant que Bean.
t t t
The only tricky part is that you must make sure that you get the proper path in the “Name:” field. If you look back at BangBean.java, you’ll see it’s in package bangbean (and thus in a subdirectory called “bangbean” that’s off of the classpath), and the name in the manifest file must include this package information. In addition, you must place the manifest file in the directory above the root of your package path, which in this case means placing the file in the directory above the “bangbean” subdirectory. Then you must invoke jar from the same directory as the manifest file, as follows: t Le seul point délicat est de s'assurer d'avoir le bon chemin dans le champ «Name:». Si on retourne à BangBean.java, on voit qu'il est dans le package bangbean (et donc dans un sous-répertoire appelé bangbean qui est en dehors du classpath), et le nom dans le fichier manifest doit contenir cette information de package. De plus, il faut placer le fichier manifest dans le répertoire au-dessus de la racine du package, ce qui dans notre cas veut dire le placer dans le répertoire au-dessus du répertoire bangbean. Ensuite il faut lancer jar depuis le répertoire où se trouve le fichier manifest, de la façon suivante :
t t t
jar cfm BangBean.jar BangBean.mf bangbean t
jar cfm BangBean.jar BangBean.mf bangbean
t t t
This assumes that you want the resulting JAR file to be named BangBean.jar and that you’ve put the manifest in a file called BangBean.mf. t Ceci suppose qu'on veut que le fichier JAR résultant s'appelle BangBean.jar, et qu'on a placé le fichier manifest dans un fichier appelé BangBean.mf.
t t t
You might wonder “What about all the other classes that were generated when I compiled BangBean.java?” Well, they all ended up inside the bangbean subdirectory, and you’ll see that the last argument for the above jar command line is the bangbean subdirectory. When you give jar the name of a subdirectory, it packages that entire subdirectory into the jar file (including, in this case, the original BangBean.java source-code file—you might not choose to include the source with your own Beans). In addition, if you turn around and unpack the JAR file you’ve just created, you’ll discover that your manifest file isn’t inside, but that jar has created its own manifest file (based partly on yours) called MANIFEST.MF and placed it inside the subdirectory META-INF (for “meta-information”). If you open this manifest file you’ll also notice that digital signature information has been added by jar for each file, of the form: t On peut se demander ce qui se passe pour les autres classes générées lorsqu'on a compilé BangBean.java. Eh bien, elles ont toutes abouti dans le sous-répertoire bangbean. Lorsqu'on donne à la commande jar le nom d'un sous-répertoire, il embarque tout le contenu de ce sous-répertoire dans le fichier jar (y compris, dans notre cas, le code source original BangBean.java qu'on peut ne pas vouloir inclure dans les Beans). Si on regarde à l'intérieur du fichier JAR, on découvre que le fichier manifest n'y est pas, mais que jar a créée son propre fichier manifest (partiellement sur la base du nôtre) appelé MANIFEST.MF et l'a placé dans le sous-répertoire META-INF (pour meta-information). Si on ouvre ce fichier manifest on remarquera également qu'une information de signature numérique a été ajoutée par jar pour chaque fichier, de la forme :
t t t
Digest-Algorithms: SHA MD5 SHA-Digest: pDpEAG9NaeCx8aFtqPI4udSX/O0= MD5-Digest: O4NcS1hE3Smnzlp2hj6qeg== t
Digest-Algorithms: SHA MD5
SHA-Digest: pDpEAG9NaeCx8aFtqPI4udSX/O0=MD5-Digest: O4NcS1hE3Smnzlp2hj6qeg==
t t t
In general, you don’t need to worry about any of this, and if you make changes you can just modify your original manifest file and reinvoke jar to create a new JAR file for your Bean. You can also add other Beans to the JAR file simply by adding their information to your manifest. t En général, on ne se préoccupe pas de tout ceci, et lors de modifications il suffit de modifier le fichier manifest d'origine et rappeler jar pour créer un nouveau fichier JAR pour le Bean. On peut aussi ajouter d'autres Beans dans le fichier JAR en ajoutant simplement leurs informations dans le manifest.
t t t
One thing to notice is that you’ll probably want to put each Bean in its own subdirectory, since when you create a JAR file you hand the jar utility the name of a subdirectory and it puts everything in that subdirectory into the JAR file. You can see that both Frog and BangBean are in their own subdirectories. t Une chose à remarquer est qu'on mettra probablement chaque Bean dans son propre sous-répertoire, puisque lorsqu'on crée un fichier JAR on passe à la commande jar le nom d'un sous-répertoire et qu'il place tout ce qui est dans ce répertoire dans le fichier JAR. On peut voir que Frog et BangBean sont chacun dans leur propre sous-répertoire.
t t t
Once you have your Bean properly inside a JAR file you can bring it into a Beans-enabled program-builder environment. The way you do this varies from one tool to the next, but Sun provides a freely available test bed for JavaBeans in their “Beans Development Kit” (BDK) called the “beanbox.” (Download the BDK from java.sun.com/beans.) To place your Bean in the beanbox, copy the JAR file into the BDK’s “jars” subdirectory before you start up the beanbox.
t Une fois le Bean convenablement inséré dans un fichier JAR, on peut l'installer dans un environnement de développement de programmes acceptant les Beans. La façon de le faire varie d'un outil à l'autre, mais Sun fournit gratuitement un banc de test pour les JavaBeans dans leur Beans Development Kit (BDK) appelé la beanbox (le BDK se télécharge à partir de java.sun.com/beans). Pour placer un Bean dans la beanbox, il suffit de copier le fichier JAR dans le sous-répertoire jars du BDK avant de lancer la beanbox.
t t t

More complex Bean support

t

Un support des Beans plus sophistiqué

t t t
You can see how remarkably simple it is to make a Bean. But you aren’t limited to what you’ve seen here. The JavaBeans architecture provides a simple point of entry but can also scale to more complex situations. These situations are beyond the scope of this book, but they will be briefly introduced here. You can find more details at java.sun.com/beans. t On a vu comme il était simple de fabriquer un Bean. Mais on n'est pas limité à ce qu'on a vu ici. L'architecture des JavaBeans fournit un point d'entrée simple, mais peut aussi s'adapter à des cas plus complexes. Ceux-ci ne sont pas du ressort de ce livre, mais on va les introduire rapidement ici. On trouvera plus de détails à java.sun.com/beans.
t t t
One place where you can add sophistication is with properties. The examples above have shown only single properties, but it’s also possible to represent multiple properties in an array. This is called an indexed property. You simply provide the appropriate methods (again following a naming convention for the method names) and the Introspector recognizes an indexed property so your application builder tool can respond appropriately. t Un endroit où l'on peut apporter des perfectionnements est le traitement des propriétés. Les exemples ci-dessus n'ont montré que des propriétés uniques, mais il est également possible de représenter plusieurs propriétés dans un tableau. C'est ce qu'on appelle une propriété indexée [indexed property]. Il suffit de fournir les méthodes appropriées (également en suivant une convention de nommage pour les noms de méthodes) et l'Introspector reconnaît une propriété indexée, de sorte qu'un outil de construction d'applications puisse y répondre correctement.
t t t
Properties can be bound, which means that they will notify other objects via a PropertyChangeEvent. The other objects can then choose to change themselves based on the change to the Bean. t Les propriétés peuvent être liées [bound], ce qui signifie qu'elles avertiront les autres objets à l'aide d'un PropertyChangeEvent. Les autres objets peuvent alors décider de se modifier eux-mêmes suite à la modification de ce Bean.
t t t
Properties can be constrained, which means that other objects can veto a change to that property if it is unacceptable. The other objects are notified using a PropertyChangeEvent, and they can throw a PropertyVetoException to prevent the change from happening and to restore the old values. t Les propriétés peuvent être contraintes [constrained], ce qui signifie que les autres objets peuvent mettre leur veto sur la modification de cette propriété si c'est inacceptable. Les autres objets sont avertis à l'aide d'un PropertyChangeEvent, et ils peuvent émettre un PropertyVetoException pour empêcher la modification et pour rétablir les anciennes valeurs.
t t t
You can also change the way your Bean is represented at design time: t On peut également modifier la façon de représenter le Bean lors de la conception :
t t t
  1. You can provide a custom property sheet for your particular Bean. The ordinary property sheet will be used for all other Beans, but yours is automatically invoked when your Bean is selected.
  2. You can create a custom editor for a particular property, so the ordinary property sheet is used, but when your special property is being edited, your editor will automatically be invoked.
  3. You can provide a custom BeanInfo class for your Bean that produces information that’s different from the default created by the Introspector.
  4. It’s also possible to turn “expert” mode on and off in all FeatureDescriptors to distinguish between basic features and more complicated ones.
t
  1. On peut fournir une feuille de propriétés spécifique pour un Bean particulier. La feuille de propriétés normale sera utilisée pour tous les autres Beans, mais la feuille spéciale sera automatiquement appelée lorsque ce Bean sera sélectionné.
  2. On peut créer un éditeur spécifique pour une propriété particulière, de sorte que la feuille de propriétés normale est utilisée, mais si on veut éditer cette propriété, c'est cet éditeur qui est automatiquement appelé.
  3. On peut fournir une classe BeanInfo spécifique pour un Bean donné, pour fournir des informations différentes de celles créées par défaut par l'Introspector.
  4. Il est également possible de valider ou dévalider le mode expert dans tous les FeatureDescriptors pour séparer les caractéristiques de base de celles plus compliquées.
t t t

More to Beans

t

Davantage sur les Beans

t t t
There’s another issue that couldn’t be addressed here. Whenever you create a Bean, you should expect that it will be run in a multithreaded environment. This means that you must understand the issues of threading, which will be introduced in Chapter 14. You’ll find a section there called “JavaBeans revisited” that will look at the problem and its solution. t Il y a un autre problème qui n'a pas été traité ici. Chaque fois qu'on crée un Bean, on doit s'attendre à ce qu'il puisse être exécuté dans un environnement multithread. Ceci signifie qu'il faut comprendre les problèmes du threading, qui sera présenté au Chapitre 14. On y trouvera un paragraphe appelé «JavaBeans revisited» qui parlera de ce problème et de sa solution.
t t t
There are a number of books about JavaBeans; for example, JavaBeans by Elliotte Rusty Harold (IDG, 1998).
t Il y a plusieurs livres sur les JavaBeans, par exemple JavaBeans par Elliotte Rusty Harold (IDG, 1998).
t t t

Summary

t

Résumé

t t t
Of all the libraries in Java, the GUI library has seen the most dramatic changes from Java 1.0 to Java 2. The Java 1.0 AWT was roundly criticized as being one of the worst designs seen, and while it would allow you to create portable programs, the resulting GUI was “equally mediocre on all platforms.” It was also limiting, awkward, and unpleasant to use compared with the native application development tools available on a particular platform. t De toutes les librairies Java, c'est la librairie de GUI qui a subi les changements les plus importants de Java 1.0 à Java 2. L'AWT de Java 1.0 était nettement critiqué comme étant une des moins bonnes conceptions jamais vues, et bien qu'il permette de créer des programmes portables, la GUI résultante était aussi médiocre sur toutes les plateformes. Il était également limité, malaisé et peu agréable à utiliser en comparaison des outils de développement natifs disponibles sur une plate-forme donnée.
t t t
When Java 1.1 introduced the new event model and JavaBeans, the stage was set—now it was possible to create GUI components that could be easily dragged and dropped inside visual application builder tools. In addition, the design of the event model and Beans clearly shows strong consideration for ease of programming and maintainable code (something that was not evident in the 1.0 AWT). But it wasn’t until the JFC/Swing classes appeared that the job was finished. With the Swing components, cross-platform GUI programming can be a civilized experience. t Lorsque Java 1.1 introduisit le nouveau modèle d'événements et les JavaBeans, la scène était installée. Il était désormais possible de créer des composants de GUI pouvant être facilement glissés et déposés à l'intérieur d'outils de développement visuels. De plus, la conception du modèle d'événements et des Beans montre l'accent mis sur la facilité de programmation et la maintenabilité du code (ce qui n'était pas évident avec l'AWT du 1.0). Mais le travail ne s'est terminé qu'avec l'apparition des classes JFC/Swing. Avec les composants Swing, la programmation de GUI toutes plateformes devient une expérience civilisée.
t t t
Actually, the only thing that’s missing is the application builder tool, and this is where the real revolution lies. Microsoft’s Visual Basic and Visual C++ require Microsoft’s application builder tools, as does Borland’s Delphi and C++ Builder. If you want the application builder tool to get better, you have to cross your fingers and hope the vendor will give you what you want. But Java is an open environment, and so not only does it allow for competing application builder environments, it encourages them. And for these tools to be taken seriously, they must support JavaBeans. This means a leveled playing field: if a better application builder tool comes along, you’re not tied to the one you’ve been using—you can pick up and move to the new one and increase your productivity. This kind of competitive environment for GUI application builder tools has not been seen before, and the resulting marketplace can generate only positive results for the productivity of the programmer. t En fait, la seule chose qui manque est l'outil de développement, et c'est là que se trouve la révolution. Visual Basic et Visual C++ de Microsoft nécessitent des outils de développement de Microsoft, et il en est de même pour Delphi et C++ Builder de Borland. Si on désire une amélioration de l'outil, on n'a plus qu'à croiser les doigts et espérer que le fournisseur le fera. Mais java est un environnement ouvert, et de ce fait, non seulement il permet la compétition des outils, mais il l'encourage. Et pour que ces outils soient pris au sérieux, ils doivent permettre l'utilisation des JavaBeans. Ceci signifie un terrain de jeu nivelé : si un meilleur outil de développement apparaît, on n'est pas lié à celui qu'on utilisait jusqu'alors, on peut migrer vers le nouvel outil et augmenter sa productivité. Cet environnement compétitif pour les outils de développement ne s'était jamais vu auparavant, et le marché résultant ne peut que générer des résultats positifs pour la productivité du programmeur.
t t t
This chapter was meant only to give you an introduction to the power of Swing and to get you started so you could see how relatively simple it is to feel your way through the libraries. What you’ve seen so far will probably suffice for a good portion of your UI design needs. However, there’s a lot more to Swing—it’s intended to be a fully powered UI design tool kit. There’s probably a way to accomplish just about everything you can imagine. t Ce chapitre était uniquement destiné à vous fournir une introduction à la puissance de Swing et vous faire démarrer, et vous avez pu voir comme il était simple de trouver son chemin à travers les librairies. Ce qu'on a vu jusqu'ici suffira probablement pour une bonne part à vos besoins en développement d'interfaces utilisateurs. Cependant, Swing ne se limite pas qu'à cela. Il est destiné à être une boîte à outils de conception d'interfaces utilisateurs très puissante. Il y a probablement une façon de faire à peu près tout ce qu'on peut imaginer.
t t t
If you don’t see what you need here, delve into the online documentation from Sun and search the Web, and if that’s not enough then find a dedicated Swing book—a good place to start is The JFC Swing Tutorial, by Walrath & Campione (Addison Wesley, 1999).
t Si vous ne trouvez pas ici ce dont vous avez besoin, fouillez dans la documentation en ligne de Sun, et recherchez sur le Web, et si cela ne suffit pas, cherchez un livre consacré à Swing. Un bon endroit pour démarrer est The JFC Swing Tutorial, par Walrath & Campione (Addison Wesley, 1999).
t t t
t t t
t t
\\\
///
t t t
t
     
Sommaire Le site de Bruce Eckel