Menu

Tutoriel Java SWING: Conteneur, composants et gestion des événements

  • Principal
  • Autre
  • Tutoriel Java SWING: Conteneur, composants et gestion des événements

java swing tutorial container

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel vidéo complet sur Java Swing explique divers composants de l'interface graphique Swing Framework et des concepts associés tels que JPanel, JFrame, JButton, etc.:

Nous utilisons des interfaces utilisateur graphiques (communément appelées GUI) pour créer des applications qui ont une interface visuelle en facilitant l'utilisation de l'application par l'utilisateur.

Avoir une interface visuelle pour une application facilite la navigation dans l'application, utilise les contrôles plus efficacement et est également attrayant visuellement pour l'utilisateur.

Swing est principalement utilisé pour créer l'interface graphique pour les applications.

=> Visitez ici pour voir la série de formations Java pour tous.

Java SWING

Ce que vous apprendrez:

Tutoriel vidéo sur Java Swing

Qu'est-ce que Java Swing

Java fournit de nombreux frameworks GUI qui nous aident à développer une variété d'applications GUI. Nous en avons vu un dans notre tutoriel précédent, c'est-à-dire Abstract Window Toolkit ou AWT. AWT est l'un des plus anciens frameworks d'interface graphique de Java et dépend également de la plate-forme. Un autre inconvénient d'AWT est ses composants lourds.

Dans ce didacticiel, nous discuterons encore d'un autre cadre d'interface graphique en Java, à savoir «SWING». Le framework Swing en Java fait partie des classes Java Foundation ou communément appelées JFC. JFC est une API similaire aux MFC (Microsoft Foundation Classes) en C ++. JFC contient Swing, AWT et Java2D.

Le framework Swing en Java est construit sur le framework AWT et peut être utilisé pour créer des applications GUI tout comme AWT. Mais contrairement à AWT, les composants Swing sont légers et indépendants de la plate-forme.

Le framework Swing est entièrement écrit en Java. Le framework Swing en Java est fourni via le package «javax.swing». Les classes du package javax.swing commencent par la lettre «J». Donc, dans un package javax.swing, nous aurons des classes comme JButton, JFrame, JTextField, JTextArea, etc.

En général, l'API Swing a tous les contrôles définis dans le package javax.swing qui est présent dans AWT. Ainsi, le swing agit en quelque sorte comme un remplacement d'AWT. En outre, Swing dispose de divers volets à onglets de composants avancés. L'API Swing en Java adapte l'architecture MVC (Model View Controller).

Les principales caractéristiques de cette architecture sont:

  • Les données du composant swing sont représentées à l'aide de Model.
  • Il est représenté visuellement à l'aide d'une vue.
  • Le composant contrôleur de l'architecture MVC lit les entrées de l'utilisateur sur la vue, puis ces modifications sont transmises aux données du composant.
  • Dans chaque composant Swing, la vue et le contrôleur sont assemblés tandis que le modèle est séparé. Cela donne à la balançoire un aspect et une sensation enfichables.

Les fonctionnalités de l'API swing sont résumées ci-dessous.

  1. Les composants Swing sont indépendants de la plate-forme.
  2. L'API est extensible.
  3. Les composants Swing sont légers. Les composants swing sont écrits en Java pur et les composants sont également rendus à l'aide de code Java au lieu d'appels système sous-jacents.
  4. L'API Swing fournit un ensemble de contrôles avancés tels que TabbedPane, Tree, Colorpicker, des contrôles de table, etc. qui sont riches en fonctionnalités.
  5. Les commandes de swing sont hautement personnalisables. En effet, l'apparence ou l'aspect et la convivialité du composant sont indépendants de la représentation interne et nous pouvons donc le personnaliser comme nous le souhaitons.
  6. Nous pouvons simplement modifier les valeurs et ainsi modifier l'apparence au moment de l'exécution.

Composants Java Swing

Swing a un grand ensemble de composants que nous pouvons inclure dans nos programmes et profiter des riches fonctionnalités à l'aide desquelles nous pouvons développer des applications GUI hautement personnalisées et efficaces.

Alors, qu'est-ce qu'un composant?

Un composant peut être défini comme un contrôle qui peut être représenté visuellement et qui est généralement indépendant. Il a une fonctionnalité spécifique et est représenté comme une classe individuelle dans l'API Swing.

Par exemple, La classe JButton dans l'API swing est un composant de bouton et fournit la fonctionnalité d'un bouton.

Un ou plusieurs composants forment un groupe et ce groupe peut être placé dans un «Conteneur». Un conteneur fournit un espace dans lequel nous pouvons afficher les composants et également gérer leur espacement, leur disposition, etc.

En Java, les conteneurs sont divisés en deux types, comme indiqué ci-dessous:

Types de conteneurs

Cours Swing en Java

Une hiérarchie d'API Swing en Java est présentée ci-dessous:

Introduction aux classes Swing

Comme le montre la hiérarchie ci-dessus, nous avons des classes Container - frame, dialog, Panel, Applet, etc. Il existe également des classes Component dérivées de la classe JComponent de l'API Swing. Certaines des classes qui héritent de JComponent sont JLabel, JList, JTextBox, etc.

Certaines des classes importantes de l'API Swing sont les suivantes:

  • JWindow: La classe JWindow de Swing hérite directement de la classe Window. La classe JWindow utilise «BorderLayout» comme disposition par défaut.
  • JPanel: JPanel est un descendant de la classe JComponent et est sur des lignes similaires à la classe AWT Panel et a «FlowLayout» comme disposition par défaut.
  • JFrame: JFrame descend de la classe Frame. Les composants ajoutés au cadre sont appelés contenu du cadre.
  • JLabel: La classe JLabel est une sous-classe du JComponent. Il est utilisé pour créer des étiquettes de texte dans l'application.
  • JButton: La fonctionnalité de bouton-poussoir dans Swing est fournie par JButton. Nous pouvons associer une chaîne, une icône ou les deux à l'objet JButton.
  • JTextField: La classe JTextField fournit un champ de texte dans lequel nous pouvons éditer une seule ligne de texte.

JFrame en Java

Un cadre, en général, est un conteneur qui peut contenir d'autres composants tels que des boutons, des étiquettes, des champs de texte, etc. Une fenêtre Frame peut contenir un titre, une bordure, ainsi que des menus, des champs de texte, des boutons et d'autres composants. Une application doit contenir un cadre afin que nous puissions y ajouter des composants.

Le cadre dans Java Swing est défini dans la classe javax.swing.JFrame. La classe JFrame hérite de la classe java.awt.Frame. JFrame est comme la fenêtre principale de l'application GUI utilisant swing.

Nous pouvons créer un objet de fenêtre JFrame en utilisant deux approches:

meilleur logiciel pour optimiser Windows 10

# 1) En étendant la classe JFrame

La première approche consiste à créer une nouvelle classe pour construire un Frame. Cette classe hérite de la classe JFrame du package javax.swing.

Le programme suivant met en œuvre cette approche.

import javax.swing.*; class FrameInherited extends JFrame{ //inherit from JFrame class JFrame f; FrameInherited(){ JButton b=new JButton('JFrame_Button');//create button object b.setBounds(100,50,150, 40); add(b);//add button on frame setSize(300,200); setLayout(null); setVisible(true); } } public class Main { public static void main(String() args) { new FrameInherited(); //create an object of FrameInherited class } }

Production:

En étendant la classe JFrame

# 2) En instanciant la classe JFrame

import javax.swing.*; public class Main { public static void main(String() args) { JFrame f=new JFrame('JFrameInstanceExample');//create a JFrame object JButton b=new JButton('JFrameButton');//create instance of JButton b.setBounds(100,50,150, 40);//dimensions of JButton object f.add(b);//add button in JFrame f.setSize(300,200);//set frame width = 300 and height = 200 f.setLayout(null);//no layout manager specified f.setVisible(true);//make the frame visible } }

Production:

En instanciant la classe JFrame

Dans le programme ci-dessus, nous avons créé un cadre à partir de la classe JFrame en créant une instance de la classe JFrame.

JPanel en Java

Un panneau est un composant contenu dans une fenêtre cadre. Un cadre peut contenir plus d'un composant de panneau à l'intérieur, chaque composant de panneau ayant plusieurs autres composants.

En termes plus simples, nous pouvons utiliser des panneaux pour cloisonner le cadre. Chaque panneau regroupe plusieurs autres composants à l'intérieur. En d'autres termes, nous utilisons des panneaux pour organiser les composants à l'intérieur du cadre.

La classe d'API swing qui implémente le composant de panneau est JPanel. La classe JPanel hérite de JComponent et a FlowLayout comme disposition par défaut.

Le programme suivant montre la création d'un conteneur de panneaux dans un cadre à l'aide des classes de package javax.swing.

import javax.swing.*; class JPanelExample { JPanelExample(){ JFrame frame = new JFrame('Panel Example'); //create a frame JPanel panel = new JPanel(); //Create JPanel Object panel.setBounds(40,70,100,100); //set dimensions for Panel JButton b = new JButton('ButtonInPanel'); //create JButton object b.setBounds(60,50,80,40); //set dimensions for button panel.add(b); //add button to the panel frame.add(panel); //add panel to frame frame.setSize(400,400); frame.setLayout(null); frame.setVisible(true); } } public class Main { public static void main(String() args) { new JPanelExample(); //create an object of FrameInherited class } }

Production:

JPanel en Java

Ici, nous avons un cadre. À l'intérieur du cadre, nous créons un panneau. Puis à l'intérieur du panneau, nous créons un bouton. De cette façon, nous pouvons utiliser un panneau pour contenir les autres composants.

JTextArea en Java

TextArea définit un champ de texte modifiable. Il peut avoir plusieurs lignes. La classe swing qui définit la zone de texte est JTextArea et elle hérite de la classe JTextComponent.

classe publique JTextArea étend JTextComponent

La classe JTextArea contient 4 constructeurs qui nous permettent de créer une zone de texte avec diverses options.

  • JTextArea (): Constructeur par défaut. Créez une zone de texte vide.
  • JTextArea (chaînes): Crée une zone de texte avec s comme valeur par défaut.
  • JTextArea (ligne int, colonne int): Crée une zone de texte avec une ligne x colonne spécifiée.
  • JTextArea (chaîne s, ligne int, colonne int): Crée un texte are2a avec la ligne x colonne spécifiée et la valeur par défaut s.

Le programme Java suivant montre un exemple du composant JTextArea dans le swing.

import javax.swing.*; class JTextAreaExample { JTextAreaExample(){ JFrame frame= new JFrame(); JTextArea t_area=new JTextArea('JTextArea example'); //create object of JTextArea t_area.setBounds(10,30, 150,100); //set its dimensions frame.add(t_area); //add it to the frame frame.setSize(200,200); frame.setLayout(null); frame.setVisible(true); } } public class Main { public static void main(String() args) { new JTextAreaExample(); //create an object of TextAreaExample class } }

Production:

JTextArea en Java

JButton en Java

Un bouton est un composant utilisé pour créer un bouton poussoir avec un nom ou une étiquette dessus. Dans swing, la classe qui crée un bouton étiqueté est JButton. JButton hérite de la classe AbstractButton. Nous pouvons associer l'événement ActionListener au bouton pour qu'il effectue une action lorsqu'il est poussé.

Implémentons un exemple de programme pour JButton dans les balançoires Java.

import javax.swing.*; public class Main { public static void main(String() args) { JFrame frame=new JFrame('JButton Example'); //create JFrame object JButton button=new JButton('Button'); //Create a JButton object button.setBounds(50,50,75,35); //set dimensions for button frame.add(button); //add button to the frame frame.setSize(250,200); frame.setLayout(null); frame.setVisible(true); } }

Production:

JButton en Java

JList en Java

Une liste se compose de plusieurs éléments de texte. Les utilisateurs peuvent sélectionner un seul élément ou plusieurs éléments à la fois. La classe qui implémente la liste dans l'API swing est JList. JList est un descendant de la classe JComponent.

Vous trouverez ci-dessous les constructeurs de la classe JList.

  • JList (): Constructeur par défaut qui crée une liste vide en lecture seule.
  • JList (array () listItem): Créez une JList qui contient initialement des éléments du tableau listItem.
  • JList (ListModel dataModel): Crée une liste avec des éléments du modèle dataModel spécifié.

Une simple démonstration du composant JList est donnée ci-dessous.

import javax.swing.*; public class Main { public static void main(String() args) { JFrame frame= new JFrame('JList Example'); //create a list model and add items to it DefaultListModel colors = new DefaultListModel<>(); colors.addElement('Red'); colors.addElement('Green'); colors.addElement('Blue'); //create JList object and add listModel to it JList colorsList = new JList<>(colors); colorsList.setBounds(100,100, 75,50); frame.add(colorsList); //add list to the frame frame.setSize(400,400); frame.setLayout(null); frame.setVisible(true); } }

Production:

JList en Java

Dans le programme ci-dessus, nous définissons d'abord un listModel avec des entrées de couleur. Ensuite, nous créons un objet JList et y ajoutons le listModel. Ensuite, l'objet JList est ajouté à l'objet frame qui est ensuite affiché.

JComboBox en Java

La classe JCombobox affiche une liste de choix à partir de laquelle un utilisateur peut sélectionner une option. Le choix sélectionné est en haut. JComboBox dérive de la classe JComponent.

Voici les constructeurs fournis par la classe JComboBox:

  • JComboBox (): Constructeur par défaut qui crée un ComboBox avec le modèle de données par défaut.
  • JComboBox (objets () éléments): Ce constructeur crée un ComboBox contenant des éléments comme éléments des éléments de tableau donnés.
  • JComboBox (éléments vectoriels): Ce constructeur lit les éléments du vecteur donné et construit un ComboBox avec ces éléments comme éléments.

La classe JComboBox fournit également des méthodes pour ajouter / supprimer des éléments, ajouter ActionListener, ItemListener, etc.

L'exemple suivant illustre l'implémentation de JComboBox en Java.

import javax.swing.*; class ComboBoxExample { JFrame frame; ComboBoxExample(){ frame=new JFrame('ComboBox Example'); //create a string array String country()={'India','SriLanka','Singapore','Maldives','SeyChelles'}; //create a combobox object with given string array JComboBox countries=new JComboBox(country); countries.setBounds(50, 50,90,20); frame.add(countries); //add it to the frame frame.setLayout(null); frame.setSize(200,300); frame.setVisible(true); } } public class Main { public static void main(String arg()) { new ComboBoxExample(); } }

Production:

comment faire un faux email

Implémentation JComboBox

JSlider en Java

Un curseur nous permet de sélectionner une plage de valeurs spécifique. Dans l'API Java Swing, JSlider est la classe utilisée pour implémenter le curseur.

Voici les constructeurs fournis par la classe JSlider.

  • JSlider (): Un constructeur par défaut qui crée un curseur ayant 50 comme valeur initiale et une plage de 0 à 100.
  • JSlider (orientation int): ce constructeur crée un curseur comme ci-dessus mais avec une orientation spécifiée. La valeur d'orientation peut être JSlider.HORIZONTAL ou JSlider.VERTICAL.
  • JSlider (int min, int max): Ce constructeur est utilisé pour créer un curseur horizontal en utilisant les min et max donnés.
  • JSlider (int min, int max, int value): ce constructeur crée un curseur horizontal avec la valeur spécifiée min, max et value.
  • JSlider (int orientation, int min, int max, int value): ce constructeur construit un curseur avec l'orientation, min, max et valeur spécifiés.

Le programme suivant montre le JSlider en Java avec des graduations. Ce programme montre également l'utilisation des méthodes prises en charge par la classe JSlider.

import javax.swing.*; class SliderExample extends JFrame { public SliderExample() { //create a slider object JSlider slider = new JSlider(JSlider.HORIZONTAL, 0, 50, 25); //set major and minor ticks for the slider slider.setMinorTickSpacing(2); slider.setMajorTickSpacing(10); slider.setPaintTicks(true); slider.setPaintLabels(true); JPanel panel = new JPanel(); panel.add(slider); //add slider to the panel add(panel); } } public class Main{ public static void main(String s()) { SliderExample frame=new SliderExample(); frame.pack(); frame.setVisible(true); } }

Production:

JSlider en Java

Gestion des événements en Java

Un événement peut être défini comme un changement d'état d'un objet. Du point de vue de l'interface graphique, un événement se produit lorsque l'utilisateur final interagit avec les composants de l'interface graphique. Les événements qui sont déclenchés dans l'interface graphique peuvent être le clic d'un bouton, le défilement, la sélection d'éléments de liste, la modification de texte, etc.

Les événements survenant dans l'interface graphique ci-dessus sont principalement des événements de premier plan. Nous pouvons également avoir des événements en arrière-plan tels que l'achèvement des opérations en arrière-plan, l'expiration du minuteur, etc.

La gestion des événements est un mécanisme par lequel une action est entreprise lorsqu'un événement se produit. Pour cela, nous définissons une méthode qui est également appelée gestionnaire d'événements qui est appelée lorsqu'un événement se produit. Java utilise un mécanisme standard appelé «modèle d'événement de délégation» pour générer et gérer les événements.

Le modèle d'événement de délégation comprend:

# 1) Source: La source de l'événement est l'objet. L'objet sur lequel un événement se produit est la source et la source est responsable de l'envoi des informations sur l'événement au gestionnaire d'événements.

# 2) Auditeur: L'écouteur n'est rien d'autre que le gestionnaire d'événements chargé d'effectuer une action lorsqu'un événement se produit. En Java, un écouteur est un objet qui attend un événement. Une fois que l'événement se produit, l'auditeur traite l'événement.

La condition requise est d'enregistrer l'écouteur auprès de l'objet afin que lorsqu'un événement se produit, l'écouteur puisse le traiter.

Par exemple,pour un événement de clic de bouton, nous pouvons avoir la séquence d'étapes suivante.

  1. L'utilisateur clique sur le bouton qui génère un événement Click.
  2. L'objet de classe d'événements approprié est créé et les données source et d'événement sont transmises à cet objet.
  3. Cet objet événement est ensuite passé à la classe d'écouteur enregistrée avec l'objet.
  4. L'auditeur s'exécute et retourne.

Voyons maintenant quelques-uns des écouteurs fournis par Java.

ActionListener en Java

Un actionListener est l'écouteur d'un bouton ou d'un élément de menu. Lorsque nous cliquons sur un bouton, le bouton Listener concerné est l'actionListener. ActionListener est notifié dans ActionEvent.

Le package d'événements java.awt.an définit l'interface ActionListener. Cette interface n'a qu'une seule méthode actionPerformed ().

public abstract void actionPerformed (ActionEvent e);

Lorsqu'un composant enregistré comme un Button est cliqué, la méthode actionPerformed () est automatiquement appelée.

L'approche la plus courante pour inclure ActionListener dans le programme consiste à implémenter l'interface ActionListener, puis à implémenter la méthode actionPerformed ().

Les étapes pour implémenter la classe ActionListener sont les suivantes:

# 1) Implémentez l'interface ActionListerner.

Classe publique ActionListenerImpl Implémente ActionListener

# 2) Enregistrez le composant avec cet écouteur. Si le bouton est un composant que nous voulons enregistrer auprès de l'auditeur, nous l'enregistrerons comme suit:

button.addActionListener (instanceOfListenerclass);

# 3) Implémentez / remplacez la méthode actionPerformed ().

public void actionPerformed (ActionEvent e){ //code to perform action }

Ainsi, en utilisant les étapes ci-dessus, nous pouvons associer n'importe quel événement au composant GUI.

L'exemple suivant illustre un événement Click de bouton à l'aide d'ActionListener.

import javax.swing.*; import java.awt.event.*; public class Main { public static void main(String() args) { JFrame frame=new JFrame('Button Click Example'); final JTextField text_field=new JTextField(); //JTextField object text_field.setBounds(50,100, 150,20); JButton click_button=new JButton('Click Me!!!'); //JButton object click_button.setBounds(20,50,75,30); click_button.addActionListener(new ActionListener(){ //add an event and take action public void actionPerformed(ActionEvent e){ text_field.setText('You Clicked the button'); } }); //add button and textfield to the frame frame.add(click_button);frame.add(text_field); frame.setSize(400,400); frame.setLayout(null); frame.setVisible(true); } }

Production:

ActionListener en Java

Le programme ci-dessus implémente un événement ActionListener. L'événement est l'événement Click Button et avec lui, nous avons associé un ActionListener qui affiche le texte dans le champ de texte en cliquant sur le bouton.

KeyListener en Java

Chaque fois qu'il y a un changement dans l'état de la clé, un KeyListener est notifié. Tout comme ActionListener, le KeyListener se trouve également dans le package java.awt.event.

L'interface KeyListener fournit les méthodes suivantes:

public abstract void keyPressed (KeyEvent e);

public abstract void keyReleased (KeyEvent e);

public abstract void keyTyped (KeyEvent e);

Nous devons implémenter les méthodes ci-dessus pour associer les événements clés au composant. Nous laissons à l'utilisateur le soin d'implémenter un exemple KeyListener en utilisant des swings en Java.

Swing Layouts en Java

Lorsque nous organisons divers composants dans un conteneur, nous disons que nous disposons ces composants. Ainsi, une mise en page peut être définie comme le positionnement de composants dans un conteneur.

Tant qu'il y a moins de composants, ils peuvent être placés manuellement par glisser-déposer. Mais il devient difficile de disposer les composants en grand nombre. À ce stade, le Layout Manager de Java vient à notre aide.

LayoutManager est responsable de la disposition des composants dans les applications GUI. LayoutManager est une interface et il est implémenté par toutes les classes du gestionnaire de disposition. Java fournit les classes LayoutManager suivantes.

LayoutManagerLa description
javax.swing.GroupLayoutRegroupe les composants puis les positionne dans le conteneur.
java.awt.BorderLayoutLes composants sont disposés pour s'adapter dans cinq directions à savoir le centre, l'est, l'ouest, le sud et le nord.
java.awt.FlowLayoutC'est la mise en page par défaut. Il place les composants dans le flux directionnel.
java.awt.GridLayoutOrganise les composants dans une grille rectangulaire.
javax.swing.BoxLayoutLes composants sont disposés dans une boîte.
java.awt.CardLayoutChaque composant est considéré comme une carte dans un jeu et à la fois, un seul composant est visible.
java.awt.GridBagLayoutRéorganise les composants verticalement, horizontalement ou même le long de leurs lignes de base. Les composants ne doivent pas nécessairement être de la même taille.
javax.swing.ScrollPaneLayoutUtilisé par la classe JScrollPane et est responsable de l'organisation des composants dans des conteneurs à défilement.
javax.swing.SpringLayout etc.Un ensemble de contraintes telles que la distance horizontale et verticale entre les composants, etc. est fourni et les composants sont agencés selon cet ensemble de contraintes.

Dans ce didacticiel, nous aborderons uniquement FlowLayout et GridLayout.

FlowLayout en Java

Le FlowLayout organise les composants dans une direction d'écoulement, l'un après l'autre. Il s'agit de la disposition par défaut pour les conteneurs tels que Panel et Applet.

La classe FlowLayout en Java qui représente le gestionnaire FlowLayout contient les champs et les constructeurs suivants.

Champs de la classe FlowLayout

  • public static final int LEADING
  • public static final int TRAILING
  • public static final int LEFT
  • public static final int DROIT
  • public static final int CENTRE

Les champs ci-dessus définissent les positions auxquelles les composants seront placés ou alignés.

Constructeurs de la classe FlowLayout

  • FlowLayout (): Il s'agit d'un constructeur par défaut. Ce constructeur crée une disposition de flux ayant des composants alignés au centre avec un espace par défaut de 5 unités dans la direction horizontale et verticale.
  • FlowLayout (alignement int): Ce constructeur crée une disposition de flux avec la valeur d'alignement spécifiée et avec un espace horizontal et vertical de 5 unités.
  • FlowLayout (int align, int hgap, int vgap): Crée une disposition de flux avec une valeur d'alignement et un espace horizontal et vertical spécifiés.

Ci-dessous, un exemple de FlowLayout en Java.

import javax.swing.*; import java.awt.*; class FlowLayoutClass { JFrame frame; FlowLayoutClass() { frame = new JFrame('FlowLayout Example'); //create button components JButton b1 = new JButton('A'); JButton b2 = new JButton('B'); JButton b3 = new JButton('C'); JButton b4 = new JButton('D'); JButton b5 = new JButton('E'); //add components to the frame frame.add(b1); frame.add(b2); frame.add(b3); frame.add(b4); frame.add(b5); //set layout as 'FlowLayout.CENTER' frame.setLayout(new FlowLayout(FlowLayout.CENTER)); //setting flow layout of right alignment frame.setSize(300, 300); frame.setVisible(true); } } public class Main{ public static void main(String() args) { new FlowLayoutClass(); } }

Production:

Constructeurs de la classe FlowLayout

GridLayout en Java

En utilisant GridLayout, nous pouvons disposer les composants dans une grille rectangulaire, c'est-à-dire que chaque composant est disposé dans chaque rectangle.

Constructeurs de la classe GridLayout

  1. Disposition de la grille (): constructeur par défaut qui génère une disposition de grille ayant une colonne pour un composant dans une ligne.
  2. GridLayout (int rows, int columns): ce constructeur génère une disposition de grille avec des lignes et des colonnes spécifiées. Il n'y a pas d'écart entre les composants.
  3. GridLayout (int rows, int columns, int hgap, int vgap): en utilisant ce constructeur, nous générons une disposition de grille avec des lignes et des colonnes spécifiées et des espaces horizontaux et verticaux.

L'exemple suivant implémente le GridLayout en Java.

import javax.swing.*; import java.awt.*; class GridLayoutClass { JFrame frame; GridLayoutClass() { frame=new JFrame('GridLayout Example'); //create components to be laid out as per GridLayout JButton b1=new JButton('P'); JButton b2=new JButton('Q'); JButton b3=new JButton('R'); JButton b4=new JButton('S'); JButton b5=new JButton('T'); JButton b6=new JButton('U'); JButton b7=new JButton('V'); JButton b8=new JButton('W'); JButton b9=new JButton('X'); //add components to the frame frame.add(b1);frame.add(b2);frame.add(b3);frame.add(b4);frame.add(b5); frame.add(b6);frame.add(b7);frame.add(b8);frame.add(b9); //set frame layout to GridLayout of 3 rows and 3 columns frame.setLayout(new GridLayout(3,3)); frame.setSize(300,300); frame.setVisible(true); } } public class Main{ public static void main(String() args) { new GridLayoutClass(); } }

Production:

GridLayout en Java

Setbounds en Java

Si nous vérifions les exemples de programmation dans ce didacticiel avant la rubrique de mise en page, nous pouvons voir que nous avons défini la mise en page comme null dans ces exemples (setLayout (null)). Nous avons vu que lorsque nous utilisons des gestionnaires de disposition dans notre programme, ils positionnent automatiquement les composants.

Lorsque les gestionnaires de disposition ne sont pas utilisés, nous pouvons utiliser la méthode setBounds pour la taille et la position du composant. Ainsi, la méthode setBounds est utilisée pour positionner manuellement le composant et également définir la taille.

La syntaxe générale de la méthode setBounds est la suivante:

setBounds (int coordonnée x, int y - coordonnée, largeur int, hauteur int)

Implémentons maintenant un exemple de la méthode SetBounds.

import javax.swing.*; public class Main { public static void main(String arg()) { JFrame frame = new JFrame('SetBounds Method Test'); frame.setSize(375, 250); // Set layout as null frame.setLayout(null); // Create a Button JButton button = new JButton('ButtonWithSetBounds'); // Set position and size of a button using setBounds button.setBounds(80,30,200,40); frame.add(button); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setLocationRelativeTo(null); frame.setVisible(true); } }

Production:

différence entre l'assurance qualité et le contrôle qualité

Setbounds en Java

Dans le programme ci-dessus, nous avons un composant Button. Nous n'avons défini aucune disposition mais nous avons utilisé la méthode setBounds pour définir sa position et ses dimensions.

Swing contre JavaFX

BalançoireJavaFX
Swing fournit une API pour créer des composants GUI.JavaFX fournit des scripts et un développement rapide de l'interface utilisateur associés au générateur d'écran.
Il n'y aura pas de nouvelle fonctionnalité ajoutée à Swing dans les versions futures.JavaFX fournit des fonctionnalités riches et a le potentiel pour plus de fonctionnalités dans les versions futures.
Nous pouvons créer tous les composants standard à l'aide de l'API Swing.JavaFX nous permet de créer des composants GUI riches en utilisant une apparence et une convivialité avancées.
Un grand nombre de composants sont présents dans Swing.JavaFX a un nombre comparativement moindre de composants.
Swing est une bibliothèque d'interface utilisateur entièrement équipée.JavaFX est une API nouvelle et à venir avec des composants d'interface utilisateur riches.
Swing a un support MVC lâche.JavaFX prend en charge le modèle MVC de manière cohérente.

Questions fréquemment posées

Q # 1) Swing est-il toujours utilisé en Java?

Répondre: Oui, Swing est toujours utilisé en Java et cela trop fortement. Parfois, il est utilisé comme un remplacement complet pour AWT. Parfois, il est également utilisé avec certains des composants AWT. Il est même utilisé avec le dernier JavaFX. Donc Swing est toujours utilisé et sera utilisé pendant longtemps.

Q # 2) Comment fonctionne Java Swing?

Répondre: Swing in Java est écrit au-dessus du framework AWT. Ainsi, la gestion des événements d'AWT est héritée complètement par swing. Swing fournit également un grand nombre de composants que nous pouvons utiliser pour développer des applications GUI efficaces.

Q # 3) Swing suit-il MVC?

Répondre: L'API Swing a un support MVC lâche. Le modèle représente les données du composant. Le composant swing a un élément séparé appelé modèle tandis que le contrôleur et la vue sont regroupés dans les éléments de l'interface utilisateur. Ce clubbing permet à la balançoire d'avoir un aspect et une sensation enfichables.

Q # 4) JavaFX est-il meilleur que Swing?

Répondre: Swing existe depuis longtemps et dispose d'un support IDE plus mature. Il avait également une très grande bibliothèque de composants. JavaFX est relativement plus récent et dispose d'une petite bibliothèque de composants mais avec des mises à jour plus cohérentes et une prise en charge MVC cohérente. Cela dépend donc de la façon dont JavaFX se développe et fournit plus de fonctionnalités.

Q # 5) Quel est le meilleur AWT ou Swing?

Répondre: Swing est construit sur AWT et fournit un ensemble riche et large de composants d'interface utilisateur par rapport à AWT. Les composants Swing peuvent également avoir leur apparence et leur convivialité par rapport aux composants AWT qui prennent une apparence et une sensation du système d'exploitation.

Les composants Swing sont plus rapides que AWT. Tous ces facteurs rendent le swing meilleur que AWT.

En savoir plus sur Java Swing

Lorsque vous créez une application, vous devez initialement avoir un conteneur de base et vous devez ajouter les composants requis tels que des boutons et des champs de texte dans le conteneur.

Et lorsque vous cliquez ou effectuez une opération sur un champ, l'événement se produit et votre code doit écouter les événements et également gérer l'événement.

Conteneur de balançoire

Un conteneur est un élément racine d'une application. Tous les autres composants sont ajoutés à cette racine et elle forme une hiérarchie.

Il existe trois classes de conteneurs:

  • JFrame
  • JDialog
  • JApplet

Démonstration de conteneur utilisant JFrame:

import java.awt.Color; import javax.swing.JFrame; import javax.swing.JPanel; public class ContainerDemo { public static void main(String() args) { JFrame baseFrame =new JFrame(); baseFrame.setTitle('Base Container'); JPanel contentPane=new JPanel(); contentPane.setBackground(Color.pink); baseFrame.setSize(400, 400); baseFrame.add(contentPane); baseFrame.setDefaultCloseOperation(baseFrame.EXIT_ON_CL OSE); baseFrame.setVisible(true); } }

Démonstration de conteneur avec JFrame

Lorsque vous exécutez le programme ci-dessus, vous obtiendrez la sortie ci-dessous.

conteneur de base

Composants

La classe JComponent est une classe de base pour tous les composants d'une balançoire.

Les composants fréquemment utilisés comprennent,

  • JButton
  • JTextField
  • JTextArea
  • JRadioButton
  • JComboBox etc.

Tous ces composants doivent être ajoutés au conteneur sinon, il n'apparaîtra pas sur l'application.

Exemple:

Pour créer l'instance de bouton,

JButton clickButton = nouveau JButton ();

Pour ajouter le bouton au conteneur,

myFrame.add ();

Gestion des événements

Toutes les applications sont pilotées par des événements tels que les clics de bouton, les clics de souris, la saisie de texte utilisateur, etc. Lorsque l'événement se produit, vous devez ajouter un écouteur et transmettre l'objet événement source.

Avec une classe interne, vous pouvez gérer l'événement avec votre logique comme indiqué ci-dessous.

public class ContainerDemo { public void createApp() { JFrame baseFrame =new JFrame(); JPanel contentPane=new JPanel(); baseFrame.setTitle('Base Container'); baseFrame.setSize(400, 400); baseFrame.add(contentPane); JButton demoButton =new JButton('click'); demoButton.setBounds(100,95,95,30); JTextArea result =new JTextArea(); result.setBounds(130,140,95,30); contentPane.add(demoButton); contentPane.add(result); baseFrame.setDefaultCloseOperation(baseFrame.EXIT_ON_CL OSE); baseFrame.setVisible(true); demoButton.addMouseListener(new MouseAdapter() { @Override public void mouseClicked(MouseEvent e) { result.setText('button clicked'); } }); } public static void main(String() args) { ContainerDemo c =new ContainerDemo(); c.createApp(); } }

Gestion des événements

Conclusion

Dans ce tutoriel, nous avons abordé la base avec l'API Swing fournie par Java pour créer des applications GUI. Nous avons discuté des principaux conteneurs et composants mobiles et de leur mise en œuvre.

Nous avons également discuté de la gestion des événements dans Swing. Bien que le mécanisme de gestion des événements soit AWT, swing implémente les événements de manière efficace. Ensuite, nous avons discuté des différents gestionnaires de disposition fournis par l'API Swing qui nous permettent de mettre en page ou d'organiser divers composants dans les applications Swing GUI.

=> Consultez le guide de formation Perfect Java ici.

lecture recommandée

^