Menü

Java SWING Tutorial: Container-, Komponenten- und Ereignisbehandlung

  • Haupt
  • Andere
  • Java SWING Tutorial: Container-, Komponenten- und Ereignisbehandlung

java swing tutorial container

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Dieses umfassende Java Swing-Video-Tutorial erklärt verschiedene Komponenten des GUI Swing Framework und verwandte Konzepte wie JPanel, JFrame, JButton usw .:

Wir verwenden grafische Benutzeroberflächen (allgemein als GUI bezeichnet), um Anwendungen mit einer visuellen Oberfläche zu erstellen, indem wir dem Benutzer die Verwendung der Anwendung erleichtern.

Durch eine visuelle Oberfläche für eine Anwendung ist die Anwendung einfach zu navigieren, Steuerelemente effizienter zu verwenden und der Benutzer ist auch optisch ansprechend.

Swing wird hauptsächlich zum Erstellen der GUI für Anwendungen verwendet.

=> Besuchen Sie hier, um die Java-Schulungsreihe für alle zu sehen.

Java SWING

Was du lernen wirst:

Video-Tutorial zu Java Swing

Was ist Java Swing?

Java bietet viele GUI-Frameworks, die uns bei der Entwicklung einer Vielzahl von GUI-Anwendungen helfen. Wir haben eines in unserem vorherigen Tutorial gesehen, d. H. Abstract Window Toolkit oder AWT. AWT ist eines der ältesten GUI-Frameworks in Java und auch plattformabhängig. Ein weiterer Nachteil von AWT sind seine schweren Komponenten.

In diesem Tutorial werden wir ein weiteres GUI-Framework in Java diskutieren, d. H. 'SWING'. Das Swing-Framework in Java ist Teil von Java Foundation Classes oder wird allgemein als JFCs bezeichnet. JFC ist eine API, die MFCs (Microsoft Foundation Classes) in C ++ ähnelt. JFC enthält Swing, AWT und Java2D.

Das Swing-Framework in Java basiert auf dem AWT-Framework und kann zum Erstellen von GUI-Anwendungen wie AWT verwendet werden. Im Gegensatz zu AWT sind die Swing-Komponenten jedoch leicht und plattformunabhängig.

Das Swing-Framework ist vollständig in Java geschrieben. Das Swing-Framework in Java wird über das Paket 'javax.swing' bereitgestellt. Die Klassen im Paket javax.swing beginnen mit dem Buchstaben 'J'. In einem javax.swing-Paket haben wir also Klassen wie JButton, JFrame, JTextField, JTextArea usw.

Im Allgemeinen ist in der Swing-API jedes Steuerelement im Paket javax.swing definiert, das in AWT vorhanden ist. In gewisser Weise wirkt Swing als Ersatz für AWT. Außerdem verfügt Swing über verschiedene erweiterte Fenster mit Registerkarten für Komponenten. Die Swing-API in Java passt die MVC-Architektur (Model View Controller) an.

Die Hauptmerkmale dieser Architektur sind:

  • Die Daten der Swing-Komponente werden mit Model dargestellt.
  • Es wird visuell anhand einer Ansicht dargestellt.
  • Die Controller-Komponente der MVC-Architektur liest Eingaben des Benutzers in die Ansicht und diese Änderungen werden dann an die Komponentendaten übergeben.
  • In jeder Swing-Komponente sind Ansicht und Controller miteinander verbunden, während das Modell separat ist. Dies verleiht dem Swing ein steckbares Erscheinungsbild.

Die Funktionen der Swing-API sind unten zusammengefasst.

  1. Swing-Komponenten sind plattformunabhängig.
  2. Die API ist erweiterbar.
  3. Schaukelkomponenten sind leicht. Die Swing-Komponenten sind in reinem Java geschrieben und auch Komponenten werden mit Java-Code anstelle der zugrunde liegenden Systemaufrufe gerendert.
  4. Die Swing-API bietet eine Reihe erweiterter Steuerelemente wie TabbedPane, Tree, Colorpicker, Tabellensteuerelemente usw., die reich an Funktionen sind.
  5. Die Schwenksteuerungen sind sehr anpassbar. Dies liegt daran, dass das Erscheinungsbild oder das Erscheinungsbild der Komponente unabhängig von der internen Darstellung ist und wir sie daher nach unseren Wünschen anpassen können.
  6. Wir können einfach die Werte und damit das Erscheinungsbild zur Laufzeit ändern.

Java Swing-Komponenten

Swing verfügt über eine Vielzahl von Komponenten, die wir in unsere Programme aufnehmen und die umfangreichen Funktionen nutzen können, mit denen wir hochgradig angepasste und effiziente GUI-Anwendungen entwickeln können.

Was ist eine Komponente?

Eine Komponente kann als Steuerelement definiert werden, das visuell dargestellt werden kann und normalerweise unabhängig ist. Es hat eine bestimmte Funktionalität und wird in der Swing-API als einzelne Klasse dargestellt.

Zum Beispiel, Klasse JButton in der Swing-API ist eine Schaltflächenkomponente und bietet die Funktionalität einer Schaltfläche.

Eine oder mehrere Komponenten bilden eine Gruppe, und diese Gruppe kann in einem „Container“ platziert werden. Ein Container bietet einen Bereich, in dem wir Komponenten anzeigen und deren Abstand, Layout usw. verwalten können.

In Java werden Container wie folgt gezeigt in zwei Typen unterteilt:

Containertypen

Swing-Klassen in Java

Eine Swing-API-Hierarchie in Java ist unten dargestellt:

Einführung in Swingklassen

Wie aus der obigen Hierarchie hervorgeht, haben wir Containerklassen - Frame, Dialog, Panel, Applet usw. Es gibt auch Komponentenklassen, die von der JComponent-Klasse der Swing-API abgeleitet sind. Einige der Klassen, die von JComponent erben, sind JLabel, JList, JTextBox usw.

Einige der wichtigen Klassen der Swing-API sind wie folgt:

  • JWindow: Die JWindow-Klasse von Swing erbt die Window-Klasse direkt. Die JWindow-Klasse verwendet 'BorderLayout' als Standardlayout.
  • JPanel: JPanel ist ein Nachkomme der JComponent-Klasse und ähnelt der AWT-Klasse Panel. Als Standardlayout wird 'FlowLayout' verwendet.
  • JFrame: JFrame stammt von der Frame-Klasse ab. Die dem Frame hinzugefügten Komponenten werden als Inhalt des Frames bezeichnet.
  • JLabel: Die JLabel-Klasse ist eine Unterklasse der JComponent. Es wird verwendet, um Textbeschriftungen in der Anwendung zu erstellen.
  • JButton: Die Drucktastenfunktion in Swing wird von JButton bereitgestellt. Wir können dem JButton-Objekt eine Zeichenfolge, ein Symbol oder beides zuordnen.
  • JTextField: Die JTextField-Klasse bietet ein Textfeld, in dem wir eine einzelne Textzeile bearbeiten können.

JFrame In Java

Ein Frame ist im Allgemeinen ein Container, der andere Komponenten wie Schaltflächen, Beschriftungen, Textfelder usw. enthalten kann. Ein Frame-Fenster kann einen Titel, einen Rahmen sowie Menüs, Textfelder, Schaltflächen und andere Komponenten enthalten. Eine Anwendung sollte einen Rahmen enthalten, damit wir Komponenten hinzufügen können.

Der Frame in Java Swing ist in der Klasse javax.swing.JFrame definiert. Die JFrame-Klasse erbt die java.awt.Frame-Klasse. JFrame ist wie das Hauptfenster der GUI-Anwendung mit Swing.

Wir können ein JFrame-Fensterobjekt mit zwei Ansätzen erstellen:

Tools zur Erfassung von Anforderungen, die von Geschäftsanalysten verwendet werden

# 1) Durch Erweitern der JFrame-Klasse

Der erste Ansatz besteht darin, eine neue Klasse zum Erstellen eines Frames zu erstellen. Diese Klasse erbt von der JFrame-Klasse des Pakets javax.swing.

Das folgende Programm implementiert diesen Ansatz.

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 } }

Ausgabe:

Durch Erweitern der JFrame-Klasse

# 2) Durch Instanziieren der JFrame-Klasse

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 } }

Ausgabe:

Durch Instanziieren der JFrame-Klasse

Im obigen Programm haben wir einen Frame aus der JFrame-Klasse erstellt, indem wir eine Instanz der JFrame-Klasse erstellt haben.

JPanel In Java

Ein Panel ist eine Komponente, die in einem Rahmenfenster enthalten ist. Ein Rahmen kann mehr als eine Panel-Komponente enthalten, wobei jede Panel-Komponente mehrere andere Komponenten aufweist.

Einfacher ausgedrückt können wir Panels verwenden, um den Rahmen zu partitionieren. Jedes Panel gruppiert mehrere andere Komponenten darin. Mit anderen Worten, wir verwenden Bedienfelder, um Komponenten innerhalb des Rahmens zu organisieren.

Die Swing-API-Klasse, die die Panel-Komponente implementiert, ist JPanel. Die JPanel-Klasse erbt von JComponent und hat FlowLayout als Standardlayout.

Das folgende Programm demonstriert die Erstellung eines Panel-Containers in einem Frame mithilfe der Paketklassen 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 } }

Ausgabe:

JPanel in Java

Hier haben wir einen Rahmen. Innerhalb des Rahmens erstellen wir ein Panel. Dann erstellen wir innerhalb des Panels eine Schaltfläche. Auf diese Weise können wir ein Panel verwenden, um die anderen Komponenten zu halten.

JTextArea In Java

TextArea definiert ein bearbeitbares Textfeld. Es kann mehrere Zeilen haben. Die Swing-Klasse, die den Textbereich definiert, ist JTextArea und erbt die JTextComponent-Klasse.

öffentliche Klasse JTextArea erweitert JTextComponent

Die JTextArea-Klasse enthält 4 Konstruktoren, mit denen wir einen Textbereich mit verschiedenen Optionen erstellen können.

  • JTextArea (): Standardkonstruktor. Erstellen Sie einen leeren Textbereich.
  • JTextArea (String s): Erstellt einen Textbereich mit s als Standardwert.
  • JTextArea (int Zeile, int Spalte): Erstellt einen Textbereich mit einer angegebenen Zeile x Spalte.
  • JTextArea (Zeichenfolge s, int Zeile, int Spalte): Erstellt einen Text are2a mit der angegebenen Zeile x Spalte und dem Standardwert s.

Das folgende Java-Programm zeigt ein Beispiel für die JTextArea-Komponente im 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 } }

Ausgabe:

JTextArea in Java

JButton In Java

Eine Schaltfläche ist eine Komponente, mit der eine Drucktaste mit einem Namen oder einer Bezeichnung erstellt wird. Im Swing ist die Klasse, die eine beschriftete Schaltfläche erstellt, JButton. JButton erbt die AbstractButton-Klasse. Wir können das ActionListener-Ereignis der Schaltfläche zuordnen, damit es beim Drücken eine Aktion ausführt.

Implementieren wir ein Beispielprogramm für JButton in Java-Swings.

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); } }

Ausgabe:

JButton in Java

JList In Java

Eine Liste besteht aus mehreren Textelementen. Benutzer können entweder ein einzelnes Element oder mehrere Elemente gleichzeitig auswählen. Die Klasse, die die Liste in der Swing-API implementiert, ist JList. JList ist ein Nachkomme der JComponent-Klasse.

Nachstehend sind die Konstruktoren der JList-Klasse aufgeführt.

  • JList (): Standardkonstruktor, der eine leere schreibgeschützte Liste erstellt.
  • JList (array () listItem): Erstellen Sie eine JList, die anfänglich Elemente des Arrays listItem enthält.
  • JList (ListModel dataModel): Erstellt eine Liste mit Elementen aus dem angegebenen Modell dataModel.

Eine einfache Demonstration der JList-Komponente finden Sie unten.

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); } }

Ausgabe:

JList in Java

Im obigen Programm definieren wir zuerst ein listModel mit Farbeinträgen. Dann erstellen wir ein JList-Objekt und fügen das listModel hinzu. Als nächstes wird das JList-Objekt dem Rahmenobjekt hinzugefügt, das dann angezeigt wird.

JComboBox in Java

Die JCombobox-Klasse zeigt eine Liste von Auswahlmöglichkeiten, aus denen ein Benutzer eine Option auswählen kann. Die ausgewählte Auswahl befindet sich oben. JComboBox leitet sich von der JComponent-Klasse ab.

Die folgenden Konstruktoren werden von der JComboBox-Klasse bereitgestellt:

  • JComboBox (): Standardkonstruktor, der eine ComboBox mit dem Standarddatenmodell erstellt.
  • JComboBox (Objekt () Elemente): Dieser Konstruktor erstellt eine ComboBox mit Elementen als Elementen der angegebenen Array-Elemente.
  • JComboBox (Vektorelemente): Dieser Konstruktor liest die Elemente des angegebenen Vektors und erstellt eine ComboBox mit diesen Elementen als Elementen.

Die JComboBox-Klasse bietet auch Methoden zum Hinzufügen / Entfernen von Elementen, Hinzufügen von ActionListener, ItemListener usw.

Das folgende Beispiel zeigt die JComboBox-Implementierung in 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(); } }

Ausgabe:

JComboBox-Implementierung

JSlider In Java

Mit einem Schieberegler können wir einen bestimmten Wertebereich auswählen. In der Java Swing-API ist JSlider die Klasse, mit der der Schieberegler implementiert wird.

Die folgenden Konstruktoren werden von der JSlider-Klasse bereitgestellt.

  • JSlider (): Ein Standardkonstruktor, der einen Schieberegler mit 50 als Anfangswert und einem Bereich von 0 bis 100 erstellt.
  • JSlider (int Ausrichtung): Dieser Konstruktor erstellt einen Schieberegler wie oben, jedoch mit einer angegebenen Ausrichtung. Der Orientierungswert kann entweder JSlider.HORIZONTAL oder JSlider.VERTICAL sein.
  • JSlider (int min, int max): Mit diesem Konstruktor wird ein horizontaler Schieberegler unter Verwendung der angegebenen min und max erstellt.
  • JSlider (int min, int max, int value): Dieser Konstruktor erstellt einen horizontalen Schieberegler mit dem angegebenen Wert von min, max und value.
  • JSlider (int Orientierung, int min, int max, int Wert): Dieser Konstruktor erstellt einen Schieberegler mit der angegebenen Ausrichtung, min, max und Wert.

Das folgende Programm demonstriert den JSlider in Java mit Häkchen. Dieses Programm demonstriert auch die Verwendung der von der JSlider-Klasse unterstützten Methoden.

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); } }

Ausgabe:

JSlider in Java

Ereignisbehandlung in Java

Ein Ereignis kann als Zustandsänderung eines Objekts definiert werden. Aus Sicht der GUI tritt ein Ereignis auf, wenn der Endbenutzer mit den GUI-Komponenten interagiert. Die Ereignisse, die in der GUI ausgelöst werden, können das Klicken einer Schaltfläche, das Scrollen, das Auswählen von Listenelementen, das Ändern von Text usw. sein.

Ereignisse, die in der oben aufgeführten GUI auftreten, sind meistens Vordergrundereignisse. Es können auch einige Hintergrundereignisse wie Abschluss des Hintergrundvorgangs, Ablauf des Timers usw. auftreten.

Die Ereignisbehandlung ist ein Mechanismus, über den eine Aktion ausgeführt wird, wenn ein Ereignis auftritt. Dazu definieren wir eine Methode, die auch als Ereignishandler bezeichnet wird und beim Auftreten eines Ereignisses aufgerufen wird. Java verwendet einen Standardmechanismus namens 'Delegation Event Model', um Ereignisse zu generieren und zu verarbeiten.

Das Delegationsereignismodell besteht aus:

# 1) Quelle: Die Quelle des Ereignisses ist das Objekt. Das Objekt, an dem ein Ereignis auftritt, ist die Quelle, und die Quelle ist dafür verantwortlich, Informationen über das Ereignis an den Ereignishandler zu senden.

# 2) Zuhörer: Der Listener ist nichts anderes als der Ereignishandler, der für das Ausführen einer Aktion verantwortlich ist, wenn ein Ereignis auftritt. In Java ist ein Listener ein Objekt, das auf ein Ereignis wartet. Sobald das Ereignis eintritt, verarbeitet der Listener das Ereignis.

Die Anforderung besteht darin, den Listener beim Objekt zu registrieren, damit der Listener es verarbeiten kann, wenn ein Ereignis auftritt.

Zum Beispiel,Für ein Button-Click-Ereignis können wir die folgende Abfolge von Schritten ausführen.

  1. Der Benutzer klickt auf die Schaltfläche, die ein Klickereignis generiert.
  2. Das entsprechende Ereignisklassenobjekt wird erstellt und die Quell- und Ereignisdaten werden an dieses Objekt übergeben.
  3. Dieses Ereignisobjekt wird dann an die mit dem Objekt registrierte Listener-Klasse übergeben.
  4. Der Listener wird ausgeführt und kehrt zurück.

Lassen Sie uns nun einige der von Java bereitgestellten Listener diskutieren.

ActionListener In Java

Ein actionListener ist der Listener für eine Schaltfläche oder einen Menüpunkt. Wenn wir auf eine Schaltfläche klicken, ist die betroffene Schaltfläche Listener der actionListener. Der actionListener wird im ActionEvent benachrichtigt.

Das Ereignispaket java.awt.an definiert die ActionListener-Schnittstelle. Diese Schnittstelle hat nur eine Methode actionPerformed ().

public abstract void actionPerformed (ActionEvent e);

Wenn auf eine registrierte Komponente wie eine Schaltfläche geklickt wird, wird die actionPerformed () -Methode automatisch aufgerufen.

Der gebräuchlichste Ansatz, um ActionListener in das Programm aufzunehmen, besteht darin, die ActionListener-Schnittstelle und anschließend die actionPerformed () -Methode zu implementieren.

Die Schritte zum Implementieren der ActionListener-Klasse lauten wie folgt:

# 1) Implementieren Sie die Schnittstelle ActionListerner.

öffentliche Klasse ActionListenerImpl Implementiert ActionListener

# 2) Registrieren Sie die Komponente bei diesem Listener. Wenn die Schaltfläche eine Komponente ist, die wir beim Listener registrieren möchten, registrieren wir sie wie folgt:

button.addActionListener (instanceOfListenerclass);

# 3) Implementieren / überschreiben Sie die actionPerformed () -Methode.

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

Mit den obigen Schritten können wir also jedes Ereignis der GUI-Komponente zuordnen.

Das folgende Beispiel zeigt ein Schaltflächenklickereignis mit 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); } }

Ausgabe:

ActionListener in Java

Das obige Programm implementiert ein ActionListener-Ereignis. Das Ereignis ist das Schaltflächenklickereignis, und wir haben ihm einen ActionListener zugeordnet, der den Text im Textfeld beim Klicken auf die Schaltfläche anzeigt.

KeyListener In Java

Immer wenn sich der Status des Schlüssels ändert, wird ein KeyListener benachrichtigt. Genau wie ActionListener befindet sich auch der KeyListener im Paket java.awt.event.

Wie finde ich den Netzwerksicherheitsschlüssel auf dem Android-Handy?

Die KeyListener-Schnittstelle bietet die folgenden Methoden:

public abstract void keyPressed (KeyEvent e);

public abstract void keyReleased (KeyEvent e);

public abstract void keyTyped (KeyEvent e);

Wir müssen die obigen Methoden implementieren, um die Schlüsselereignisse der Komponente zuzuordnen. Wir überlassen es dem Benutzer, ein KeyListener-Beispiel mithilfe von Swings in Java zu implementieren.

Swing-Layouts in Java

Wenn wir verschiedene Komponenten in einem Container anordnen, sagen wir, dass wir diese Komponenten auslegen. Ein Layout kann also als Positionierung von Komponenten in einem Container definiert werden.

Solange weniger Komponenten vorhanden sind, können diese manuell per Drag & Drop platziert werden. Es wird jedoch schwierig, die Komponenten in großen Mengen anzuordnen. Zu diesem Zeitpunkt hilft uns der Layout Manager von Java.

LayoutManager ist für das Layout der Komponenten in GUI-Anwendungen verantwortlich. LayoutManager ist eine Schnittstelle und wird von allen Layout Manager-Klassen implementiert. Java bietet die folgenden LayoutManager-Klassen.

LayoutManagerBeschreibung
javax.swing.GroupLayoutGruppiert die Komponenten und positioniert sie dann im Container.
java.awt.BorderLayoutDie Komponenten sind so ausgelegt, dass sie in fünf Richtungen passen, nämlich Mitte, Osten, Westen, Süden, Norden.
java.awt.FlowLayoutDies ist das Standardlayout. Es legt die Komponenten in den Richtungsfluss.
java.awt.GridLayoutOrdnet die Komponenten in einem rechteckigen Raster an.
javax.swing.BoxLayoutKomponenten sind in einer Box angeordnet.
java.awt.CardLayoutJede Komponente wird als Karte in einem Deck angesehen und es ist jeweils nur eine Komponente sichtbar.
java.awt.GridBagLayoutOrdnet Komponenten vertikal, horizontal oder sogar entlang ihrer Basislinien an. Komponenten müssen nicht gleich groß sein.
javax.swing.ScrollPaneLayoutWird von der JScrollPane-Klasse verwendet und ist für das Anordnen von Komponenten in scrollbaren Containern verantwortlich.
javax.swing.SpringLayout etc.Eine Reihe von Einschränkungen wie der horizontale und vertikale Abstand zwischen Komponenten usw. wird bereitgestellt, und die Komponenten werden gemäß dieser Gruppe von Einschränkungen angeordnet.

In diesem Tutorial werden nur FlowLayout und GridLayout behandelt.

FlowLayout In Java

Das FlowLayout ordnet die Komponenten nacheinander in Flussrichtung an. Dies ist das Standardlayout für Container wie Panel und Applet.

Die FlowLayout-Klasse in Java, die den FlowLayout-Manager darstellt, enthält die folgenden Felder und Konstruktoren.

Felder der FlowLayout-Klasse

  • public static final int LEADING
  • public static final int TRAILING
  • public static final int LEFT
  • public static final int RIGHT
  • public static final int CENTER

Die obigen Felder definieren die Positionen, an denen die Komponenten platziert oder ausgerichtet werden.

Konstruktoren der FlowLayout-Klasse

  • FlowLayout (): Dies ist ein Standardkonstruktor. Dieser Konstruktor erstellt ein Flusslayout mit zentral ausgerichteten Komponenten mit einem Standardabstand von 5 Einheiten in horizontaler und vertikaler Richtung.
  • FlowLayout (int align): Dieser Konstruktor erstellt ein Flusslayout mit dem angegebenen Ausrichtungswert und einem horizontalen und vertikalen Abstand von 5 Einheiten.
  • FlowLayout (int align, int hgap, int vgap): Erstellt ein Flusslayout mit angegebenem Ausrichtungswert und horizontalem und vertikalem Spalt.

Im Folgenden finden Sie ein Beispiel für FlowLayout in 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(); } }

Ausgabe:

Konstruktoren der FlowLayout-Klasse

GridLayout In Java

Mit GridLayout können wir die Komponenten in einem rechteckigen Raster anordnen, d. H. Jede Komponente ist in jedem Rechteck angeordnet.

Konstruktoren der GridLayout-Klasse

  1. Gitterstruktur (): Standardkonstruktor, der ein Rasterlayout mit einer Spalte pro Komponente in einer Zeile generiert.
  2. GridLayout (int Zeilen, int Spalten): Dieser Konstruktor generiert ein Rasterlayout mit angegebenen Zeilen und Spalten. Es gibt keine Lücke zwischen den Komponenten.
  3. GridLayout (int Zeilen, int Spalten, int hgap, int vgap): Verwenden dieses Konstruktors, Wir generieren ein Rasterlayout mit festgelegten Zeilen und Spalten sowie horizontalen und vertikalen Lücken.

Das folgende Beispiel implementiert das GridLayout in 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(); } }

Ausgabe:

GridLayout in Java

Setbounds in Java

Wenn wir die Programmierbeispiele in diesem Tutorial vor dem Layout-Thema überprüfen, können wir sehen, dass wir das Layout in diesen Beispielen auf null gesetzt haben (setLayout (null)). Wir haben gesehen, dass wenn wir Layout-Manager in unserem Programm verwenden, diese die Komponenten automatisch positionieren.

Wenn Layout-Manager nicht verwendet werden, können wir die setBounds-Methode für die Größe und Position der Komponente verwenden. Daher wird die Methode setBounds verwendet, um die Komponente manuell zu positionieren und auch die Größe festzulegen.

Die allgemeine Syntax der setBounds-Methode lautet wie folgt:

setBounds (int x-Koordinate, int y - Koordinate, int Breite, int Höhe)

Implementieren wir nun ein Beispiel für die SetBounds-Methode.

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); } }

Ausgabe:

wie man eine mkv-Datei abspielt

Setbounds in Java

Im obigen Programm haben wir eine Button-Komponente. Wir haben kein Layout festgelegt, aber wir haben die setBounds-Methode verwendet, um ihre Position und Abmessungen festzulegen.

Swing Vs JavaFX

SchwingenJavaFX
Swing bietet eine API zum Erstellen von GUI-Komponenten.JavaFX bietet Skripte und eine schnelle UI-Entwicklung im Zusammenhang mit Screen Builder.
In zukünftigen Versionen wird Swing keine neue Funktionalität hinzugefügt.JavaFX bietet umfangreiche Funktionen und bietet das Potenzial für weitere Funktionen in zukünftigen Versionen.
Wir können alle Standardkomponenten mit der Swing-API erstellen.Mit JavaFX können wir umfangreiche GUI-Komponenten mit erweitertem Erscheinungsbild erstellen.
In Swing ist eine große Anzahl von Komponenten vorhanden.JavaFX hat eine vergleichsweise geringere Anzahl von Komponenten.
Swing ist eine UI-Bibliothek mit allen Funktionen.JavaFX ist eine neue und kommende API mit umfangreichen UI-Komponenten.
Swing hat lose MVC-Unterstützung.JavaFX unterstützt MVC-Muster konsistent.

Häufig gestellte Fragen

F # 1) Wird Swing noch in Java verwendet?

Antworten: Ja, Swing wird immer noch in Java verwendet und das zu stark. Manchmal wird es als vollständiger Ersatz für AWT verwendet. Manchmal wird es auch zusammen mit einigen AWT-Komponenten verwendet. Es wird sogar mit dem neuesten JavaFX verwendet. Swing wird also immer noch verwendet und wird noch lange verwendet.

F # 2) Wie funktioniert Java Swing?

Antworten: Swing in Java wird über das AWT-Framework geschrieben. Das Event-Handling von AWT wird also vollständig von Swing übernommen. Swing bietet auch eine große Anzahl von Komponenten, mit denen wir effiziente GUI-Anwendungen entwickeln können.

F # 3) Folgt Swing MVC?

Antworten: Swing API hat lose MVC-Unterstützung. Das Modell repräsentiert die Daten der Komponente. Die Swing-Komponente verfügt über ein separates Element namens Model, während Controller und View in UI-Elementen zusammengefasst sind. Dieses Clubbing ermöglicht dem Swing ein steckbares Erscheinungsbild.

F # 4) Ist JavaFX besser als Swing?

Antworten: Swing gibt es schon lange und es gibt eine ausgereiftere IDE-Unterstützung. Es hatte auch eine sehr große Bibliothek von Komponenten. JavaFX ist vergleichsweise neuer und verfügt über eine kleine Komponentenbibliothek, jedoch mit konsistenteren Updates und konsistenter MVC-Unterstützung. Daher hängt es davon ab, wie sich JavaFX weiterentwickelt und mehr Funktionen bietet.

F # 5) Was ist besser AWT oder Swing?

Antworten: Swing basiert auf AWT und bietet im Vergleich zu AWT eine Vielzahl von UI-Komponenten. Swing-Komponenten können auch so aussehen und sich so anfühlen wie AWT-Komponenten, die sich wie das Betriebssystem anfühlen.

Schwenkkomponenten sind schneller als AWT. All diese Faktoren machen den Schwung besser als AWT.

Weitere Informationen zu Java Swing

Wenn Sie eine Anwendung erstellen, sollten Sie zunächst einen Basiscontainer haben und die erforderlichen Komponenten wie Schaltflächen und Textfelder in den Container einfügen.

Wenn Sie auf ein Feld klicken oder eine Operation ausführen, tritt das Ereignis auf und Ihr Code sollte die Ereignisse abhören und auch das Ereignis behandeln.

Schaukelcontainer

Ein Container ist ein Stammelement für eine Anwendung. Alle anderen Komponenten werden zu diesem Stamm hinzugefügt und bilden eine Hierarchie.

Es gibt drei Containerklassen:

  • JFrame
  • JDialog
  • JApplet

Container-Demo mit 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); } }

Container-Demo mit JFrame

Wenn Sie das obige Programm ausführen, erhalten Sie die folgende Ausgabe.

Basisbehälter

Komponenten

Die JComponent-Klasse ist eine Basisklasse für alle Komponenten in einem Swing.

Die häufig verwendeten Komponenten umfassen:

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

Alle diese Komponenten sollten dem Container hinzugefügt werden. Andernfalls wird sie nicht in der Anwendung angezeigt.

Beispiel:

Um die Schaltflächeninstanz zu erstellen,

JButton clickButton = neuer JButton ();

Um die Schaltfläche zum Container hinzuzufügen,

myFrame.add ();

Handhabung des Events

Alle Anwendungen werden von Ereignissen wie Schaltflächenklicks, Mausklicks, Benutzerexteingaben usw. gesteuert. Wenn das Ereignis eintritt, müssen Sie einen Listener hinzufügen und das Quellereignisobjekt übergeben.

Mit einer inneren Klasse können Sie das Ereignis mit Ihrer Logik wie unten gezeigt behandeln.

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(); } }

Handhabung des Events

Fazit

In diesem Tutorial haben wir uns mit der von Java bereitgestellten Swing-API zum Erstellen von GUI-Anwendungen befasst. Wir haben die wichtigsten Schaukelcontainer und -komponenten sowie deren Implementierung besprochen.

Wir haben auch die Ereignisbehandlung in Swing besprochen. Obwohl der Ereignisbehandlungsmechanismus von AWT ist, implementiert Swing die Ereignisse auf effiziente Weise. Anschließend wurden die verschiedenen von der Swing-API bereitgestellten Layout-Manager erläutert, mit denen wir verschiedene Komponenten in den Swing-GUI-Anwendungen gestalten oder anordnen können.

=> Lesen Sie hier den perfekten Java-Schulungsleitfaden.

Literatur-Empfehlungen

^