Dans ce court article, je souhaite décrire le processus de création d'un petit programme prenant en charge l'interface graphique dans le langage Java. On suppose que le lecteur est familiarisé avec les bases de la langue. Java.

Et donc, de quels outils avons-nous besoin :

• Machine virtuelle Java (OpenJDK ou Oracle JDK)
• Intellij IDEA (ou un autre IDE pour Java)

Après avoir installé le logiciel nécessaire, ouvrez IDÉE IntelliJ et créez un nouveau projet : File -> New Project…

j'ai nommé le projet guiBase. Comme vous pouvez le voir sur la capture d'écran, le dossier src ne contient rien, nous y créons donc notre classe principale contenant la fonction principale.

Classe publique Main ( public static void main(String args) ( System.out.println("Hello, Govzalla!"); ) )

Voir le contenu de la classe principale ci-dessus. Nous pouvons maintenant créer un projet ( projet de construction ) et exécutez-le ( Courir ). En bas dans le terminal de votre EDI vous verrez un message Bonjour, Govzalla !. Mais comme vous l'avez compris, il ne prend pas en charge l'interface graphique.

À ce stade, nous avons déjà un programme de travail, mais sans prise en charge de l'interface graphique. Et maintenant dans le même dossier src créer Formulaire d'interface graphique: Nouveau -> Formulaire GUI

Ouvrez le formulaire GUI créé, cliquez sur jPanel et définissez son identifiant dans le champ nom de domaine, J'ai demandé panneau.

Ensuite, faites glisser et déposez sur le formulaire sur le côté droit JTextField, JPasswordField et jBouton:

Il reste à ajouter le code et à y lier notre formulaire. Lorsque nous avons ajouté le formulaire fenêtre principale, la classe a été créée automatiquement fenêtre principale, cette classe est la classe du formulaire généré, c'est-à-dire cette classe servira tous les événements de la forme donnée.

Bien que notre classe de fenêtre contienne les éléments nécessaires, même maintenant, elle n'a rien à voir avec l'interface graphique, alors étendons-la avec jCadre et hériter de toutes les fonctionnalités de base et nécessaires de l'interface graphique .

À ce moment nous avons le formulaire fenêtre principale et classe fenêtre principale prolongé avec jCadre. Nous devons maintenant définir tous les éléments d'interface graphique ajoutés en tant que contenu de classe fenêtre principale this.getContentPane().add(panneau); Après cela, le contenu du fichier MainWindow.java sera modifié comme suit :

Importer javax.swing.* ; public class MainWindow étend JFrame ( private JTextField textField1; private JPasswordField passwordField1; private JButton button1; private JPanel panel; public MainWindow() ( this.getContentPane().add(panel); ) )

Si vous essayez d'exécuter le code, vous verrez à nouveau le même message "Hello, Govzalla!". Le problème est que nous avons créé une classe et sa forme, mais que nous n'avons pas créé d'instance de cette classe.

Il est temps de changer le fichier Main.java et d'y ajouter le code pour créer notre interface graphique :

Importer java.awt.* ; public class Main ( public static void main(String args) ( // Crée une instance de la classe MainWindow MainWindow mainWindow = new MainWindow(); // Emballe tous les éléments de notre formulaire mainWindow.pack(); // Redimensionne la fenêtre mainWindow.setSize( new Dimension(200, 200)); // Affiche la fenêtre créée mainWindow. setVisible(true); ) )

Exécuter le code

En cliquant sur le bouton, vous remarquerez que le programme ne réagit en aucune façon. Le fait est que nous n'avons pas encore ajouté l'écouteur ( Auditeur) pour les événements ( Événements) du bouton.

écouteur d'événement ( écouteur d'événement) jBouton doit être une implémentation d'adaptateur ActionListener, ajoutez donc le code suivant au corps de la classe fenêtre principale:

La classe privée MyButtonListener implémente ActionListener ( @Override public void actionPerformed(ActionEvent actionEvent) ( ) )

Méthode actionEffectuée() gérera tous les événements de bouton button1, mais vous devez d'abord indiquer à button1 quelle classe il gérera, ajoutez donc le code suivant au constructeur de la classe MainWIndow : this.button1.addActionListener(new MyButtonListener()); Pour que notre gestionnaire ne soit pas dénué de sens, ajoutez le code suivant à la méthode actionEffectuée():

@Override public void actionPerformed(ActionEvent actionEvent) ( if (textField1.getText().equals(passwordField1.getText())) ( JOptionPane.showMessageDialog(null, "Success"); ) else ( JOptionPane.showMessageDialog(null, "Échec "); ) )

Maintenant, le programme répondra correctement aux événements, pas à tous les événements, bien sûr. Par exemple, si vous essayez de désactiver le programme en cliquant sur la croix, la fenêtre disparaîtra, mais le programme fonctionnera toujours, car. gestionnaire d'événements de la fenêtre principale non ajouté.

Davydov Anton Valérievitch
Étudiant de TSU, Russie, Togliatti
Conseiller scientifique: Erofeeva E.A.

L'interface utilisateur en Java a traversé un chemin très épineux de formation et de développement. Le sien pendant longtemps accusé d'être gourmand en ressources système, travail lent et des fonctionnalités limitées. L'avènement de .NET avec des composants graphiques plus rapides a encore ébranlé la position de Java. Mais une telle concurrence n'a fait qu'inciter les développeurs Java à développer et à améliorer les bibliothèques graphiques. Et dans cet article, nous verrons ce qu'il en est advenu.

Boîte à outils de fenêtre abstraite

L'Abstract Window Toolkit (AWT en abrégé) a été publié pour la première fois en 1995 par Sun Microsystems. C'était la première tentative de création d'une interface graphique pour Java. AWT agissait comme une couche qui appelait des méthodes à partir de bibliothèques écrites en C. Et ces méthodes, à leur tour, utilisaient des composants graphiques système opérateur. D'une part, un programme construit de cette manière ressemblait à tous les autres programmes du système d'exploitation utilisé, mais d'autre part, le même programme peut sembler complètement différent sur différents systèmes d'exploitation, ce qui complique le développement. De plus, dans un souci de multiplateforme, il était nécessaire d'unifier les interfaces d'appel des composants, ce qui entraînait des fonctionnalités quelque peu tronquées. L'ensemble des composants est également assez modeste. Par exemple, il n'y a pas de tableaux et les icônes ne peuvent pas être placées dans les boutons. AWT essaie de libérer automatiquement les ressources utilisées. Cela affecte les performances et complique l'architecture. AWT est facile à apprendre, mais écrire quelque chose de complexe est difficile. Désormais, AWT est principalement utilisé pour les applets. Oracle encourage actuellement les développeurs à passer à Swing car il est plus sécurisé.

Fig.1 - Un exemple de programme écrit à l'aide d'AWT dans un environnement Windows

Après AWT, en 1998, Sun a sorti Swing. Il est entièrement écrit en Java et utilise la 2D pour le rendu. Swing a une variété de composants beaucoup plus large que AWT. Les composants eux-mêmes sont devenus beaucoup plus faciles à créer en héritant des fichiers . La possibilité d'utiliser différents styles et skins a également été introduite. Cependant, la vitesse de travail premières versions Le swing était assez faible et les erreurs d'écriture d'un programme pouvaient même entraîner un blocage du système d'exploitation.

Cependant, en raison de la facilité d'apprentissage et de la disponibilité un grand nombre documentation, Swing est devenu l'interface graphique la plus populaire de Java. Sur cette base, de nombreuses extensions sont apparues, telles que SwingX et JGoodies, qui facilitent encore plus la création d'applications visuellement complexes. Tous les environnements de programmation Java modernes incluent éditeur graphique Se balancer. Même si des frameworks plus modernes existent maintenant, Swing reste le plus populaire.

Fig. 2 - Exemple de programme écrit avec Swing

Boîte à outils de widget standard

SWT a été publié par IBM à une époque où Swing était encore lent, et principalement pour promouvoir l'environnement de programmation Eclipse. Comme AWT, SWT utilise des composants du système d'exploitation, mais différentes interfaces d'interopérabilité sont utilisées pour différentes plates-formes. Ainsi, une bibliothèque JAR distincte doit être livrée pour chaque système d'exploitation. Cela vous permet d'utiliser plus pleinement les fonctions correspondant aux différents systèmes d'exploitation. Et les composants manquants ont été implémentés en 2D. Cependant, SWT s'est avéré plus difficile à maîtriser que Swing. De plus, le programmeur doit lui-même mettre en œuvre la libération des ressources par l'application.

Fig.3 - Exemple de programme écrit avec Swing

JavaFX a été publié en 2008 par Oracle. Il se positionne comme une plateforme de création d'une application Internet riche. Pour le rendu, un pipeline graphique est utilisé, ce qui accélère considérablement l'application. Il existe un grand nombre de composants intégrés. Il existe également des composants distincts pour tracer des graphiques. Prise en charge implémentée du contenu multimédia, de l'animation et même du multi-touch. L'apparence des composants est configurée à l'aide de styles CSS. De plus, l'ensemble d'utilitaires JavaFX inclut la possibilité de créer un programme d'installation natif pour les plates-formes les plus populaires : exe ou msi pour Windows, deb ou rpm pour Linux, dmg pour Mac. Le site Web d'Oracle contient une documentation détaillée et un grand nombre d'exemples prêts à l'emploi.

Ainsi, après avoir décrit les principales caractéristiques et inconvénients des interfaces utilisateur graphiques ci-dessus, nous pouvons décider pour quelles tâches elles sont les mieux adaptées. L'Abstract Window Toolkit est plus adapté à la création d'applets. Un débutant peut recommander Swing étant donné que vous pouvez trouver une énorme quantité de documentation sur Internet, y compris en russe. JavaFX est idéal pour créer des applications Internet riches.

Liste des sources utilisées

Ryzhenko A. V. Programmation orientée objet : Complexe pédagogique et méthodologique pour la discipline de la spécialité 010501 - "Mathématiques appliquées et informatique". – 2007.

Khabibullin I. Sh. Java 7 (4e éd.). - BHV-Pétersbourg, 2012.

Clarke J., Connors J., Bruno E. J. JavaFX : Développement d'applications Internet riches. – Éducation Pearson, 2009.

Northover S., Wilson M. Swt : la boîte à outils de widgets standard, volume 1. - Addison Wesley Professional, 2004.

L'interface graphique en Java a traversé un chemin très épineux de développement et de formation. Pendant longtemps, il a été accusé de travail lent, d'avidité pour les ressources système et de fonctionnalités limitées.

AWT Java

La première tentative de Sun sur une interface graphique pour Java était la bibliothèque A.W.T.(Abstract Window Toolkit) - une boîte à outils pour travailler avec divers environnements de fenêtres. Sun a créé une couche Java qui appelle des méthodes à partir de bibliothèques écrites en C. Les méthodes de la bibliothèque AWT créent et utilisent les composants graphiques de l'environnement d'exploitation. D'une part, c'est bien, car un programme Java est similaire à d'autres programmes au sein du même système d'exploitation. Mais lors de son exécution sur une plate-forme différente, il peut y avoir des différences dans la taille des composants et des polices qui gâcheront apparence programmes.

Pour assurer la multiplateforme A.W.T. les interfaces d'appel de composant ont été unifiées, ce qui entraîne une fonctionnalité légèrement réduite. Et l'ensemble des composants s'est avéré assez petit. Par exemple, il n'y a pas de tableaux dans AWT et les icônes ne sont pas prises en charge dans les boutons. Cependant, le paquet java.awt inclus avec Java depuis la toute première version et peut être utilisé pour créer des interfaces graphiques.

Alors les composants A.W.T. ne faites aucun "travail". C'est juste un "encapsuleur Java" pour les contrôles du système d'exploitation sur lequel ils s'exécutent. Toutes les requêtes adressées à ces composants sont redirigées vers le système d'exploitation, qui fait tout le travail.

Ressources utilisées A.W.T. essaie de se libérer automatiquement. Cela complique légèrement l'architecture et affecte les performances. Écrire quelque chose de sérieux avec AWT sera quelque peu difficile. Maintenant, il n'est utilisé que pour les applets.

Concepts de base SWING

Après A.W.T. Sun a développé une bibliothèque de composants graphiques Se balancer, écrit entièrement en Java. La 2D est utilisée pour le rendu, ce qui apporte plusieurs avantages à la fois. Trousse composants standards surpasse considérablement AWT en termes de variété et de fonctionnalité. Swing facilite la création de nouveaux composants en héritant de composants existants et prend en charge une variété de styles et d'habillages.

Créateurs de la nouvelle bibliothèque d'interface utilisateur Se balancer n'a pas "réinventé la roue" et a choisi AWT comme base pour sa bibliothèque. Bien sûr, nous ne parlions pas de l'utilisation de composants AWT lourds spécifiques (représentés par les classes Button, Label et similaires). Seuls les composants légers offraient le degré requis de flexibilité et de contrôlabilité. Le diagramme d'héritage montre la relation entre AWT et Swing.

La différence la plus importante Se balancer d'AWT est que les composants Swing ne sont pas du tout connectés au système d'exploitation et sont donc beaucoup plus stables et plus rapides. De tels composants sont appelés légers en Java, et comprendre les principes de base de leur fonctionnement contribuera grandement à expliquer le fonctionnement de Swing.

Conteneurs pivotants de niveau supérieur

Pour créer une interface graphique pour une application, vous devez utiliser des composants spéciaux de la bibliothèque Swing, appelés conteneurs. haut niveau(conteneurs de niveau supérieur). Ce sont des fenêtres du système d'exploitation qui hébergent les composants de l'interface utilisateur. Les conteneurs de niveau supérieur incluent les fenêtres JFrame et JWindow, la boîte de dialogue JDialog et l'applet JApplet (qui n'est pas une fenêtre, mais est également destinée à afficher une interface dans le navigateur exécutant cette applet). Les conteneurs Swing de niveau supérieur sont des composants lourds et constituent une exception à la règle générale. Tous les autres composants Swing sont légers.

Simple Se balancer exemple d'interface de fenêtre jCadre.

Importer java.awt.Dimension ; importer javax.swing.JFrame ; importer javax.swing.JLabel ; public class JFrameTest ( public static void createGUI() ( JFrame frame = new JFrame("Test frame"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JLabel label = new JLabel("Test label"); frame.getContentPane(). add(label); frame.setPreferredSize(new Dimension(200, 100)); frame.pack(); frame.setVisible(true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); javax. swing.SwingUtilities.invokeLater(new Runnable() ( public void run() ( createGUI(); ) )); ) )

Constructeur JFrame() sans paramètres crée une fenêtre vide. Constructeur JFrame (titre de la chaîne) crée une fenêtre vide avec le titre titre. Créer le programme le plus simple avec une fenêtre vide, les méthodes suivantes doivent être utilisées :

• setSize(int width, int height) - définit la taille de la fenêtre ;
• setDefaultCloseOperation(int operation) - définition de l'action à la fin du programme ;
• setVisible(boolean visible) - rend la fenêtre visible.

Si vous ne définissez pas la taille de la fenêtre, elle aura une hauteur nulle, quel que soit son contenu. Les dimensions de la fenêtre incluent non seulement la zone "de travail", mais également les bordures et la barre de titre.

La méthode setDefaultCloseOperation définit l'action à effectuer lors de la "sortie du programme". Pour ce faire, passez la constante EXIT_ON_CLOSE, décrite dans la classe JFrame, comme paramètre d'opération.

Par défaut, la fenêtre est créée invisible. Pour afficher la fenêtre à l'écran, la méthode setVisible est appelée avec le paramètre true. Si vous l'appelez avec le paramètre false, la fenêtre deviendra invisible.

interface graphique balançoire java exemple de création de fenêtre jCadre montré dans la figure suivante.

Pour connecter la bibliothèque Se balancer l'application doit importer la bibliothèque javax.swing.

Chaque fois qu'un conteneur de niveau supérieur est créé, qu'il s'agisse d'une fenêtre normale, d'une boîte de dialogue ou d'une applet, le constructeur du conteneur crée Panneau racine JRootPane. Les conteneurs Swing de niveau supérieur garantissent que les autres composants ne peuvent pas "explorer" en dehors de JRootPane.

Racine pâle JRootPane ajoute une propriété "profondeur" aux conteneurs, offrant la possibilité non seulement de placer les composants les uns au-dessus des autres, mais aussi, si nécessaire, de les permuter, d'augmenter ou de diminuer la profondeur des composants. Cette fonctionnalité est nécessaire lors de la création d'une application multi-documents. Se balancer, dont les fenêtres représentent des composants légers empilés les uns sur les autres, ainsi que des menus déroulants (contextuels) et des info-bulles.

La figure suivante montre clairement la structure du panneau racine JRootPane.

Panneau racine JRootPane est un conteneur qui hérite de la classe de base Swing JComponent. Dans ce conteneur, un gestionnaire de disposition spécial, implémenté dans la classe interne RootPaneLayout, est responsable de la disposition des composants. Ce gestionnaire de mise en page est chargé de s'assurer que tous les composants du panneau racine sont placés comme il se doit : le panneau en couches occupe tout l'espace de la fenêtre ; son FRAME_CONTENT_LAYER contient la barre de menus et le panneau de contenu, et au-dessus de tout cela se trouve un panneau transparent.

Tous les composants du panneau racine JRootPane peuvent être obtenus ou modifiés. Il a un ensemble de méthodes get/set pour cela. Par programmation JRootPane peut être obtenu à l'aide de la méthode getRootPane().

En plus des conteneurs de niveau supérieur, le volet racine est utilisé dans les fenêtres JInternalFrame internes créées dans des applications multi-documents et situées sur le JDesktopPane "desktop". Cela vous permet d'oublier que ces fenêtres sont des composants légers ordinaires et de travailler avec eux comme s'il s'agissait de véritables conteneurs de niveau supérieur.

Panneau en couches JLayeredPane

A la base du panneau racine (conteneur) se trouve le soi-disant panneau en couches JLayeredPane occupe tout espace disponible récipient. C'est dans ce panneau que se trouvent toutes les autres parties du panneau racine, y compris tous les composants de l'interface utilisateur.

JLayeredPane utilisé pour ajouter une propriété de profondeur au conteneur. Autrement dit, le panneau multicouche vous permet d'organiser une troisième dimension dans le conteneur, le long de laquelle se trouvent les couches (couches) du composant. Dans un conteneur normal, l'emplacement d'un composant est déterminé par un rectangle qui indique la partie du conteneur occupée par le composant. Lors de l'ajout d'un composant à un panneau multicouche, vous devez spécifier non seulement le rectangle occupé par le composant, mais également le calque dans lequel il se trouvera. Un calque dans un panneau en couches est défini par un nombre entier. Plus le nombre définissant la couche est grand, plus la couche est élevée.

Le premier composant ajouté au conteneur est supérieur aux composants ajoutés ultérieurement. Le plus souvent, le développeur ne s'occupe pas des positions des composants. Lorsque vous ajoutez des composants, leur position change automatiquement. Cependant, le panneau en couches vous permet de modifier dynamiquement la position des composants, après leur ajout au conteneur.

Les capacités de panneau en couches sont largement utilisées par certains composants Se balancer. Ils sont particulièrement importants pour les applications multi-documents, les info-bulles et les menus. Multidocument Se balancer les applications utilisent un conteneur spécial JDesktopPane("bureau") hérité de JLayeredPane A qui contient les fenêtres Swing intérieures. Les fonctions les plus importantes d'une application multi-documents - positionner la fenêtre "active" au-dessus des autres, minimiser les fenêtres, les faire glisser - sont assurées par les mécanismes du panneau en couches. Le principal avantage de l'utilisation d'un panneau en couches pour les info-bulles et les menus est leur rapidité. Au lieu de créer une nouvelle fenêtre lourde pour chaque info-bulle ou menu, située au-dessus du composant dans lequel l'info-bulle ou le menu a été demandé, Se balancer crée un composant léger rapide. Ce composant est placé dans une couche suffisamment élevée du panneau en couches ci-dessus dans la pile de tous les autres composants et est utilisé pour afficher une info-bulle ou un menu.

Le panneau multicouche vous permet d'organiser un nombre illimité de couches. Structure JLayeredPane comprend plusieurs couches standard qui sont utilisées par tous les composants Swing, ce qui vous permet de fournir travail correct tous les mécanismes du panneau multicouche. Les couches JLayeredPane standard sont illustrées dans la figure suivante.

La couche par défaut est utilisée pour héberger tous composants conventionnels, qui sont ajoutés au conteneur. Cette couche contient les fenêtres internes des applications multi-documents.

La couche Palette est conçue pour héberger des fenêtres avec un ensemble d'outils, qui chevauchent généralement le reste de l'interface. Le panneau JDesktopPane permet de créer de telles fenêtres, qui les placent sur ce calque.

La couche modale était destinée à héberger des boîtes de dialogue modales légères. Cependant, ces boîtes de dialogue ne sont pas encore implémentées, donc cette couche n'est actuellement pas utilisée dans Swing.

La couche la plus couramment utilisée pour les menus contextuels et les info-bulles.

La couche supérieure. Destiné aux opérations de glisser-déposer ( glisser déposer drop), qui doit être clairement visible dans l'interface du programme.

Un petit exemple d'un JLayeredPane avec un panneau en couches montre comment ajouter des composants à différentes couches et comment les couches s'empilent les unes sur les autres :

Importer javax.swing.* ; import java.awt.*; // classe pour dessiner deux types de figures avec la classe de texte La figure étend JComponent ( private static final long serialVersionUID = 1L; private Couleur couleur; type int privé ; texte de chaîne privé ; // paramètres : couleur et type de figure Figure(Color color, int type, String text) ( this.color = color; this.type = type; this.text = text; setOpaque(false); ) public void paintComponent(Graphics g ) ( // dessinant la forme g.setColor(color); switch (type) ( case 0: g.fillOval(0, 0, 90, 90); break; case 1: g.fillRect(0, 0, 130, 80 ); break; ) g.setColor(Color.yellow); g.drawString(text, 10, 35); ) ) public class JLayeredPaneTest étend JFrame ( private static final long serialVersionUID = 1L; public JLayeredPaneTest() ( // créer une fenêtre super("Example LayeredTest"); // Quitte lorsque la fenêtre est fermée setDefaultCloseOperation(EXIT_ON_CLOSE); // Définit un panneau JLayeredPane en couches lp = getLayeredPane(); // Crée trois formes Figure figure1 = new Figure(Color.red , 0, "Figure popup"); Figure figure2 = new Figure(Color.blue, 0, "Figure 1"); Figure figure3 = new Figure(Color.cyan, 1, "Figure 2"); // localiser les formes dans la fenêtre figure1.setBounds (10, 40, 12 0,120); figure2.setBounds(60, 120, 160, 180); figure3.setBounds(90, 55, 250, 180); // ajout de formes à différents calques lp.add(figure1, JLayeredPane.POPUP_LAYER); lp.add(figure2, JLayeredPane.PALETTE_LAYER); lp.add(figure3, JLayeredPane.PALETTE_LAYER); // change la position d'un des chiffres lp.setPosition(figure3, 0); // détermination de la taille et ouverture de la fenêtre setSize(280, 250); setVisible(vrai); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new JLayeredPaneTest(); ) )

L'exemple crée une petite fenêtre jCadre et plusieurs composants Figure sont ajoutés au panneau en couches. Pour obtenir un panneau en couches dans n'importe quel conteneur Swing de niveau supérieur, appelez simplement la méthode getLayeredPane().

La classe d'assistance Figure hérite des propriétés de la classe de base JComponent et vous permet de dessiner deux types de formes (cercles et rectangles) avec des couleurs différentes. Les paramètres de dessin des formes sont définis dans le constructeur de classe.

Lors de la définition d'une interface, trois formes de couleurs différentes (deux cercles et un rectangle) sont créées. Le cercle est placé dans le calque POPUP_LAYER et les rectangles sont placés dans le calque PALETTE_LAYER. Lors du placement des composants, leurs coordonnées d'écran absolues sont spécifiées, car les gestionnaires d'emplacement habituels ne fonctionnent pas dans un panneau en couches.

À la fin, la position de l'un des rectangles est modifiée de sorte qu'il soit le premier du calque, bien qu'il ait été ajouté à l'origine au second. Lorsque vous exécutez l'application, vous verrez que le panneau en couches fonctionne et organise soigneusement les composants en fonction de leurs couches et de leurs positions.

À applications courantes le panneau multicouche est rarement utilisé directement, il remplit ses fonctions de manière imperceptible. Cependant, il est parfois utile de créer des effets étonnants et des interfaces inhabituelles, par exemple en vous permettant de placer une animation ou une vidéo sur des composants ordinaires sans nécessiter d'efforts et d'astuces surhumains de la part du développeur.

Volet contenu

Le ContentPane est la partie suivante du volet racine et est utilisé pour héberger les composants de l'interface utilisateur du programme. Volet contenu occupe la majeure partie de l'espace du panneau en couches (à l'exception de l'espace occupé par la barre de menus). Pour empêcher le panneau de contenu de couvrir les composants ajoutés ultérieurement à la fenêtre, le panneau en couches le place sur une couche spéciale très basse appelée FRAME_CONTENT_LAYER, numérotée -30000.

Vous pouvez accéder au panneau de contenu en utilisant getContentPane() Classe JFrame. En utilisant la méthode add(Component component), vous pouvez lui ajouter n'importe quel contrôle. Remplacer Volet contenu tout autre panneau de type JPanel, vous pouvez utiliser la méthode setContentPane()

Un exemple d'ajout d'un bouton au panneau de contenu :

JButton nouveauBouton = nouveau JBouton(); getContentPane().add(newButton);

En conséquence, nous obtenons une fenêtre avec un bouton. Le bouton occupe toute la surface disponible de la fenêtre. Cet effet n'est pas utile dans tous les programmes, vous devez donc utiliser différentes manières d'organiser les éléments sur le panneau.

Le panneau de contenu peut être complètement remplacé. Considérer ce qui suit Se balancer exemple de panneau de contenu Volet contenu.

Importer javax.swing.* ; public class ContentPaneReplace étend JFrame ( private static final long serialVersionUID = 1L; public ContentPaneReplace() ( super("Test ContentPane"); setDefaultCloseOperation(EXIT_ON_CLOSE); // Crée un panneau avec deux boutons JPanel contents = new JPanel(); contents. add (new JButton("Family"));contents.add(new JButton("School")); // Remplacement du volet de contenu setContentPane(contents); // Détermination de la taille de la fenêtre setSize(200, 100); // Ouverture de la fenêtre setVisible (true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new ContentPaneAdd(); ) )

L'exemple crée une petite fenêtre et un panneau avec deux boutons, qui est ensuite setContentPane() remplace le volet de contenu de la fenêtre. Ainsi, un remplacement a été utilisé au lieu d'un ajout plus simple - en appelant la méthode add (). L'interface de la fenêtre est illustrée dans la capture d'écran suivante.

Panneau de contenu Volet contenu en soi n'a rien de spécial. Il vous suffit de vous rappeler que les composants y sont ajoutés.

JOptionPane transparent

Panneau transparent JOptionPane placé comme panneau racine au-dessus de tous les éléments du panneau en couches. Le placement de JOptionPane est géré par le volet racine, qui place le volet transparent au-dessus du volet en couches afin qu'il couvre complètement toute la zone de la fenêtre, y compris la zone occupée par la barre de menus.

JOptionPane est rarement utilisé dans les applications, donc par défaut le panneau racine le rend invisible, ce qui réduit la charge sur le système de dessin. Gardez à l'esprit que si vous rendez visible un panneau transparent, vous devez vous assurer qu'il est transparent (sa propriété opaque est fausse), car sinon il couvrira tous les autres éléments du panneau racine, et le reste de l'interface sera invisible.

Dans quels cas peut-on utiliser un panneau transparent ? JOptionPane? Il peut être utilisé pour définir des fonctionnalités d'application qui nécessiteraient des efforts importants pour être implémentées à partir de zéro. Le panneau transparent peut être adapté pour les tests automatisés de l'interface utilisateur. Les événements qui y sont synthétisés vous permettent de suivre les résultats de débogage intermédiaires. Parfois, cette approche est beaucoup plus efficace que les tests manuels.

Panneau transparent JOptionPane peut être utilisé pour créer des animations fantaisistes qui "flottent" au-dessus de tous les composants, y compris la barre de menus, ou pour capturer des événements si certains d'entre eux doivent être traités avant d'être envoyés à l'interface utilisateur principale.

Un exemple d'utilisation d'un Swing JOptionPane transparent :

// Utilisation d'un JOptionPane transparent import java.awt.Dimension; importer java.awt.Font ; importer java.awt.event.WindowEvent ; import java.awt.event.WindowListener ; importer javax.swing.JDialog ; importer javax.swing.JFrame ; importer javax.swing.JLabel ; importer javax.swing.JOptionPane ; importer javax.swing.UIManager ; public class JOptionPaneTest étend JFrame ( private static final long serialVersionUID = 1L; public static final Font FONT = new Font("Verdana", Font.PLAIN, 11); public static void createGUI() ( JFrame frame = new JFrame("Test JOptionPane "); frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); frame.addWindowListener(new WindowListener() ( public void windowActivated(WindowEvent event) () public void windowClosed(WindowEvent event) () public void windowDeactivated(WindowEvent event) () public void windowDeiconified(WindowEvent event) () public void windowIconified(WindowEvent event) () public void windowOpened(WindowEvent event) () public void windowClosing(WindowEvent event) ( Object options = ( "Yes", "No!" ); int rc = JOptionPane.showOptionDialog(event.getWindow(), "Fermer la fenêtre ?", "Confirmer", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, options); (false);System.exit(0); ) ) )); JLabel label = new JLabel("Utiliser le panneau transparent lors de la fermeture de la fenêtre"); frame.getContentPane().add(label); frame.setPreferredSize(nouvelle dimension(350, 80)); frame.pack(); frame.setLocationRelativeTo(null); frame.setVisible(true); ) public static void main(String args) ( javax.swing.SwingUtilities.invokeLater(new Runnable() ( public void run() ( UIManager.put("Button.font", FONT); UIManager.put("Label.font ", POLICE); JFrame.setDefaultLookAndFeelDecorated(true); JDialog.setDefaultLookAndFeelDecorated(true); createGUI(); ) )); ) )

Si la méthode setDefaultCloseOperation reçoit une constante JFrame.EXIT_ON_CLOSE, puis lorsque la fenêtre est fermée, l'application cessera de fonctionner. Dans l'exemple, une constante est passée à cette méthode JFrame.DO_NOTHING_ON_CLOSE pour que rien ne se passe lorsque la fenêtre est fermée. La sortie de l'application dans l'exemple se fait à partir de l'écouteur JFrame WindowListener dans la méthode fenêtreFermeture. Lorsque la fenêtre est fermée, la méthode windowClosing est appelée avec un paramètre d'événement WindowEvent qui, dans un Swing JOptionPane transparent, ouvre une boîte de dialogue de confirmation.

La capture d'écran suivante montre deux fenêtres d'application. Fenêtre principale supérieure. La fermeture de cette fenêtre ouvre la boîte de dialogue de confirmation de l'intention inférieure.

JMenuBar Barre de menus

L'une des caractéristiques importantes de l'utilisation du volet racine de JRootPane dans Swing est la nécessité de placer une barre de menus dans la fenêtre. JMenuBar. Une application sérieuse ne peut pas être construite sans une sorte de menu pour accéder aux fonctions du programme. La bibliothèque Swing fournit d'excellentes fonctionnalités pour créer des JMenuBars pratiques qui sont également des composants légers.

Barre de menu JMenuBar placé dans un panneau en couches dans une couche spéciale FRAME_CONTENT_LAYER et occupe un petit espace en haut de la fenêtre. La longueur de la barre de menu est égale à la taille de la fenêtre. La largeur de la barre de menus dépend des composants qu'elle contient.

Le panneau racine s'assure que le panneau de contenu et la barre de menus JMenuBar ne se chevauchaient pas. Si la barre de menus n'est pas requise, le panneau racine utilise tout l'espace pour accueillir le panneau de contenu.

Exemples de balançoire

Les codes sources des exemples discutés dans le texte de la page peuvent être téléchargés.

Nous supposons que nous vous avons fatigué en parlant tout le temps de programmes d'inférence. des messages texteà la console. Dans cette leçon, cette "monstrueuse" série d'exemples sera enfin interrompue : nous montrerons comment les fenêtres sont créées en Java et vous verrez que c'est une tâche facile. Voici notre code (nous commencerons à en discuter dans la prochaine leçon, car il possède de très nombreuses fonctionnalités que vous devez vraiment connaître) :

import java.awt.*;

import javax.swing.*;

la classe publique MoneyForNothing étend JFrame(

// Constructeur

public ArgentPourRien() ()

setTitle("Bienvenue dans Money for Nothing");

setSize(nouvelle dimension(600, 400));

setDefaultCloseOperation(EXIT_ON_CLOSE);

setVisible(vrai);

public static void main(String args)(

MoneyForNothing mfn = new MoneyForNothing();

Et voici le même code dans la fenêtre d'édition FAR :

Au fait, nous vous recommandons de taper immédiatement les codes sources des programmes dans l'encodage CP1251 (ou dans le langage courant, dans l'encodage Windows): le changement d'encodage se fait en appuyant sur F8, et l'encodage actuel est affiché dans la barre d'état au-dessus la zone d'édition.

Le point d'entrée est resté inchangé, mais le reste du code a changé dans l'ordre (mais nous n'allons pas nous devancer). Après compilation et exécution, vous devriez voir ceci :

Félicitations, en quelques lignes vous avez créé une véritable fenêtre graphique ! Il peut être déplacé, redimensionné, réduit, développé et fermé. Certes, notre fenêtre s'est avérée en quelque sorte fanée, pour le dire franchement - «laide». De plus, la fenêtre est affichée dans le coin supérieur gauche de l'écran, mais j'aimerais qu'elle soit au centre - il est plus pratique de l'utiliser là-bas, et une telle sortie est plus agréable. Faisons donc un peu de "polissage".

Résolvons d'abord le deuxième problème - le centrage de la fenêtre. Ici, nous vous recommandons de vous arrêter et de réfléchir - comment feriez-vous ?

Disons que la bibliothèque graphique Java possède une méthode setLocation, qui reçoit en paramètre les coordonnées du coin supérieur gauche de la fenêtre (c'est à partir de ce coin que les autres éléments graphiques sont placés à l'intérieur de la fenêtre). Mais si vous définissez ces paramètres "sur le front", alors presque certainement rien de bon n'en sortira. sur un autre moniteur avec une résolution différente, la fenêtre ne sera pas là où vous vous attendiez. Par conséquent, les coordonnées doivent être définies plus intelligemment.

Tout ce qui est nécessaire pour centrer la fenêtre est de connaître la taille de la fenêtre elle-même (d'ailleurs, elles sont définies dans le constructeur et forment un rectangle de 600 par 400 pixels) et la résolution de l'écran, puis, en utilisant une arithmétique simple , calculez les coordonnées nécessaires du coin supérieur gauche. Ceci est réalisé en plaçant le code suivant

Dimension sSize = Toolkit.getDefaultToolkit().getScreenSize(),

fTaille = obtenirTaille();

if (fSize.height > sSize.height) (fSize.height = sSize.height;)

if (fSize.width > sSize.width) (fSize.width = sSize.width;)

setLocation((sSize.width - fSize.width)/2,

(sTaille.hauteur - fTaille.hauteur)/2);

immédiatement après la ligne setSize (new Dimension (600, 400)); dans le constructeur. Apportez les modifications nécessaires au code source, compilez le programme et exécutez-le pour l'exécution ; la fenêtre doit apparaître au centre de l'écran du moniteur.

Maintenant, quelques mots sur l'apparence de la fenêtre. Son aspect étrange s'explique par le fait que les développeurs Java ont cherché à faire en sorte que, quelle que soit la plate-forme matérielle et le "bourrage" logiciel, tous les éléments graphiques (fenêtres, boutons, listes, etc.) aient un seul rendu et un seul schéma de couleurs. Pour ce faire, ils ont développé un style spécial, qu'ils ont appelé "METAL". Si le développeur ne prend pas efforts particuliers, les éléments de l'interface graphique de ses programmes ressembleront exactement à ce style, sans tenir compte des caractéristiques d'ordinateurs spécifiques et de leur Logiciel. Dans certains cas, cela a du sens, mais vous devez quand même convenir qu'il est bien préférable qu'un programme exécuté sous Windows ressemble à un programme Windows et qu'il s'exécute sous LINUX ressemble à un programme Linux. C'est facile à réaliser. Il suffit d'inclure le code suivant dans le point d'entrée, avant de créer une instance de la classe :

essayez(UIManager.setLookAndFeel

(UIManager.getSystemLookAndFeelClassName());

catch(Exceptionnel)()

C'est ainsi que nous procéderons. Maintenant, après avoir compilé la version mise à jour de notre programme et l'avoir exécutée pour l'exécution, la fenêtre graphique aura l'air bien "décente":

Selon le réglage des propriétés d'affichage de votre moniteur, l'affichage de la fenêtre sera différent ; nous utilisons le classique Thème Windows XP. Votre fenêtre pourrait ressembler à ceci :

Assurez-vous que tout fonctionne comme prévu : la fenêtre s'affiche au centre de l'écran et son aspect est comme prévu.

Ceci conclut notre première leçon sur les interfaces graphiques. Dans celui-ci, nous avons montré la "façade", mais complètement laissé "par-dessus bord" beaucoup de problèmes qui sont extrêmement importants et sans lesquels la programmation en Java en général et les interfaces graphiques en particulier est impossible. Nous commencerons à traiter ces problèmes dans la prochaine leçon, mais pour l'instant, jouez avec le code source que vous avez.

En guise d'exercice, calculez, par exemple, les coordonnées de la sortie de notre fenêtre dans le coin inférieur droit de l'écran et vérifiez le résultat.

Un autre exercice est plus simple, mais vous devrez utiliser la documentation (il faut vraiment commencer quelque part) : faites en sorte que vous ne puissiez pas redimensionner la fenêtre, c'est-à-dire à la zone boutons système ressemblait à la photo

(indice : recherchez des informations sur mots clés javax et JFrame). Alors retroussez vos manches et bonne chance !

Commentaire

Il peut arriver que la fenêtre générée soit totalement ou partiellement invisible (du fait que vous avez mal calculé les coordonnées de son affichage à l'écran). Les boutons de contrôle de la fenêtre peuvent également être indisponibles. Comment interrompre l'application sans supprimer la tâche dans le "Gestionnaire des tâches" ou redémarrer l'ordinateur ?

Étant donné que nous lançons des programmes à exécuter à partir de FAR, l'interruption de l'exécution d'un programme Java se fait en appuyant sur la combinaison de touches Control-C (ici "C" est une lettre latine, ne la confondez pas avec une lettre cyrillique similaire).