Menu

Tutorial Java SWING: contenitore, componenti e gestione degli eventi

  • Principale
  • Altro
  • Tutorial Java SWING: contenitore, componenti e gestione degli eventi

java swing tutorial container

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial video completo su Java Swing spiega i vari componenti del framework GUI Swing e concetti correlati come JPanel, JFrame, JButton, ecc:

Usiamo interfacce utente grafiche (comunemente chiamate GUI) per creare applicazioni che hanno un'interfaccia visiva rendendo facile per l'utente l'utilizzo dell'applicazione.

Disporre di un'interfaccia visiva per un'applicazione rende l'applicazione facile da navigare, utilizza i controlli in modo più efficiente ed è anche visivamente attraente per l'utente.

Swing viene utilizzato principalmente per creare la GUI per le applicazioni.

=> Visita qui per vedere la serie di formazione Java per tutti.

Java SWING

Cosa imparerai:

Tutorial video su Java Swing

Cos'è Java Swing

Java fornisce molti framework GUI che ci aiutano nello sviluppo di una varietà di applicazioni GUI. Ne abbiamo visto uno nel nostro tutorial precedente, ad esempio Abstract Window Toolkit o AWT. AWT è uno dei framework GUI più vecchi in Java ed è anche dipendente dalla piattaforma. Un altro svantaggio di AWT sono i suoi componenti pesanti.

In questo tutorial, discuteremo di un altro framework GUI in Java, ovvero 'SWING'. Il framework Swing in Java fa parte delle Java Foundation Classes o comunemente chiamate JFC. JFC è un'API simile a MFC (Microsoft Foundation Classes) in C ++. JFC contiene Swing, AWT e Java2D.

Il framework Swing in Java è basato sul framework AWT e può essere utilizzato per creare applicazioni GUI proprio come AWT. Ma a differenza di AWT, i componenti Swing sono leggeri e indipendenti dalla piattaforma.

Il framework Swing è scritto interamente in Java. Il framework Swing in Java viene fornito tramite il pacchetto 'javax.swing'. Le classi nel pacchetto javax.swing iniziano con la lettera 'J'. Quindi in un pacchetto javax.swing, avremo classi come JButton, JFrame, JTextField, JTextArea, ecc.

In generale, l'API Swing ha tutti i controlli definiti nel pacchetto javax.swing presente in AWT. Quindi l'oscillazione in un certo senso agisce come una sostituzione di AWT. Inoltre, Swing ha vari riquadri a schede di componenti avanzati. L'API Swing in Java adatta l'architettura MVC (Model View Controller).

Le caratteristiche principali di questa architettura sono:

  • I dati del componente swing sono rappresentati utilizzando il modello.
  • È rappresentato visivamente utilizzando una vista.
  • Il componente controller dell'architettura MVC legge l'input dell'utente nella vista e quindi queste modifiche vengono passate ai dati del componente.
  • In ogni componente Swing, la vista e il controller sono uniti insieme mentre il modello è separato. Ciò conferisce a swing un aspetto e una sensazione collegabili.

Le caratteristiche dell'API swing sono riassunte di seguito.

  1. I componenti Swing sono indipendenti dalla piattaforma.
  2. L'API è estensibile.
  3. I componenti Swing sono leggeri. I componenti swing sono scritti in Java puro e anche i componenti vengono renderizzati utilizzando il codice Java invece delle chiamate di sistema sottostanti.
  4. L'API Swing fornisce una serie di controlli avanzati come TabbedPane, Tree, Colorpicker, controlli da tavolo, ecc. Che sono ricchi di funzionalità.
  5. I controlli dello swing sono altamente personalizzabili. Questo perché l'aspetto o l'aspetto del componente è indipendente dalla rappresentazione interna e quindi possiamo personalizzarlo nel modo che desideriamo.
  6. Possiamo semplicemente modificare i valori e quindi alterare l'aspetto grafico in fase di esecuzione.

Componenti Java Swing

Swing ha una vasta gamma di componenti che possiamo includere nei nostri programmi e avvalerci delle ricche funzionalità che ci consentono di sviluppare applicazioni GUI altamente personalizzate ed efficienti.

Allora cos'è un componente?

Un componente può essere definito come un controllo che può essere rappresentato visivamente e di solito è indipendente. Ha una funzionalità specifica ed è rappresentato come una singola classe nell'API Swing.

Per esempio, La classe JButton nell'API swing è un componente pulsante e fornisce la funzionalità di un pulsante.

Uno o più componenti formano un gruppo e questo gruppo può essere posizionato in un 'Contenitore'. Un contenitore fornisce uno spazio in cui possiamo visualizzare i componenti e anche gestirne la spaziatura, il layout, ecc.

In Java, i contenitori sono divisi in due tipi come mostrato di seguito:

Tipi di contenitori

Corsi di swing in Java

Di seguito è mostrata una gerarchia dell'API Swing in Java:

Introduzione alle lezioni di swing

Come si vede dalla gerarchia sopra, abbiamo classi Container: frame, dialog, Panel, Applet, ecc. Ci sono anche classi Component derivate dalla classe JComponent dell'API Swing. Alcune delle classi che ereditano da JComponent sono JLabel, JList, JTextBox, ecc.

Alcune delle classi importanti di Swing API sono le seguenti:

  • JWindow: La classe JWindow di Swing eredita direttamente la classe Window. La classe JWindow utilizza 'BorderLayout' come layout predefinito.
  • JPanel: JPanel è un discendente della classe JComponent e si trova su linee simili alla classe AWT Panel e ha 'FlowLayout' come layout predefinito.
  • JFrame: JFrame discende dalla classe Frame. I componenti aggiunti al Frame sono chiamati contenuti del Frame.
  • JLabel: La classe JLabel è una sottoclasse di JComponent. Viene utilizzato per creare etichette di testo nell'applicazione.
  • JButton: La funzionalità del pulsante in Swing è fornita da JButton. Possiamo associare una stringa, un'icona o entrambi all'oggetto JButton.
  • JTextField: La classe JTextField fornisce un campo di testo in cui possiamo modificare una singola riga di testo.

JFrame in Java

Un Frame, in generale, è un contenitore che può contenere altri componenti come pulsanti, etichette, campi di testo, ecc. Una finestra Frame può contenere un titolo, un bordo e anche menu, campi di testo, pulsanti e altri componenti. Un'applicazione dovrebbe contenere una cornice in modo che possiamo aggiungere componenti al suo interno.

Il Frame in Java Swing è definito nella classe javax.swing.JFrame. La classe JFrame eredita la classe java.awt.Frame. JFrame è come la finestra principale dell'applicazione GUI che utilizza swing.

Possiamo creare un oggetto finestra JFrame utilizzando due approcci:

come rimuovere elementi da un array java

# 1) Estendendo la classe JFrame

Il primo approccio è creare una nuova classe per costruire un Frame. Questa classe eredita dalla classe JFrame del pacchetto javax.swing.

Il seguente programma implementa questo approccio.

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

Produzione:

Estendendo la classe JFrame

# 2) Istanziando 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 } }

Produzione:

Istanziando la classe JFrame

Nel programma sopra, abbiamo creato un frame dalla classe JFrame creando un'istanza della classe JFrame.

JPanel In Java

Un pannello è un componente contenuto all'interno di una finestra frame. Un telaio può contenere più componenti di un pannello al suo interno con ogni componente del pannello che ha diversi altri componenti.

In termini più semplici, possiamo usare i pannelli per dividere il telaio. Ogni pannello raggruppa diversi altri componenti al suo interno. In altre parole, utilizziamo i pannelli per organizzare i componenti all'interno del telaio.

La classe API swing che implementa il componente panel è JPanel. La classe JPanel eredita da JComponent e ha FlowLayout come layout predefinito.

Il seguente programma mostra la creazione di un contenitore di pannelli in un frame utilizzando le classi del pacchetto 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 } }

Produzione:

JPanel in Java

Qui abbiamo una cornice. All'interno della cornice creiamo un pannello. Quindi all'interno del pannello, creiamo un pulsante. In questo modo possiamo usare un pannello per contenere gli altri componenti.

JTextArea in Java

TextArea definisce un campo di testo modificabile. Può avere più righe. La classe swing che definisce l'area di testo è JTextArea ed eredita la classe JTextComponent.

la classe pubblica JTextArea estende JTextComponent

La classe JTextArea contiene 4 costruttori che ci permettono di creare un'area di testo con varie opzioni.

  • JTextArea (): Costruttore predefinito. Crea un'area di testo vuota.
  • JTextArea (String s): Crea un'area di testo con s come valore predefinito.
  • JTextArea (int riga, int colonna): Crea un'area di testo con una riga x colonna specificata.
  • JTextArea (String s, int row, int column): Crea un testo are2a con la riga x colonna specificata e il valore predefinito s.

Il seguente programma Java mostra un esempio del componente JTextArea nello 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 } }

Produzione:

JTextArea in Java

JButton in Java

Un pulsante è un componente utilizzato per creare un pulsante con un nome o un'etichetta su di esso. In swing, la classe che crea un pulsante etichettato è JButton. JButton eredita la classe AbstractButton. Possiamo associare l'evento ActionListener al pulsante per fare in modo che esegua un'azione quando viene premuto.

Implementiamo un programma di esempio per JButton negli swing 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); } }

Produzione:

JButton in Java

JList In Java

Un elenco è costituito da più elementi di testo. Gli utenti possono selezionare un singolo elemento o più elementi alla volta. La classe che implementa l'elenco nell'API swing è JList. JList è un discendente della classe JComponent.

Di seguito sono riportati i costruttori della classe JList.

  • JList (): Costruttore predefinito che crea un elenco vuoto di sola lettura.
  • JList (array () listItem): Crea una JList che inizialmente contiene elementi di array listItem.
  • JList (ListModel dataModel): Crea un elenco con elementi dal modello dataModel specificato.

Di seguito viene fornita una semplice dimostrazione del componente JList.

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

Produzione:

JList in Java

Nel programma sopra, definiamo prima un listModel con voci di colore in esso. Quindi creiamo un oggetto JList e aggiungiamo listModel ad esso. Successivamente, l'oggetto JList viene aggiunto all'oggetto frame che viene quindi visualizzato.

JComboBox in Java

La classe JCombobox mostra un elenco di scelte da cui un utente può selezionare un'opzione. La scelta selezionata è in alto. JComboBox deriva dalla classe JComponent.

I seguenti sono i costruttori forniti dalla classe JComboBox:

  • JComboBox (): Costruttore predefinito che crea un ComboBox con il modello di dati predefinito.
  • JComboBox (oggetti Object ()): Questo costruttore crea un ComboBox con elementi come elementi degli elementi della matrice specificati.
  • JComboBox (elementi vettoriali): Questo costruttore legge gli elementi del vettore dato e costruisce un ComboBox con questi elementi come suoi elementi.

La classe JComboBox fornisce anche metodi per aggiungere / rimuovere elementi, aggiungere ActionListener, ItemListener, ecc.

L'esempio seguente mostra l'implementazione di JComboBox 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(); } }

Produzione:

Implementazione di JComboBox

JSlider in Java

Un cursore ci consente di selezionare un intervallo di valori specifico. In Java Swing API, JSlider è la classe utilizzata per implementare lo slider.

I seguenti sono i costruttori forniti dalla classe JSlider.

  • JSlider (): un costruttore predefinito che crea uno slider con 50 come valore iniziale e intervallo 0-100.
  • JSlider (int orientamento): questo costruttore crea uno slider proprio come sopra ma con un orientamento specificato. Il valore di orientamento può essere JSlider.HORIZONTAL o JSlider.VERTICAL.
  • JSlider (int min, int max): questo costruttore viene utilizzato per creare uno slider orizzontale utilizzando i valori min e max.
  • JSlider (int min, int max, int value): questo costruttore crea uno slider orizzontale con il valore specificato di min, max e value.
  • JSlider (int orientamento, int min, int max, int valore): questo costruttore costruisce uno slider con orientamento, min, max e valore specificati.

Il seguente programma mostra JSlider in Java con i segni di spunta. Questo programma dimostra anche l'utilizzo dei metodi supportati dalla 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); } }

Produzione:

JSlider in Java

Gestione degli eventi in Java

Un evento può essere definito come un cambiamento di stato di un oggetto. Dal punto di vista della GUI, si verifica un evento quando l'utente finale interagisce con i componenti della GUI. Gli eventi che vengono attivati ​​nella GUI possono essere il clic di un pulsante, lo scorrimento, la selezione di elementi dell'elenco, la modifica del testo, ecc.

Gli eventi che si verificano nella GUI sopra elencata sono per lo più eventi in primo piano. Possiamo anche avere alcuni eventi in background come il completamento delle operazioni in background, la scadenza del timer, ecc.

La gestione degli eventi è un meccanismo attraverso il quale viene eseguita un'azione quando si verifica un evento. Per questo, definiamo un metodo che è anche chiamato un gestore di eventi che viene chiamato quando si verifica un evento. Java utilizza un meccanismo standard chiamato 'Delegation event model' per generare e gestire gli eventi.

Il modello di eventi di delega è costituito da:

# 1) Fonte: La fonte dell'evento è l'oggetto. L'oggetto su cui si verifica un evento è l'origine e l'origine è responsabile dell'invio delle informazioni sull'evento al gestore dell'evento.

# 2) ascoltatore: L'ascoltatore non è altro che il gestore di eventi responsabile di eseguire un'azione quando si verifica un evento. In Java, un listener è un oggetto che attende un evento. Una volta che si verifica l'evento, l'ascoltatore elabora l'evento.

Il requisito è registrare il listener con l'oggetto in modo che quando si verifica un evento, il listener possa elaborarlo.

Per esempio,per un evento clic su un pulsante, possiamo avere la seguente sequenza di passaggi.

  1. L'utente fa clic sul pulsante che genera un evento Click.
  2. L'oggetto della classe di eventi appropriato viene creato ei dati di origine e di evento vengono passati a questo oggetto.
  3. Questo oggetto evento viene quindi passato alla classe listener registrata con l'oggetto.
  4. L'ascoltatore esegue e ritorna.

Ora parliamo di alcuni degli ascoltatori forniti da Java.

ActionListener in Java

Un actionListener è l'ascoltatore di un pulsante o di una voce di menu. Quando si fa clic su un pulsante, il pulsante Listener coinvolto è actionListener. Il actionListener viene notificato in ActionEvent.

Il pacchetto di eventi java.awt.an definisce l'interfaccia ActionListener. Questa interfaccia ha un solo metodo actionPerformed ().

public abstract void actionPerformed (ActionEvent e);

come trovare i file apk su Android

Quando si fa clic su un componente registrato come un Button, viene automaticamente richiamato il metodo actionPerformed ().

L'approccio più comune per includere ActionListener nel programma è implementare l'interfaccia ActionListener e quindi implementare il metodo actionPerformed ().

I passaggi per implementare la classe ActionListener sono i seguenti:

# 1) Implementa l'interfaccia ActionListerner.

public class ActionListenerImpl Implementa ActionListener

# 2) Registra il componente con questo listener. Se il pulsante è un componente che vogliamo registrare con l'ascoltatore, lo registreremo come segue:

button.addActionListener (instanceOfListenerclass);

# 3) Implementa / sovrascrivi il metodo actionPerformed ().

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

Quindi, utilizzando i passaggi precedenti, possiamo associare qualsiasi evento al componente GUI.

L'esempio seguente mostra un evento Click del pulsante utilizzando 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); } }

Produzione:

ActionListener in Java

Il programma precedente implementa un evento ActionListener. L'evento è l'evento clic del pulsante e ad esso abbiamo associato un ActionListener che visualizza il testo nel campo di testo facendo clic sul pulsante.

KeyListener in Java

Ogni volta che si verifica una modifica nello stato della chiave, viene notificato un KeyListener. Proprio come ActionListener, anche KeyListener si trova nel pacchetto java.awt.event.

L'interfaccia KeyListener fornisce i seguenti metodi:

public abstract void keyPressed (KeyEvent e);

public abstract void keyReleased (KeyEvent e);

public abstract void keyTyped (KeyEvent e);

Dobbiamo implementare i metodi precedenti per associare gli eventi chiave al componente. Lasciamo all'utente l'implementazione di un esempio di KeyListener utilizzando gli swing in Java.

Layout di oscillazione in Java

Quando sistemiamo vari componenti in un contenitore, diciamo che stiamo disponendo quei componenti. Quindi un layout può essere definito come il posizionamento di componenti in un contenitore.

Finché ci sono meno componenti, possono essere posizionati manualmente tramite trascinamento. Ma diventa difficile disporre i componenti in gran numero. A questo punto, il Layout Manager di Java viene in nostro aiuto.

LayoutManager è responsabile del layout dei componenti nelle applicazioni GUI. LayoutManager è un'interfaccia ed è implementata da tutte le classi di layout manager. Java fornisce le seguenti classi LayoutManager.

LayoutManagerDescrizione
javax.swing.GroupLayoutRaggruppa i componenti e quindi li posiziona nel contenitore.
java.awt.BorderLayoutI componenti sono disposti per adattarsi in cinque direzioni: centro, est, ovest, sud, nord.
java.awt.FlowLayoutQuesto è il layout predefinito. Depone i componenti nel flusso direzionale.
java.awt.GridLayoutDispone i componenti in una griglia rettangolare.
javax.swing.BoxLayoutI componenti sono disposti in una scatola.
java.awt.CardLayoutOgni componente è visto come una carta in un mazzo e alla volta è visibile solo un componente.
java.awt.GridBagLayoutDispone i componenti verticalmente, orizzontalmente o anche lungo le rispettive linee di base. I componenti non devono essere della stessa dimensione.
javax.swing.ScrollPaneLayoutUtilizzato dalla classe JScrollPane ed è responsabile della disposizione dei componenti in contenitori scorrevoli.
javax.swing.SpringLayout ecc.Viene fornito un insieme di vincoli come la distanza orizzontale e verticale tra i componenti, ecc. E i componenti sono disposti in base a questo insieme di vincoli.

In questo tutorial, discuteremo solo FlowLayout e GridLayout.

FlowLayout in Java

Il FlowLayout dispone i componenti in una direzione di flusso, uno dopo l'altro. Questo è il layout predefinito per i contenitori come Panel e Applet.

La classe FlowLayout in Java che rappresenta il gestore FlowLayout contiene i seguenti campi e costruttori.

Campi della classe FlowLayout

  • pubblico statico finale int LEADING
  • pubblico statico finale int TRAILING
  • public static final int LEFT
  • public static final int RIGHT
  • pubblico statico finale int CENTRO

I campi sopra definiscono le posizioni in cui i componenti verranno posizionati o allineati.

Costruttori della classe FlowLayout

  • FlowLayout (): Questo è un costruttore predefinito. Questo costruttore crea un layout di flusso con componenti allineati centralmente con una distanza predefinita di 5 unità in direzione orizzontale e verticale.
  • FlowLayout (int align): Questo costruttore crea un layout di flusso con il valore di allineamento specificato e con uno spazio orizzontale e verticale di 5 unità.
  • FlowLayout (int align, int hgap, int vgap): Crea un layout di flusso con un valore di allineamento specificato e uno spazio orizzontale e verticale.

Di seguito è riportato un esempio di 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(); } }

Produzione:

Costruttori della classe FlowLayout

GridLayout in Java

Usando GridLayout possiamo disporre i componenti in una griglia rettangolare, cioè ogni componente è disposto in ogni rettangolo.

Costruttori della classe GridLayout

  1. Layout della griglia (): costruttore predefinito che genera un layout di griglia con una colonna per un componente in una riga.
  2. GridLayout (int righe, int colonne): questo costruttore genera un layout a griglia con righe e colonne specificate. Non c'è spazio tra i componenti.
  3. GridLayout (int righe, int colonne, int hgap, int vgap): utilizzando questo costruttore, generiamo un layout a griglia con righe e colonne specificate e spazi orizzontali e verticali.

L'esempio seguente implementa 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(); } }

Produzione:

GridLayout in Java

Setbound in Java

Se controlliamo gli esempi di programmazione in questo tutorial prima dell'argomento layout, possiamo vedere che abbiamo impostato il layout come null in questi esempi (setLayout (null)). Abbiamo visto che quando usiamo i gestori di layout nel nostro programma, questi posizionano automaticamente i componenti.

Quando i gestori di layout non vengono utilizzati, è possibile utilizzare il metodo setBounds per le dimensioni e la posizione del componente. Quindi il metodo setBounds viene utilizzato per posizionare manualmente il componente e anche per impostare la dimensione.

La sintassi generale del metodo setBounds è la seguente:

setBounds (int x-coordinate, int y - coordinate, int larghezza, int altezza)

Implementiamo ora un esempio del metodo 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); } }

Produzione:

qual è la migliore app per spiare

Setbound in Java

Nel programma sopra, abbiamo un componente Button. Non abbiamo impostato alcun layout ma abbiamo utilizzato il metodo setBounds per impostarne la posizione e le dimensioni.

Swing Vs JavaFX

SwingJavaFX
Swing fornisce un'API per creare componenti GUI.JavaFX fornisce script e un veloce sviluppo dell'interfaccia utente associato a Screen Builder.
Non ci saranno nuove funzionalità aggiunte a Swing nelle versioni future.JavaFX fornisce funzionalità avanzate e ha il potenziale per ulteriori funzionalità nelle versioni future.
Possiamo creare tutti i componenti standard utilizzando Swing API.JavaFX ci consente di creare ricchi componenti GUI utilizzando aspetto e funzionalità avanzati.
Un gran numero di componenti sono presenti in Swing.JavaFX ha un numero di componenti relativamente inferiore.
Swing è una libreria dell'interfaccia utente con funzionalità complete.JavaFX è una nuova e futura API con ricchi componenti dell'interfaccia utente.
Swing ha un supporto MVC sciolto.JavaFX supporta il pattern MVC in modo coerente.

Domande frequenti

D # 1) Swing è ancora utilizzato in Java?

Risposta: Sì, Swing è ancora utilizzato in Java e questo è troppo pesante. A volte viene utilizzato come sostituto completo di AWT. A volte viene utilizzato anche insieme ad alcuni componenti AWT. Viene anche utilizzato con l'ultimo JavaFX. Quindi Swing è ancora usato e lo sarà ancora per molto tempo.

D # 2) Come funziona Java Swing?

Risposta: Swing in Java è scritto sopra il framework AWT. Quindi la gestione degli eventi di AWT viene ereditata completamente dallo swing. Swing fornisce anche un gran numero di componenti che possiamo utilizzare per sviluppare applicazioni GUI efficienti.

D # 3) Swing segue MVC?

Risposta: L'API Swing ha un supporto MVC libero. Il modello rappresenta i dati del componente. Il componente swing ha un elemento separato chiamato Model mentre Controller e View sono riuniti insieme negli elementi dell'interfaccia utente. Questo clubbing consente allo swing di avere un aspetto e una sensazione collegabili.

D # 4) JavaFX è migliore di Swing?

Risposta: Swing è in circolazione da molto tempo e ha un supporto IDE più maturo. Aveva anche una libreria molto ampia di componenti. JavaFX è relativamente più recente e ha una piccola libreria di componenti ma con aggiornamenti più coerenti e supporto MVC coerente. Quindi dipende da come JavaFX si sviluppa ulteriormente e fornisce più funzionalità.

D # 5) Quale è meglio AWT o Swing?

Risposta: Swing è basato su AWT e fornisce un set ricco e ampio di componenti dell'interfaccia utente rispetto ad AWT. I componenti Swing possono anche avere il loro aspetto rispetto ai componenti AWT che danno un aspetto e un tocco del sistema operativo.

I componenti Swing sono più veloci di AWT. Tutti questi fattori rendono lo swing migliore dell'AWT.

Ulteriori informazioni su Java Swing

Quando crei un'applicazione, inizialmente dovresti avere un contenitore di base e devi aggiungere i componenti richiesti come pulsanti e campi di testo nel contenitore.

E quando fai clic o esegui qualsiasi operazione su qualsiasi campo, l'evento si verificherà e il tuo codice dovrebbe ascoltare gli eventi e gestire anche l'evento.

Contenitore Swing

Un contenitore è un elemento radice per un'applicazione. Tutti gli altri componenti vengono aggiunti a quella radice e forma una gerarchia.

Esistono tre classi di contenitori:

  • JFrame
  • JDialog
  • JApplet

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

Demo del contenitore utilizzando JFrame

Quando esegui il programma precedente, otterrai l'output seguente.

contenitore di base

Componenti

La classe JComponent è una classe base per tutti i componenti in uno swing.

I componenti utilizzati di frequente includono,

  • JButton
  • JTextField
  • JTextArea
  • JRadioButton
  • JComboBox ecc.

Tutti questi componenti dovrebbero essere aggiunti al contenitore, altrimenti non appariranno nell'applicazione.

Esempio:

Per creare l'istanza del pulsante,

JButton clickButton = nuovo JButton ();

Per aggiungere il pulsante al contenitore,

myFrame.add ();

Gestione degli eventi

Tutte le applicazioni sono guidate da eventi come clic di pulsanti, clic del mouse, input di testo dell'utente, ecc. Quando si verifica l'evento, è necessario aggiungere un ascoltatore e passare l'oggetto evento di origine.

Con una classe interna, puoi gestire l'evento con la tua logica come mostrato di seguito.

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

Gestione degli eventi

Conclusione

In questo tutorial, abbiamo toccato le basi con l'API Swing fornita da Java per la creazione di applicazioni GUI. Abbiamo discusso i principali contenitori e componenti swing e la loro implementazione.

Abbiamo anche discusso della gestione degli eventi in Swing. Sebbene il meccanismo di gestione degli eventi sia AWT, swing implementa gli eventi in modo efficiente. Quindi abbiamo discusso i vari gestori di layout forniti dall'API Swing che ci consentono di disporre o disporre i vari componenti nelle applicazioni della GUI Swing.

=> Dai un'occhiata alla guida di formazione Java perfetta qui.

Lettura consigliata

^