Project:Omega.org

Un des aspects sympas dans l’écriture d’un article sur Java pour Mac OS X tient dans le nombre important de personnes différentes que le sujet intéressera. Des désaccords importants divisent les développeurs Java en deux groupes : ceux qui sont intéressés par ce que Mac OS X a à offrir et ceux intéressés par la création d’applications Mac OS X qui considèrent que Java pourrait être le meilleur moyen.

L’article précédent s’adressait au premier groupe. Le but de cet article était de pousser les développeurs Windows et les experts Unix à arrêter de dire : “Je ne savais pas que l’on pouvait faire ça sur un Mac“. Si vous faites partie de ce premier groupe, vous allez peut être vouloir passer à la fin de cet article et vous amuser avec le défi de cette semaine.

Dans cet article, nous allons aborder les choses de manière un peu plus lente et allons créer une application Java simple qui ne fait pas grand chose du tout. Cela vous permettra d’appréhender les étapes de base nécessaires pour mettre sur pied une application GUI (à interface utilisateur graphique) simple et la faire tourner. Ce n’est pas une introduction à Java ou à la programmation orientée objet, mais je prendrai le temps de détailler les questions que l’on se pose quand on débute et vous indiquerai d’autres références.

Le but actuel de cet article est d’alterner entre les deux groupes cibles. Comme toujours, s’il y a des sujets que vous voudriez voir aborder ou n’importe quelles idées pour de futurs articles, faites le moi savoir en m’envoyant une ligne à dsteinberg@core.com.

Note : Apple a mis en ligne la version “Update 1″ pour développeurs de Java 1.3.1 sur le site ADC. Même les membres libres ont le droit de télécharger la mise à niveau et la documentation. Examinez la ! Borland recommande que vous installiez cette version avant d’utiliser la version 6 de JBUILDER pour Mac OS X.

Démarrage

Créez d’abord un répertoire à l’intérieur de votre répertoire utilisateur. Vous pouvez faire cela avec le Finder et en naviguant vers :

Mac OS X/Users/<user name>/

Dans mon cas, mon nom d’utilisateur est “dhs” donc je créerai un nouveau dossier nommé “NineSquares” à l’intérieur de Mac OS X/Users/dhs/. Ouvrez maintenant l’application Terminal. En rappel, vous pouvez trouver cette application dans le Mac OS X/Applications/Utilities/. Vous pourrez trouver utile de glisser-déposer l’icône du Terminal dans votre dock. Après le démarrage du Terminal, vous devez voir apparaître un prompt dans le genre de :

[localhost:~] <user name>%

Tapez la commande ls et vous obtiendrez une description du contenu du répertoire courant. Vous devez y voir NineSquares dans la liste.

Maintenant nous avons besoin d’un simple éditeur de texte. Vous pouvez employer emacs, vi, BBEdit, Alpha, ou votre éditeur de texte personnel. Pour des programmes plus compliqués, il est agréable d’avoir un éditeur de texte qui fait effectue un coloriage contextuel et qui vérifie aussi les couples de parenthèses. Si vous voulez un éditeur plus chic qui propose une aide au développement (en suggérant, par exemple, les méthodes disponibles pour un objet), vous pouvez vouloir examiner un des IDE (Environnement Intégré de Développement) maintenant disponibles sur Mac. Dans cet article, je me servirai seulement de Text Edit. C’est gratuit. Il est livré avec Mac OS X et il n’y a vraiment rien à faire pour apprendre à s’en servir ou l’installer.

Lancez TextEdit. Vous le trouverez dans Mac OS X/Applications. Nous n’allons pas être amenés à sauvegarder au format Rich Text (RTFD) ce que nous allons faire donc, choisissez “Convertir au format texte” dans le menu Format. Choisissez maintenant “Enregistrer sous…” du menu de Fichier et naviguer jusqu’au dossier NineSquares que vous venez de créer. Nommez le fichier NineSquares.java et cliquer sur “Enregistrer”. TextEdit veut sauvegarder ce fichier en.txt mais il s’aperçoit que quelque chose ne va pas et il vous présente alors la boite de dialogue suivante :

Sélectionnez “Ne pas ajouter” et vous aurez créé et sauvegardé le document vide correctement intitulé NineSquares.java. Maintenant, poursuivez et inscrivez-y les lignes suivantes :

package NineSquares;
import javax.swing.JFrame;
public class NineSquares {
public static void main( String args[]) {
JFrame myFrame = new JFrame(”Nine Squares”);
myFrame.setVisible(true);
myFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

L’exécution du programme commencera avec le corps de la méthode main(). Dans ce cas précis, nous créons une nouvelle JFRAME nommée myFrame qui comportera “Nine Squares” (Neuf Carrés) dans la barre de titre. Il serait sympa de voir ce que nous avons créé, donc nous devons rendre visible myFrame.

La troisième étape consiste à s’assurer que le bouton “close” rouge se comportera correctement. Nous ne voulons pas seulement que le bouton rouge ferme la fenêtre que nous avons créée - nous voulons aussi que cela provoque l’arrêt de notre application. Donc nous réglons
l’action par défaut du bouton “close” sur EXIT_ON_CLOSE. Il n’est pas possible de se rappeler de tout quand on programme. Vous allez
oublier comment s’appelle une méthode ou quels arguments elle attend. Servez-vous des JavaDocs inclus dans votre installation Java. Vous les trouverez à l’adresse suivante.

Par exemple, pour découvrir ce qui est disponible dans JFRAME, naviguer en bas de la liste inférieur gauche jusqu’à ce que vous le découvriez. Un clic dessus et vous verrez une description complète dans le coin inférieur droit. En suivant les liens vous pouvez trouver en générale réponse aux questions que vous vous posez.

Retournons à notre premier programme…. Si vous essayez de le compiler et de le lancer avec juste la déclaration de classe et la méthode main() qu’il contient, vous obtiendriez une plainte du compilateur indiquant qu’il n’a aucune idée de ce que vous entendez par JFRAME. Vous avez besoin de déclarer une importation pour inclure les informations relatives à JFRAME.

Vous auriez pu importer le package javax.swing en entier avec la commande import javax.swing.*. J’ai tendance à bien cibler de ce que j’importe. Cette attitude était généralement recommandée pour des raisons de performance. Bien que la performance ne soit plus maintenant affectée, je continue de faire ainsi car cela me permet de connaître les dépendances de la classe que j’importe. Cela m’aide aussi quand je nettoie le code après suppression d’une ou deux références à des classes.

La dernière ligne à ajouter à NineSquares.java est la déclaration du package. Je vais terminer avec plusieurs fichiers donc je les garde tous dans un même package. Physiquement, cela signifie que je les garde tous dans le répertoire NineSquares, mais, que programmaticallement, j’aime aussi les considérer comme une seule entité.

Pour compiler votre fichier, allez dans le Terminal et tapez javac NineSquares/NineSquares.java. Tapez alors “retour”. Cette commande signifie que vous voulez compiler le fichier NineSquares.java à l’intérieur du répertoire NineSquares. Le prompt doit réapparaître et, maintenant, vous pouvez lancer votre application en tapant java NineSquares/NineSquares. Une petite fenêtre apparaîtra. Redimensionnez la fenêtre et déplacez la - appuiez sur les boutons verts, jaunes et rouges, et vous verrez que vous avez obtenu pour presque rien une fenêtre au comportement approprié.

Refactoring

Avant de poursuivre, réorganisons NineSquares.java de manière à scinder en deux ses fonctionnalités. Ce processus d’amélioration du code existant est appelé le refactoring. Pour en savoir plus sur ce processus allez sur le site Web de Refactoring de Martin Fowler. Pour le moment, nous n’allons pas faire de fantaisie. Nous allons nous servir de la notion d’héritage pour créer une sous-classe de JFRAME appelée MainFrame dont le but sera de régler l’action par défaut de son bouton “close” et sa visibilité au moment de sa création.

Tout ce que je demande à NineSquares.java est de créer une instance de MainFrame que nous pouvons toujours intituler myFrame. Voici le code que vous allez mettrez dans le fichier MainFrame.java :

package NineSquares;
import javax.swing.JFrame;
public class MainFrame extends JFrame{
  public MainFrame() {
    super("Nine Squares");
    setVisible(true);
    setDefaultCloseOperation(EXIT_ON_CLOSE);
  }
}

Vous remarquerez que MainFrame est une extension de JFRAME. La première chose nous faisons, donc, à l’intérieur du constructeur MainFrame (la méthode qui porte le nom MainFrame()) est d’appeler le constructeur JFRAME qui prend une chaîne de caractères comme argument. Dans notre première version du programme, nous avons fait cela directement en appelant new JFRAME(”Nine Squares”). Vous pouvez voir que le constructeur établit le JFRAME de la même manière qu’auparavant. Il reste maintenant à modifier le fichier NineSquares.java comme suit :

package NineSquares;
public class NineSquares {
  public static void main( String args[]) {
    new MainFrame();
  }
}

Il n’y a presque plus rien maintenant dans le fichier. Nous ne faisons que créer une nouvelle MainFrame() et nous en restons là. Remarquez que nous n’avons pas même à importer la classe JFRAME parce que nous créons une MainFrame et que MainFrame appartient au même package que NineSquares.

Sauvegardez vos changements et compilez ensuite ces deux fichiers dans le Terminal. Lancez l’application exactement comme avant. Cet exemple est très insignifiant, cependant le changement que nous avons effectué illustre un point important. Nous n’avons plus à apporter de nouveau des modifications à NineSquares.java. Son travail est bel et bien défini : Il fait en sorte que l’application se lance en créant une JFRAME spéciale appelée MainFrame. De la même manière, toutes les spécificités que nous avons apportées à JFRAME sont contenues dans la simple classe simple MainFrame. Maintenant nous savons où aller pour ajouter des fonctionnalités et des particularités.

Couleur vivante

Maintenant nous allons ajouter un panneau à MainFrame. Dans un première temps, nous commencerons avec un panneau bleu puis nous donnerons à l’utilisateur la possibilité de choisir la couleur du panneau. Nous allons créé une extension de la classe JPANEL qui se trouve dans le package javax.swing. Allez dans les JavaDocs et choisissez JPANEL.

Vous verrez qu’elle hérite de la méthode setBackground() de la classe JCOMPONENT. Cliquez sur setBackground() et vous verrez que cette méthode prend une couleur comme argument. Suivez la liaison en cliquant sur “Color” et vous verrez qu’il y a plusieurs manières de spécifier cette couleur. Nous commencerons en employant la constante Color.blue. Créez un fichier appelé EachSquare.java et sauvegardez-le comme avant dans le répertoire NineSquares. Son contenu doit ressembler à ceci :

package NineSquares;
import javax.swing.JPanel;
import java.awt.Color;
public class EachSquare extends JPanel {
  public EachSquare() {
      setBackground(Color.blue);
  }
}

Vous devez être aguerri maintenant avec ce que nous avons écrit. Nous avons spécifié qu’EachSquare est une sous-classe de JPANEL et, dans le constructeur, nous avons positionné la couleur de fond à bleu. De plus, nous avons dû importer les informations relatives à JPANEL et à Color et, nous avons fait appartenir EachSquare au package NineSquares.

Il ne nous reste plus qu’à modifier MainFrame.java pour lui ajouter un JPANEL bleu. C’est un peu plus compliqué à faire pour JFRAME que pour d’autres composants. Vous devez ajouter l’objet EachSquare au contenu de chaque carreau de JFRAME et non directement à JFRAME. Le nouveau code ressemble à cela :

package NineSquares;
import javax.swing.JFrame;
public class MainFrame extends JFrame{
  public MainFrame() {
    super("Nine Squares");
    getContentPane().add(new EachSquare());
    setVisible(true);
    setDefaultCloseOperation(EXIT_ON_CLOSE);
  }
}

La ligne complémentaire est mise en évidence en italique. Nous avons créé une nouvelle instance de EachSquare et l’avons ajoutée au contenu du carreau. Maintenant quand vous compilez ces fichiers et que vous lancez l’application, vous devez obtenir la même petite fenêtre avec, maintenant, un fond bleu.

Donner à l’utilisateur le choix de la couleur

Au lieu de coder en dur la couleur dans l’application, nous pourrions permettre à l’utilisateur de choisir la couleur de fond au moment où l’application démarre. Nous ferons ainsi en affichant un JCOLORCHOOSER qui permet à l’utilisateur de choisir une couleur à partir d’une palette. Une ressource utile pour observer les options gadgets des composants Swing est le Visual Index des Swing Components. Il fait partie du Tutoriel Java. Gardez en mémoire une chose : ils ont tous une meilleure apparence quand ils tournent sur un Mac.

Le JCOLORCHOOSER permet à l’utilisateur de choisir une couleur et il renvoi une couleur qui peut être employée comme argument à la méthode setBackground()que nous avons employée dans notre première partie relative à EachSquare. Changez le code d’EachSquare.java comme suit :

package NineSquares;
import javax.swing.JPanel;
import java.awt.Color;
import javax.swing.JColorChooser;
public class EachSquare extends JPanel {
 public EachSquare() {
  setBackground( JColorChooser.showDialog(
    this, "Choose Background Color", getBackground()));
 }
}

Pour lancer le JCOLORCHOOSER à partir d’une boîte de dialogue, nous appelons la méthode JCOLORCHOOSER.SHOWDIALOG(). Elle attend trois arguments. Le premier est le composant sur lequel nous allons appliquer la couleur. Le deuxième est un message à l’attention de l’utilisateur. Le troisième est la couleur initiale du composant à colorer. C’est à vous de vous assurer que les valeurs passées en arguments soient cohérentes entre elles.

Si votre but est d’obtenir et d’appliquer une couleur à un fond et que vous envoyez un message à l’utilisateur indiquant “Choisissez la couleur de la police”, l’utilisateur sera déconcerté. Remarquez que vous avez isolé les autres objets de ces changements. L’objet NineSquares et l’objet MainFrame n’ont pas à savoir comment la couleur est choisie. Sauvegardez vos changements, compilez et lancez l’application, l’écran suivant surgira avant que vous ne voyiez votre fenêtre flottante :

Neuf carreaux

Maintenant ajoutons plusieurs carreaux à notre cadre. Quand vous arrangez des composants visuels dans un conteneur vous quittez le monde des directives d’interface Aqua. Avec Java vous devez vous reposer sur les Gestionnaires de Mise en page de Sun. Vous pouvez choisir la manière dont sera disposé le conteneur de base puis ajouter ensuite des composants au conteneur et laisser le Gestionnaire de Mise en page décider où ils seront placés.

Dans notre cas, nous ajouterons neuf carreaux dans grille de trois lignes par trois colonnes. Au lieu de créer un seul objet EachSquare, nous allons en créer neuf d’entre eux et les ajouterons au contenu de MainFrame. Le fichier MainFrame.java doit donc être modifié ainsi :

package NineSquares;
import javax.swing.JFrame;
import java.awt.GridLayout;
public class MainFrame extends JFrame{
 public MainFrame() {
  super("Nine Squares");
  getContentPane().setLayout(new GridLayout(3,3));
  for (int i = 0; i<9; i++) {
   getContentPane().add(new EachSquare());
  }
  setVisible(true);
  setDefaultCloseOperation(EXIT_ON_CLOSE);
 }
}

Nous devons importer la classe GridLayout et ensuite nous fixons la mise en page du contenu du panneau selon le modèle d’un nouveau GridLayout qui est constitué de trois lignes par trois colonnes. Ensuite, nous créons neuf EachSquares et les ajoutons au contenu du panneau. Nous obtenons beaucoup avec très peu de changements de code. Maintenant jetons un coup d’oeil aux changements à apporter à EachSquare.java :

package NineSquares;
import javax.swing.JPanel;
import java.awt.Color;
public class EachSquare extends JPanel {
 public EachSquare() {
  setBackground(new Color((int)(Math.random()* 16777215)) );
 }
}

Nous venons de créer une couleur d’une nouvelle façon. Au lieu de spécifier une couleur constante ou d’utiliser un JCOLORCHOOSER, nous choisissons un nombre aléatoire entre 0 et 2^24-1. Vous remarquerez que nous n’avons eu à pas importer la classe Math. C’est parce qu’elle fait partie du package java.lang et est donc automatiquement disponible. Quand vous lancez l’application, vous obtenez une fenêtre qui ressemble à quelque chose dans ce genre là :

Répondre à des clics de souris

Jusqu’ici, notre application n’était pas très sensible. Dans la version suivante, nous afficherons toujours neuf carreaux avec des couleurs choisies aléatoirement, mais cette fois nous donnerons à l’utilisateur la possibilité de les changer. Si un utilisateur clique sur un carreau, une boite de dialogue JCOLORCHOOSER apparaîtra de manière contextuelle et permettra de changer la couleur de fond. Les seuls changements que nous allons apporter n’affecteront que le fichier EachSquare.java. Il ressemblera maintenant à ça :

package NineSquares;
import javax.swing.JPanel;
import java.awt.Color;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JColorChooser;
public class EachSquare extends JPanel {
  public EachSquare() {
    setBackground(new Color((int)(Math.random()* 16777215)) );
    addMouseListener(new MouseClickListener());
  }
  public class MouseClickListener extends MouseAdapter{
    public void mouseClicked(MouseEvent e) {
      setBackground(JColorChooser.showDialog(
        EachSquare.this, "Choose Background Color", getBackground()));
    }
  }
}

Le grand changement ici est MouseClickListener. Cette sous-classe de MouseAdapter attend un message indiquant qu’il y a eu un clic de souris dont il doit se soucier. Elle crée alors un JCOLORCHOOSER avec une couleur initiale correspondant à la couleur de fond du carreau. Quand l’utilisateur sélectionne la nouvelle couleur et ferme la boîte de dialogue, la couleur de fond du carreau est modifiée.

Le MouseClickListener est en réalité défini à l’intérieur de la classe EachSquare et est appelé “une classe intérne” (”inner class”). La ligne addMouseListener(new MouseClickListener()) est celle qui associe le MouseClickListener avec ce carreau particulier. Quand un carreau est cliqué, son MouseClickListener répond. Les seuls autres changements à apporter au fichier consistent à ajouter les importations appropriées.

En résumé

Bien que ce ne soit pas vraiment une introduction à Java, j’espère que cet article va vous aider à voir combien il est facile de créer des applications simples pour Mac OS X en utilisatant ce langage. Vous pouvez être en droit de constater que vous travaillez mieux avec un IDE faisant la plupart de ce travail visuel à votre place. Avec la plupart d’entre eux, vous pouvez glisser-déposer ces composants visuels sur une zone de travail et en personnaliser rapidement les propriétés pour obtenir le look et le comportement que vous souhaitez.

Pour une application de cette portée, il n’était pas si dure de la mettre en oeuvre à partir de rien et en se servant d’outils simples.

Textes originaux en anglais sur O’Reilly : Java Programming on the Mac par Daniel H.Steinberg

Thierry Java Java, Mac OS X