java swing tutorial container
Aquest complet tutorial de vídeo Java Swing explica diversos components del GUI Swing Framework i conceptes relacionats com JPanel, JFrame, JButton, etc.:
Utilitzem interfícies gràfiques d’usuari (normalment anomenades GUI) per crear aplicacions que tinguin una interfície visual, facilitant l’ús de l’aplicació a l’usuari.
Disposar d’una interfície visual per a una aplicació facilita la navegació de l’aplicació, l’ús dels controls de manera més eficient i, a més, resulta atractiu visualment per a l’usuari.
Swing s'utilitza principalment per crear la GUI per a aplicacions.
=> Visiteu aquí per veure la sèrie de formació de Java per a tothom
Què aprendreu:
- Vídeo tutorial sobre Java Swing
- Què és Java Swing
- Components de Java Swing
- Classes de swing a Java
- Swing contra JavaFX
- Conclusió
Vídeo tutorial sobre Java Swing
Què és Java Swing
Java proporciona molts marcs GUI que ens ajuden a desenvolupar diverses aplicacions GUI. N’hem vist un al tutorial anterior, és a dir, Abstract Window Toolkit o AWT. AWT és un dels marcs GUI més antics de Java i també depèn de la plataforma. Un altre desavantatge d’AWT són els components pesants.
En aquest tutorial, parlarem d'un altre marc GUI a Java, és a dir, 'SWING'. El framework Swing de Java forma part de les classes de Java Foundation o comunament anomenades JFC. JFC és una API similar a MFC (classes de Microsoft Foundation) a C ++. JFC conté Swing, AWT i Java2D.
El framework Swing a Java es basa en el framework AWT i es pot utilitzar per crear aplicacions GUI igual que AWT. Però, a diferència de AWT, els components Swing són lleugers i són independents de la plataforma.
El framework Swing està escrit íntegrament en Java. El framework Swing a Java es proporciona a través del paquet ‘javax.swing’. Les classes del paquet javax.swing comencen amb la lletra ‘J’. Així doncs, en un paquet javax.swing, tindrem classes com JButton, JFrame, JTextField, JTextArea, etc.
En general, l'API Swing té tots els controls definits al paquet javax.swing que hi ha a AWT. De manera que el swing en certa manera actua com un substitut de AWT. A més, Swing té diversos panells amb pestanyes de components avançats. L'API Swing a Java adapta l'arquitectura MVC (Model View Controller).
Les principals característiques d’aquesta arquitectura són:
- Les dades del component swing es representen mitjançant Model.
- Es representa visualment mitjançant una vista.
- El component del controlador de l'arquitectura MVC llegeix l'entrada de l'usuari a la vista i després aquests canvis es passen a les dades del component.
- En cada component de Swing, la vista i el controlador es combinen mentre el model és diferent. D’aquesta manera, el swing ofereix un aspecte connectable.
Les característiques de l'API swing es resumeixen a continuació.
- Els components de swing són independents de la plataforma.
- L'API és extensible.
- Els components de swing són lleugers. Els components basculants s'escriuen en Java pur i també es representen mitjançant codi Java en lloc de trucades de sistema subjacents.
- L'API Swing proporciona un conjunt de controls avançats com TabbedPane, Tree, Colorpicker, controls de taula, etc., que són rics en funcionalitats.
- Els controls de swing són altament personalitzables. Això es deu al fet que l’aspecte o aparença del component és independent de la representació interna i, per tant, el podem personalitzar de la manera que desitgem.
- Simplement podem canviar els valors i, per tant, alterar l’aspecte en temps d’execució.
Components de Java Swing
Swing té un gran conjunt de components que podem incloure als nostres programes i aprofitar les riques funcionalitats mitjançant les quals podem desenvolupar aplicacions GUI altament personalitzades i eficients.
Llavors, què és un component?
Un component es pot definir com un control que es pot representar visualment i que sol ser independent. Té una funcionalitat específica i es representa com una classe individual a l'API de Swing.
Per exemple, La classe JButton in swing API és un component de botó i proporciona la funcionalitat d'un botó.
Un o més components formen un grup i aquest grup es pot col·locar en un 'contenidor'. Un contenidor proporciona un espai en el qual podem mostrar components i també gestionar-ne l’espaiat, el disseny, etc.
A Java, els contenidors es divideixen en dos tipus, tal com es mostra a continuació:
Classes de swing a Java
A continuació es mostra una jerarquia de l'API Swing a Java:
Com es veu a la jerarquia anterior, tenim classes de contenidors: marc, quadre de diàleg, tauler, applet, etc. També hi ha classes de components derivades de la classe JComponent de l'API Swing. Algunes de les classes que hereten de JComponent són JLabel, JList, JTextBox, etc.
Algunes de les classes importants de l'API Swing són les següents:
- JWindow: La classe JWindow de Swing hereta la classe Window directament. La classe JWindow utilitza 'BorderLayout' com a disseny predeterminat.
- JPanel: JPanel és descendent de la classe JComponent i està en línies similars a la classe AWT Panel i té com a disseny predeterminat 'FlowLayout'.
- JFrame: JFrame descendeix de la classe Frame. Els components afegits al marc s’anomenen continguts del marc.
- JLabel: La classe JLabel és una subclasse del JComponent. S'utilitza per crear etiquetes de text a l'aplicació.
- Botó J: La funcionalitat del botó a Swing la proporciona JButton. Podem associar una cadena, una icona o ambdues a l'objecte JButton.
- JTextField: La classe JTextField proporciona un camp de text en el qual podem editar una sola línia de text.
JFrame a Java
Un marc, en general, és un contenidor que pot contenir altres components com botons, etiquetes, camps de text, etc. Una finestra de marc pot contenir un títol, una vora i també menús, camps de text, botons i altres components. Una aplicació ha de contenir un marc perquè puguem afegir components al seu interior.
El marc a Java Swing es defineix a la classe javax.swing.JFrame. La classe JFrame hereta la classe java.awt.Frame. JFrame és com la finestra principal de l'aplicació GUI que utilitza swing.
Podem crear un objecte de finestra JFrame mitjançant dos enfocaments:
java passant una matriu a un mètode
# 1) Ampliant la classe JFrame
El primer enfocament és crear una nova classe per construir un Frame. Aquesta classe hereta de la classe JFrame del paquet javax.swing.
El programa següent implementa aquest enfocament.
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 } } Sortida:
# 2) Instantiant 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 } } Sortida:
Al programa anterior, hem creat un marc de la classe JFrame creant una instància de la classe JFrame.
JPanel a Java
Un tauler és un component que es troba dins d'una finestra de marc. Un marc pot tenir més d'un component de panell al seu interior i cada component de panell té diversos components.
En termes més senzills, podem utilitzar panells per particionar el marc. Cada panell agrupa diversos components al seu interior. En altres paraules, fem servir panells per organitzar components dins del marc.
La classe API swing que implementa el component del panell és JPanel. La classe JPanel hereta de JComponent i té FlowLayout com a disseny predeterminat.
El programa següent mostra la creació d'un contenidor de panell en un marc mitjançant classes de paquets 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 } } Sortida:
Aquí tenim un Frame. Dins del marc, creem un tauler. A continuació, dins del tauler, creem un botó. D'aquesta manera, podem utilitzar un tauler per subjectar els altres components.
JTextArea a Java
TextArea defineix un camp de text editable. Pot tenir diverses línies. La classe swing que defineix l'àrea de text és JTextArea i hereta la classe JTextComponent.
public class JTextArea estén JTextComponent
La classe JTextArea conté 4 constructors que ens permeten crear una àrea de text amb diverses opcions.
- JTextArea (): Constructor per defecte. Creeu una àrea de text buida.
- JTextArea (cadenes): Crea una àrea de text amb s com a valor per defecte.
- JTextArea (fila int, columna int): Crea una àrea de text amb una fila x columna especificada.
- JTextArea (cadena s, fila int, columna int): Crea un text are2a amb la fila x columna especificada i el valor per defecte s.
El següent programa Java mostra un exemple del component JTextArea al 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 } } Sortida:
JButton A Java
Un botó és un component que s’utilitza per crear un botó amb un nom o una etiqueta. Al swing, la classe que crea un botó etiquetat és JButton. JButton hereta la classe AbstractButton. Podem associar l’esdeveniment ActionListener al botó perquè faci alguna acció quan es prem.
Implantem un programa d'exemple per a JButton en 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); } } Sortida:
Llista J a Java
Una llista consta de diversos elements de text. Els usuaris poden seleccionar un element o diversos elements alhora. La classe que implementa la llista a l'API swing és JList. JList és un descendent de la classe JComponent.
A continuació es detallen els constructors de la classe JList.
- JList (): Constructor per defecte que crea una llista de només lectura buida.
- JList (array () listItem): Creeu una llista JL que inicialment contingui elements de la llista listItem.
- JList (ListModel dataModel): Crea una llista amb elements del model dataModel especificat.
A continuació es proporciona una demostració senzilla del component 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); } } Sortida:
Al programa anterior, primer definim un listModel amb entrades de color. A continuació, creem un objecte JList i hi afegim el listModel. A continuació, s’afegeix l’objecte JList a l’objecte de marc que després es mostra.
JComboBox a Java
La classe JCombobox mostra una llista d'opcions entre les quals un usuari pot seleccionar una opció. L’elecció seleccionada es troba a la part superior. JComboBox deriva de la classe JComponent.
Els següents són els constructors proporcionats per la classe JComboBox:
- JComboBox (): Constructor per defecte que crea un ComboBox amb el model de dades per defecte.
- JComboBox (objectes () elements): Aquest constructor crea un ComboBox que té elements com a elements dels elements de matriu donats.
- JComboBox (elements vectorials): Aquest constructor llegeix els elements del vector donat i construeix una ComboBox amb aquests elements com a elements.
La classe JComboBox també proporciona mètodes per afegir / eliminar elements, afegir ActionListener, ItemListener, etc.
L'exemple següent mostra la implementació de JComboBox a 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(); } } Sortida:
JSlider a Java
Un control lliscant ens permet seleccionar un rang de valors específic. A Java Swing API, JSlider és la classe que s’utilitza per implementar el control lliscant.
Els següents són els constructors proporcionats per la classe JSlider.
- JSlider (): un constructor per defecte que crea un control lliscant que té 50 com a valor inicial i rang 0 -100.
- JSlider (orientació int): aquest constructor crea un control lliscant igual que anterior, però amb una orientació especificada. El valor d’orientació pot ser JSlider.HORIZONTAL o JSlider.VERTICAL.
- JSlider (int min, int max): aquest constructor s'utilitza per crear un control lliscant horitzontal utilitzant el mínim i el màxim donats.
- JSlider (int min, int max, int value): aquest constructor crea un control lliscant que és horitzontal amb el valor especificat de min, max i valor.
- JSlider (int orientation, int min, int max, int value): aquest constructor construeix un control lliscant amb una orientació, min, max i valor especificats.
El programa següent mostra el JSlider a Java amb les paparres. Aquest programa també demostra l'ús dels mètodes compatibles amb 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); } } Sortida:
Gestió d'esdeveniments a Java
Un esdeveniment es pot definir com un canvi d'estat d'un objecte. Des del punt de vista de la GUI, es produeix un esdeveniment quan l'usuari final interactua amb els components de la GUI. Els esdeveniments que es desencadenen a la GUI poden ser el clic d’un botó, el desplaçament, la selecció d’elements de llista, el canvi de text, etc.
Els esdeveniments que es produeixen a la interfície gràfica d’usuari enumerats anteriorment són majoritàriament esdeveniments en primer pla. També podem tenir alguns esdeveniments en segon pla com la finalització de l'operació en segon pla, la caducitat del temporitzador, etc.
La gestió d'esdeveniments és un mecanisme mitjançant el qual s'actua quan es produeix un esdeveniment. Per a això, definim un mètode que també s'anomena gestor d'esdeveniments que es diu quan es produeix un esdeveniment. Java utilitza un mecanisme estàndard anomenat 'Model d'esdeveniments de delegació' per generar i gestionar esdeveniments.
El model d'esdeveniments de delegació consisteix en:
# 1) Font: La font de l'esdeveniment és l'objecte. L'objecte sobre el qual es produeix un esdeveniment és la font i la font és responsable d'enviar informació sobre l'esdeveniment al gestor d'esdeveniments.
# 2) Oient: L’oient no és res més que el gestor d’esdeveniments responsable d’actuar quan es produeix un esdeveniment. A Java, un oient és un objecte que espera en un esdeveniment. Un cop es produeix l'esdeveniment, l'oient processa l'esdeveniment.
El requisit és registrar l’oient amb l’objecte perquè, quan es produeixi un esdeveniment, l’oient pugui processar-lo.
Per exemple,per a un esdeveniment de clic de botó, podem tenir la següent seqüència de passos.
- L'usuari fa clic al botó que genera un esdeveniment de clic.
- Es crea l'objecte de classe d'esdeveniments adequat i les dades d'origen i esdeveniment es passen a aquest objecte.
- Aquest objecte d'esdeveniment es passa a la classe oient registrada amb l'objecte.
- L’oient s’executa i torna.
Ara parlem d'alguns dels oients que proporciona Java.
ActionListener A Java
Un actionListener és l’oient d’un botó o d’un element de menú. Quan fem clic a un botó, el botó Listener que hi participa és actionListener. L'accióListener es notifica a ActionEvent.
El paquet d'esdeveniments java.awt.an defineix la interfície ActionListener. Aquesta interfície només té un mètode actionPerformed ().
public abstract void actionPerformed (ActionEvent e);
Quan es fa clic a un component registrat com un botó, s'invoca automàticament el mètode actionPerformed ().
L'enfocament més comú per incloure ActionListener al programa és implementar la interfície ActionListener i després implementar el mètode actionPerformed ().
Els passos per implementar la classe ActionListener són els següents:
# 1) Implementar la interfície ActionListerner.
public class ActionListenerImpl Implementa ActionListener
# 2) Registreu el component amb aquest oient. Si el botó és un component que volem registrar a l’oient, el registrarem de la següent manera:
button.addActionListener (instanceOfListenerclass);
# 3) Implementar / substituir el mètode actionPerformed ().
public void actionPerformed (ActionEvent e){ //code to perform action }Per tant, mitjançant els passos anteriors, podem associar qualsevol esdeveniment al component GUI.
L'exemple següent mostra un esdeveniment Click de botó mitjançant 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); } } Sortida:
El programa anterior implementa un esdeveniment ActionListener. L'esdeveniment és l'esdeveniment de clic de botó i, amb ell, hem associat un ActionListener que mostra el text al camp de text fent clic al botó.
KeyListener a Java
Sempre que es produeix un canvi en l’estat de la clau, es notifica un KeyListener. Igual que ActionListener, KeyListener també es troba al paquet java.awt.event.
La interfície KeyListener proporciona els mètodes següents:
public abstract void keyPressed (KeyEvent e);
com obrir .jar a Windows 10
public abstract void keyReleased (KeyEvent e);
public abstract void keyTyped (KeyEvent e);
Hem d’implementar els mètodes anteriors per associar els esdeveniments clau amb el component. Deixem a l’usuari implementar un exemple de KeyListener mitjançant swing en Java.
Dissenys de swing a Java
Quan disposem diversos components en un contenidor, diem que disposem aquests components. Per tant, un disseny es pot definir com el posicionament de components en un contenidor.
Sempre que hi hagi menys components, es poden col·locar arrossegant-los manualment. Però es fa difícil disposar els components en grans quantitats. En aquest moment, el gestor de disseny de Java ens ajuda.
LayoutManager és responsable del disseny dels components a les aplicacions GUI. LayoutManager és una interfície i és implementat per totes les classes de gestors de disseny. Java proporciona les següents classes de LayoutManager.
| LayoutManager | Descripció |
|---|---|
| javax.swing.GroupLayout | Agrupa els components i els col·loca al contenidor. |
| java.awt.BorderLayout | Els components es distribueixen per adaptar-se a cinc direccions: centre, est, oest, sud, nord. |
| java.awt.FlowLayout | Aquest és el disseny predeterminat. Col·loca els components en el flux direccional. |
| java.awt.GridLayout | Disposa els components en una quadrícula rectangular. |
| javax.swing.BoxLayout | Els components es disposen en una caixa. |
| java.awt.CardLayout | Cada component es veu com una carta en una baralla i alhora només es veu un component. |
| java.awt.GridBagLayout | Organitza els components verticalment, horitzontalment o fins i tot al llarg de les seves línies base. Els components no han de tenir la mateixa mida. |
| javax.swing.ScrollPaneLayout | Utilitzat per la classe JScrollPane i s’encarrega d’organitzar components en contenidors desplaçables. |
| javax.swing.SpringLayout etc. | Es proporciona un conjunt de restriccions, com ara la distància horitzontal i vertical entre components, etc., i els components es disposen d'acord amb aquest conjunt de restriccions. |
En aquest tutorial, només parlarem de FlowLayout i GridLayout.
FlowLayout a Java
El FlowLayout organitza els components en una direcció de flux, un darrere l’altre. Aquest és el disseny predeterminat per a contenidors com Panel i Applet.
La classe FlowLayout de Java que representa el gestor FlowLayout conté els següents camps i constructors.
Camps de classe FlowLayout
- públic estàtic final int LÍDER
- public static final int TRAILING
- públic estàtic final int ESQUERRA
- públic estàtic final int DRET
- públic estàtic final int CENTRE
Els camps anteriors defineixen les posicions en què es col·locaran o alinearan els components.
Constructors de la classe FlowLayout
- FlowLayout (): Aquest és un constructor per defecte. Aquest constructor crea un disseny de flux amb components alineats centralment amb un espai predeterminat de 5 unitats en la direcció horitzontal i vertical.
- FlowLayout (int align): Aquest constructor crea un disseny de flux amb el valor d'alineació especificat i amb un espai horitzontal i vertical de 5 unitats.
- FlowLayout (int align, int hgap, int vgap): Crea un disseny de flux amb un valor d’alineació especificat i un espai horitzontal i vertical.
A continuació es mostra un exemple de FlowLayout a 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(); } } Sortida:
GridLayout a Java
Mitjançant GridLayout podem dissenyar els components de forma quadrícula rectangular, és a dir, cada component està disposat en cada rectangle.
Constructors de la classe GridLayout
- GridLayout (): constructor per defecte que genera un disseny de quadrícula amb una columna per un component seguit.
- GridLayout (files int, columnes int): aquest constructor genera un disseny de quadrícula amb files i columnes especificades. No hi ha cap bretxa entre els components.
- GridLayout (int files, int columnes, int hgap, int vgap): utilitzant aquest constructor, generem un disseny de quadrícula amb files i columnes especificades i espais horitzontals i verticals.
L'exemple següent implementa el GridLayout a 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(); } } Sortida:
Configuració a Java
Si comprovem els exemples de programació d’aquest tutorial abans del tema del disseny, podem veure que hem establert el disseny com a nul en aquests exemples (setLayout (nul)). Hem vist que quan fem servir gestors de disseny al nostre programa, posicionen automàticament els components.
Quan no s’utilitzen gestors de disseny, podem utilitzar el mètode setBounds segons la mida i la posició del component. Per tant, el mètode setBounds s’utilitza per col·locar manualment el component i també establir la mida.
La sintaxi general del mètode setBounds és la següent:
setBounds (int x-coordinate, int y - coordinate, int width, int height)
Implantem ara un exemple del mètode 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); } } Sortida:
ordre d'inserció a c ++
Al programa anterior, tenim un component Button. No hem establert cap disseny, però hem utilitzat el mètode setBounds per establir la seva posició i dimensions.
Swing contra JavaFX
| Swing | JavaFX |
|---|---|
| Swing proporciona una API per crear components GUI. | JavaFX proporciona scripts i un desenvolupament ràpid de la interfície d’usuari associat al generador de pantalles. |
| No hi haurà cap nova funcionalitat afegida a Swing en futures versions. | JavaFX proporciona una funcionalitat completa i té el potencial de més funcions en versions futures. |
| Podem crear tots els components estàndard mitjançant l’API Swing. | JavaFX ens permet crear components GUI rics utilitzant un aspecte avançat. |
| Hi ha un gran nombre de components a Swing. | JavaFX té un nombre de components comparativament menor. |
| Swing és una biblioteca d'interfície d'usuari amb funcions completes. | JavaFX és una nova i pròxima API amb components d’interfície d’usuari rics. |
| Swing té un suport MVC fluix. | JavaFX admet patrons MVC de manera constant. |
Preguntes freqüents
P # 1) Es continua utilitzant Swing a Java?
Resposta: Sí, Swing encara s’utilitza a Java i és massa intens. De vegades s'utilitza com a substitutiu complet d'AWT. De vegades també s'utilitza juntament amb alguns dels components AWT. Fins i tot s’utilitza amb l’última versió de JavaFX. Per tant, Swing encara s’utilitza i s’utilitzarà durant molt de temps.
Q # 2) Com funciona Java Swing?
Resposta: Swing a Java s'escriu a sobre del marc AWT. Per tant, el tractament d'esdeveniments d'AWT és heretat per swing completament. Swing també proporciona una gran quantitat de components que podem utilitzar per desenvolupar aplicacions GUI eficients.
P # 3) Swing segueix MVC?
Resposta: L'API Swing té un suport MVC fluix. El model representa les dades del component. El component basculant té un element separat anomenat Model, mentre que el controlador i la visualització es combinen en elements de la interfície d’usuari. Aquesta mànega permet que el gronxador tingui un aspecte connectable.
Q # 4) JavaFX és millor que Swing?
Resposta: Swing existeix des de fa molt de temps i té un suport IDE més madur. També tenia una biblioteca de components molt gran. JavaFX és relativament més recent i té una petita biblioteca de components, però amb actualitzacions més consistents i compatibilitat amb MVC consistent. Per tant, depèn de com es desenvolupi JavaFX i ofereixi més funcions.
P # 5) Què és millor AWT o Swing?
Resposta: Swing està construït sobre AWT i proporciona un conjunt ric i ampli de components de la IU en comparació amb AWT. Els components basculants també poden tenir el seu aspecte i els components AWT que tenen un aspecte del sistema operatiu.
Els components de swing són més ràpids que AWT. Tots aquests factors fan que el swing sigui millor que AWT.
Més informació sobre Java Swing
Quan creeu una aplicació, inicialment haureu de tenir un contenidor base i haureu d'afegir els components necessaris, com ara botons i camps de text, al contenidor.
I quan feu clic o realitzeu qualsevol operació en qualsevol camp, es produirà l'esdeveniment i el vostre codi hauria d'escoltar els esdeveniments i gestionar-lo.
Contenidor Swing
Un contenidor és un element arrel d'una aplicació. Tots els altres components s’afegeixen a aquesta arrel i forma una jerarquia.
Hi ha tres classes de contenidors:
- JFrame
- JDialog
- JApplet
Demostració de contenidors mitjançant 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); } } 
Quan executeu el programa anterior, obtindreu la sortida següent.
Components
La classe JComponent és una classe base per a tots els components d'un swing.
Els components d'ús freqüent inclouen:
- JButton
- JTextField
- JTextArea
- JRadioButton
- JComboBox, etc.
Tots aquests components s’han d’afegir al contenidor si no, no apareixerà a l’aplicació.
Exemple:
Per crear la instància del botó,
JButton clickButton = new JButton ();
Per afegir el botó al contenidor,
myFrame.add ();
Gestió d'esdeveniments
Totes les aplicacions estan impulsades per esdeveniments com ara clics de botons, clics de ratolí, entrada de text de l'usuari, etc.
Amb una classe interna, podeu gestionar l'esdeveniment amb la vostra lògica, tal com es mostra a continuació.
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(); } } 
Conclusió
En aquest tutorial, hem tocat la base amb l'API Swing proporcionada per Java per crear aplicacions GUI. Hem discutit els principals contenidors i components oscil·lants i la seva implementació.
També hem debatut sobre el tractament d'esdeveniments a Swing. Tot i que el mecanisme de gestió d'esdeveniments és AWT, swing implementa els esdeveniments d'una manera eficient. A continuació, hem debatut sobre els diversos gestors de disseny proporcionats per l'API de Swing que ens permeten dissenyar o organitzar diversos components a les aplicacions de Swing GUI.
=> Consulteu la guia de formació Java perfecta aquí.
Lectura recomanada
- Tutorial de reflexió de Java amb exemples
- Tutorial JAVA per a principiants: més de 100 tutorials pràctics de vídeo Java
- Tutorial sobre Java Collections Framework (JCF)
- Modificadors d'accés a Java: tutorial amb exemples
- Java String amb buffer de cadenes i tutorial de Generador de cadenes
- Introducció al llenguatge de programació Java: vídeo tutorial