Menu

Výukový program Java SWING: Kontejner, komponenty a zpracování událostí

  • Hlavní
  • Jiný
  • Výukový program Java SWING: Kontejner, komponenty a zpracování událostí

java swing tutorial container

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Tento komplexní výukový program Java Swing vysvětluje různé komponenty GUI Swing Framework a související koncepty jako JPanel, JFrame, JButton atd.:

K vytváření aplikací, které mají vizuální rozhraní, používáme grafická uživatelská rozhraní (běžně nazývaná GUI), které uživateli usnadňují používání aplikace.

Díky vizuálnímu rozhraní pro aplikaci se aplikace snadno orientuje, efektivněji používá ovládací prvky a také je vizuálně přitažlivá pro uživatele.

Swing se používá hlavně k vytváření grafického uživatelského rozhraní pro aplikace.

=> Navštivte zde a prohlédněte si sérii školení Java pro všechny.

Java SWING

Co se naučíte:

Výukový program o hrách Java Swing

Co je to Java Swing

Java poskytuje mnoho rámců GUI, které nám pomáhají při vývoji různých aplikací GUI. Viděli jsme jeden v našem předchozím tutoriálu, tj. Abstract Window Toolkit nebo AWT. AWT je jedním z nejstarších GUI frameworků v Javě a je také závislý na platformě. Další nevýhodou AWT jsou jeho těžké komponenty.

V tomto tutoriálu probereme ještě další rámec GUI v Javě, tj. „SWING“. Rámec Swing v Javě je součástí Java Foundation Classes nebo se běžně nazývá JFC. JFC je rozhraní API, které je podobné MFC (Microsoft Foundation Classes) v C ++. JFC obsahuje Swing, AWT a Java2D.

Rámec Swing v Javě je postaven na vrcholu rámce AWT a lze jej použít k vytváření aplikací GUI stejně jako AWT. Ale na rozdíl od AWT jsou komponenty Swing lehké a nezávislé na platformě.

Rámec Swing je napsán výhradně v Javě. Rámec Swing v Javě je poskytován prostřednictvím balíčku „javax.swing“. Třídy v balíčku javax.swing začínají písmenem „J“. Takže v balíčku javax.swing budeme mít třídy jako JButton, JFrame, JTextField, JTextArea atd.

Obecně má Swing API každý ovládací prvek definovaný v balíčku javax.swing, který je přítomen v AWT. Takže houpačka svým způsobem funguje jako náhrada AWT. Swing má také různé panely záložek s pokročilými komponentami. Swing API v Javě přizpůsobuje architekturu MVC (Model View Controller).

Hlavní charakteristiky této architektury jsou:

  • Data otočné komponenty jsou reprezentována pomocí modelu.
  • Je vizuálně znázorněno pomocí pohledu.
  • Komponenta řadiče architektury MVC čte vstup od uživatele v pohledu a poté jsou tyto změny předány datům komponenty.
  • V každé komponentě Swing jsou pohled a ovladač spojeny dohromady, zatímco model je samostatný. To dává houpačce zásuvný vzhled a chování.

Funkce swing API jsou shrnuty níže.

  1. Swing komponenty jsou nezávislé na platformě.
  2. Rozhraní API je rozšiřitelné.
  3. Swing komponenty jsou lehké. Swing komponenty jsou psány v čisté Javě a také komponenty jsou vykreslovány pomocí Java kódu místo základních systémových volání.
  4. Swing API poskytuje sadu pokročilých ovládacích prvků, jako jsou TabbedPane, Tree, Colorpicker, ovládací prvky tabulky atd., Které jsou bohaté na funkčnost.
  5. Ovládací prvky kývání jsou vysoce přizpůsobitelné. Je to proto, že vzhled nebo vzhled komponenty je nezávislý na vnitřní reprezentaci, a proto jej můžeme přizpůsobit tak, jak si přejeme.
  6. Můžeme jednoduše změnit hodnoty a tak změnit vzhled a chování za běhu.

Komponenty Java Swing

Swing má velkou sadu komponent, které můžeme zahrnout do našich programů a využívat bohaté funkce, pomocí kterých můžeme vyvíjet vysoce přizpůsobené a efektivní aplikace GUI.

Co je tedy součást?

Složku lze definovat jako ovládací prvek, který lze vizuálně znázornit a je obvykle nezávislý. Má specifickou funkčnost a je reprezentován jako samostatná třída v Swing API.

Například, třída JButton v swing API je komponenta tlačítka a poskytuje funkčnost tlačítka.

Jedna nebo více komponent tvoří skupinu a tuto skupinu lze umístit do „kontejneru“. Kontejner poskytuje prostor, ve kterém můžeme zobrazit komponenty a také spravovat jejich rozestupy, rozložení atd.

V Javě jsou kontejnery rozděleny do dvou typů, jak je znázorněno níže:

Typy kontejnerů

Třídy Swing v Javě

Níže je uvedena hierarchie Swing API v Javě:

Úvod do kurzů swingu

Jak je vidět z výše uvedené hierarchie, máme třídy kontejnerů - rám, dialog, panel, applet atd. Existují také třídy komponent odvozené od třídy JComponent Swing API. Některé z tříd, které dědí z JComponent, jsou JLabel, JList, JTextBox atd.

Některé z důležitých tříd Swing API jsou následující:

  • JWindow: Třída JWindow Swing dědí třídu Window přímo. Třída JWindow používá jako výchozí rozložení ‚BorderLayout '.
  • JPanel: JPanel je potomkem třídy JComponent a je na podobných řádcích jako Panel třídy AWT a jako výchozí rozložení má ‚FlowLayout '.
  • JFrame: JFrame sestupuje ze třídy Frame. Komponenty přidané do rámečku se nazývají obsah rámečku.
  • JLabel: Třída JLabel je podtřídou JComponent. Slouží k vytváření textových štítků v aplikaci.
  • JButton: Funkčnost tlačítka ve Swingu poskytuje JButton. K objektu JButton můžeme přidružit řetězec, ikonu nebo obojí.
  • JTextField: Třída JTextField poskytuje textové pole, ve kterém můžeme upravovat jeden řádek textu.

JFrame v Javě

Rámec je obecně kontejner, který může obsahovat další součásti, jako jsou tlačítka, štítky, textová pole atd. Okno Rámec může obsahovat nadpis, ohraničení a také nabídky, textová pole, tlačítka a další součásti. Aplikace by měla obsahovat rámec, abychom do něj mohli přidat komponenty.

Rám v Java Swing je definován ve třídě javax.swing.JFrame. Třída JFrame dědí třídu java.awt.Frame. JFrame je jako hlavní okno aplikace GUI pomocí swingu.

Objekt okna JFrame můžeme vytvořit pomocí dvou přístupů:

detekce úniku paměti c ++

# 1) Rozšířením třídy JFrame

Prvním přístupem je vytvoření nové třídy pro konstrukci Frame. Tato třída dědí ze třídy JFrame balíčku javax.swing.

Následující program implementuje tento přístup.

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

Výstup:

Rozšířením třídy JFrame

# 2) Vytvořením instance třídy 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 } }

Výstup:

Vytvořením instance třídy JFrame

Ve výše uvedeném programu jsme vytvořili rámec ze třídy JFrame vytvořením instance třídy JFrame.

JPanel v Javě

Panel je komponenta, která je obsažena uvnitř okna rámu. Rámeček může mít uvnitř více než jednu panelovou komponentu, přičemž každá panelová komponenta má několik dalších komponent.

Jednoduše řečeno, k rozdělení rámu můžeme použít panely. Každý panel v něm seskupuje několik dalších komponent. Jinými slovy, panely používáme k uspořádání komponent uvnitř rámu.

Třída swing API, která implementuje komponentu panelu, je JPanel. Třída JPanel dědí z JComponent a má FlowLayout jako výchozí rozložení.

Následující program demonstruje vytvoření kontejneru panelu v rámci pomocí tříd balíčků 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 } }

Výstup:

JPanel v Javě

Tady máme Rám. Uvnitř rámu vytvoříme panel. Pak uvnitř panelu vytvoříme tlačítko. Tímto způsobem můžeme použít panel k přidržení ostatních komponent.

JTextArea v Javě

TextArea definuje upravitelné textové pole. Může mít více řádků. Třída swing, která definuje textovou oblast, je JTextArea a dědí třídu JTextComponent.

veřejná třída JTextArea rozšiřuje JTextComponent

Třída JTextArea obsahuje 4 konstruktory, které nám umožňují vytvořit textovou oblast s různými možnostmi.

  • JTextArea (): Výchozí konstruktor. Vytvořte prázdnou textovou oblast.
  • JTextArea (String s): Vytvoří textovou oblast s jako výchozí hodnotou s.
  • JTextArea (int řádek, int sloupec): Vytvoří textovou oblast se zadaným řádkem x sloupcem.
  • JTextArea (String s, int řádek, int sloupec): Vytvoří text are2a se zadaným řádkem x sloupcem a výchozí hodnotou s.

Následující program Java ukazuje příklad komponenty JTextArea ve swingu.

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

Výstup:

JTextArea v Javě

JButton v Javě

Tlačítko je součást, která se používá k vytvoření tlačítka se jménem nebo štítkem. V houpačce je třída, která vytváří označené tlačítko, JButton. JButton dědí třídu AbstractButton. Událost ActionListener můžeme přidružit k tlačítku, aby po jeho provedení mohla provést nějakou akci.

Implementujme ukázkový program pro JButton ve výkyvech 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); } }

Výstup:

JButton v Javě

JList V Javě

Seznam se skládá z více textových položek. Uživatelé si mohou vybrat jednu nebo více položek najednou. Třída, která implementuje seznam v swing API, je JList. JList je potomkem třídy JComponent.

Níže jsou uvedeny konstruktory třídy JList.

  • JList (): Výchozí konstruktor, který vytvoří prázdný seznam jen pro čtení.
  • JList (pole () listItem): Vytvořte JList, který zpočátku obsahuje prvky pole listItem.
  • JList (ListModel dataModel): Vytvoří seznam s prvky ze zadaného modelu dataModel.

Níže je uvedena jednoduchá ukázka komponenty 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); } }

Výstup:

JList v Javě

Ve výše uvedeném programu nejprve definujeme listModel s barevnými položkami. Potom vytvoříme objekt JList a přidáme k němu listModel. Dále je objekt JList přidán k objektu rámce, který je poté zobrazen.

JComboBox v Javě

Třída JCombobox zobrazuje seznam možností, ze kterých může uživatel vybrat možnost. Vybraná volba je nahoře. JComboBox pochází z třídy JComponent.

Následují konstruktory poskytované třídou JComboBox:

jaký je nejlepší stahovač mp3
  • JComboBox (): Výchozí konstruktor, který vytvoří ComboBox s výchozím datovým modelem.
  • JComboBox (Object () položky): Tento konstruktor vytvoří ComboBox, který má položky jako prvky z daných položek pole.
  • JComboBox (vektorové položky): Tento konstruktor přečte prvky daného vektoru a vytvoří ComboBox s těmito prvky jako jeho položkami.

Třída JComboBox také poskytuje metody pro přidání / odebrání položek, přidání ActionListener, ItemListener atd.

Následující příklad ukazuje implementaci JComboBox v Javě.

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

Výstup:

Implementace JComboBox

JSlider v Javě

Posuvník nám umožňuje vybrat konkrétní rozsah hodnot. V rozhraní Java Swing API je JSlider třída, která se používá k implementaci posuvníku.

Následují konstruktory poskytované třídou JSlider.

  • JSlider (): Výchozí konstruktor, který vytvoří posuvník, který má 50 jako počáteční hodnotu a rozsah 0-100.
  • JSlider (int orientace): Tento konstruktor vytvoří posuvník stejně jako výše, ale se zadanou orientací. Hodnota orientace může být buď JSlider.HORIZONTAL nebo JSlider.VERTICAL.
  • JSlider (int min, int max): Tento konstruktor se používá k vytvoření vodorovného posuvníku pomocí daných min a max.
  • JSlider (int min, int max, int value): Tento konstruktor vytvoří posuvník, který je vodorovný se zadanou hodnotou min, max a value.
  • JSlider (int orientace, int min, int max, int hodnota): Tento konstruktor vytvoří posuvník se zadanou orientací, min, max a hodnotou.

Následující program demonstruje JSlider v Javě pomocí značek. Tento program také demonstruje použití metod podporovaných třídou 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); } }

Výstup:

JSlider v Javě

Zpracování událostí v Javě

Událost lze definovat jako změnu stavu objektu. Z hlediska grafického uživatelského rozhraní dojde k události, když koncový uživatel interaguje s komponentami grafického uživatelského rozhraní. Události, které se spustí v grafickém uživatelském rozhraní, mohou být kliknutí na tlačítko, posouvání, výběr položek seznamu, změna textu atd.

Událost vyskytující se v GUI uvedeném výše jsou většinou popředí. Můžeme také mít některé události na pozadí, jako je dokončení operace na pozadí, vypršení platnosti časovače atd.

Zpracování událostí je mechanismus, jehož prostřednictvím se při výskytu události provede akce. K tomu definujeme metodu, která se také nazývá obslužná rutina události, která se volá, když dojde k události. Java používá ke generování a zpracování událostí standardní mechanismus zvaný „Model události delegování“.

Model události delegace se skládá z:

# 1) Zdroj: Zdrojem události je objekt. Objekt, na kterém k události dojde, je zdroj a zdroj je zodpovědný za odesílání informací o události obslužné rutině události.

# 2) Posluchač: Posluchač není nic jiného než obsluha události odpovědná za provedení akce, když dojde k události. V Javě je posluchač objekt, který čeká na událost. Jakmile k události dojde, posluchač ji zpracuje.

Požadavkem je registrace posluchače u objektu, aby jej při výskytu události mohl posluchač zpracovat.

Například,pro událost kliknutí na tlačítko můžeme mít následující posloupnost kroků.

  1. Uživatel klikne na tlačítko, které generuje událost Click.
  2. Vytvoří se příslušný objekt třídy události a zdroj a data události se předají tomuto objektu.
  3. Tento objekt události se poté předá třídě posluchače registrované u objektu.
  4. Posluchač provede a vrátí se.

Nyní pojďme diskutovat o některých posluchačích poskytovaných Javou.

ActionListener v Javě

ActionListener je posluchač tlačítka nebo položky nabídky. Když klikneme na tlačítko, je to tlačítko Listener, které je zapojeno, actionListener. ActionListener je upozorněn v ActionEvent.

Balíček události java.awt.an definuje rozhraní ActionListener. Toto rozhraní má pouze jednu metodu actionPerformed ().

public abstract void actionPerformed (ActionEvent e);

Po kliknutí na zaregistrovanou komponentu, jako je Button, se automaticky vyvolá metoda actionPerformed ().

Nejběžnějším přístupem k zahrnutí ActionListener do programu je implementace rozhraní ActionListener a následná implementace metody actionPerformed ().

Kroky k implementaci třídy ActionListener jsou následující:

# 1) Implementujte rozhraní ActionListerner.

public class ActionListenerImpl Implementuje ActionListener

# 2) Zaregistrujte komponentu u tohoto posluchače. Pokud je tlačítko komponentou, kterou chceme zaregistrovat u posluchače, zaregistrujeme ji následujícím způsobem:

button.addActionListener (instanceOfListenerclass);

# 3) Implementujte / přepište metodu actionPerformed ().

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

Takže pomocí výše uvedených kroků můžeme přidružit jakoukoli událost ke komponentě GUI.

Následující příklad ukazuje událost Click Button pomocí 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); } }

Výstup:

ActionListener v Javě

Výše uvedený program implementuje událost ActionListener. Událost je událost Click button as ní jsme přidružili ActionListener, který po kliknutí na tlačítko zobrazí text v textovém poli.

KeyListener v Javě

Kdykoli dojde ke změně stavu klíče, je upozorněn KeyListener. Stejně jako ActionListener se KeyListener nachází také v balíčku java.awt.event.

Rozhraní KeyListener poskytuje následující metody:

public abstract void keyPressed (KeyEvent e);

public abstract void keyReleased (KeyEvent e);

public abstract void keyTyped (KeyEvent e);

Potřebujeme implementovat výše uvedené metody pro přidružení klíčových událostí ke komponentě. Necháme na uživateli, aby implementoval příklad KeyListener pomocí výkyvů v Javě.

Swing Layouts v Javě

Když uspořádáme různé komponenty do kontejneru, řekneme, že tyto komponenty rozložíme. Rozložení tedy lze definovat jako umístění komponent v kontejneru.

Dokud existuje méně komponent, lze je umístit přetažením ručně. Je však obtížné uspořádat velké množství komponent. V tomto okamžiku nám pomáhá Layout Manager Java.

LayoutManager je zodpovědný za rozložení komponent v aplikacích GUI. LayoutManager je rozhraní a je implementováno všemi třídami správce rozložení. Java poskytuje následující třídy LayoutManager.

LayoutManagerPopis
javax.swing.GroupLayoutSeskupí komponenty a poté je umístí do kontejneru.
java.awt.BorderLayoutKomponenty jsou rozloženy tak, aby se vešly do pěti směrů, a to na střed, východ, západ, jih, sever.
java.awt.FlowLayoutToto je výchozí rozložení. Položí komponenty do směrového toku.
java.awt.GridLayoutUspořádá komponenty do obdélníkové mřížky.
javax.swing.BoxLayoutSoučásti jsou uspořádány v krabici.
java.awt.CardLayoutKaždá komponenta je v balíčku viděna jako karta a najednou je viditelná pouze jedna komponenta.
java.awt.GridBagLayoutUspořádá komponenty svisle, vodorovně nebo dokonce podél jejich základních linií. Komponenty nemusí mít stejnou velikost.
javax.swing.ScrollPaneLayoutPoužívá se třídou JScrollPane a odpovídá za uspořádání komponent v rolovatelných kontejnerech.
javax.swing.SpringLayout atd.Je poskytnuta sada omezení, jako je vodorovná a svislá vzdálenost mezi komponentami atd., A komponenty jsou uspořádány podle této sady omezení.

V tomto kurzu budeme diskutovat pouze o FlowLayout a GridLayout.

FlowLayout v Javě

FlowLayout uspořádá komponenty ve směru toku, jednu po druhé. Toto je výchozí rozložení pro kontejnery jako Panel a Applet.

Třída FlowLayout v Javě, která představuje správce FlowLayout, obsahuje následující pole a konstruktory.

Pole třídy FlowLayout

  • public static final int VEDENÍ
  • public static final int TRAILING
  • public static final int VLEVO
  • public static final int RIGHT
  • veřejné statické konečné int CENTRUM

Výše uvedená pole definují pozice, na které budou komponenty umístěny nebo zarovnány.

Konstruktory třídy FlowLayout

  • FlowLayout (): Toto je výchozí konstruktor. Tento konstruktor vytvoří rozložení toku, které má centrálně zarovnané komponenty s výchozí mezerou 5 jednotek ve vodorovném a svislém směru.
  • FlowLayout (int align): Tento konstruktor vytvoří rozložení toku se zadanou hodnotou zarovnání as vodorovnou a svislou mezerou 5 jednotek.
  • FlowLayout (int align, int hgap, int vgap): Vytvoří rozložení toku se zadanou hodnotou zarovnání a vodorovnou a svislou mezerou.

Níže je uveden příklad FlowLayout v Javě.

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

Výstup:

Konstruktory třídy FlowLayout

GridLayout v Javě

Pomocí GridLayout můžeme komponenty rozložit obdélníkovým způsobem mřížky, tj. Každá součást je uspořádána v každém obdélníku.

Konstruktory třídy GridLayout

  1. Rozvržení mřížky (): výchozí konstruktor, který generuje rozložení mřížky s jedním sloupcem na jednu komponentu v řádku.
  2. GridLayout (int řádky, int sloupce): Tento konstruktor generuje rozložení mřížky se zadanými řádky a sloupci. Mezi komponenty není mezera.
  3. GridLayout (int řádky, int sloupce, int hgap, int vgap): Pomocí tohoto konstruktoru, generujeme rozložení mřížky se zadanými řádky a sloupci a vodorovnými a svislými mezerami.

Následující příklad implementuje GridLayout v Javě.

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

Výstup:

GridLayout v Javě

Hranice v Javě

Pokud zkontrolujeme příklady programování v tomto kurzu před tématem rozložení, můžeme vidět, že jsme v těchto příkladech nastavili rozložení jako null (setLayout (null)). Viděli jsme, že když v našem programu použijeme správce rozvržení, automaticky umístí komponenty.

Když se správci rozložení nepoužívají, můžeme použít metodu setBounds na velikost a umístění komponenty. Metoda setBounds se tedy používá k ručnímu umístění komponenty a také k nastavení velikosti.

Obecná syntaxe metody setBounds je následující:

setBounds (int x-coordinate, int y - coordinate, int width, int height)

Pojďme nyní implementovat příklad metody 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); } }

Výstup:

C ++ rozhovor otázky pro zkušené

Hranice v Javě

Ve výše uvedeném programu máme komponentu Button. Nenastavili jsme žádné rozložení, ale k nastavení jeho polohy a rozměrů jsme použili metodu setBounds.

Swing Vs JavaFX

HoupačkaJavaFX
Swing poskytuje API pro vytváření komponent GUI.JavaFX poskytuje skripty a rychlý vývoj uživatelského rozhraní spojený s nástrojem pro tvorbu obrazovky.
V budoucích verzích nebude do Swingu přidána žádná nová funkce.JavaFX poskytuje bohaté funkce a má potenciál pro další funkce v budoucích verzích.
Můžeme vytvořit všechny standardní komponenty pomocí Swing API.JavaFX nám umožňuje vytvářet bohaté komponenty grafického uživatelského rozhraní pomocí pokročilého vzhledu a chování.
Swing obsahuje velké množství komponent.JavaFX má poměrně menší počet komponent.
Swing je plně vybavená knihovna uživatelského rozhraní.JavaFX je nové a připravované API s bohatými komponenty uživatelského rozhraní.
Swing má volnou podporu MVC.JavaFX důsledně podporuje vzor MVC.

Často kladené otázky

Otázka 1) Používá se Swing v Javě stále?

Odpovědět: Ano, Swing se v Javě stále používá a to příliš silně. Někdy se používá jako úplná náhrada za AWT. Někdy se také používá spolu s některými komponentami AWT. Používá se dokonce s nejnovější verzí JavaFX. Swing je tedy stále používán a bude používán ještě dlouho.

Otázka 2) Jak funguje Java Swing?

Odpovědět: Swing v Javě je napsán nad rámec AWT. Zpracování událostí AWT je tedy zcela zděděno swingem. Swing také poskytuje velké množství komponent, které můžeme použít k vývoji efektivních aplikací GUI.

Otázka č. 3) Sleduje Swing MVC?

Odpovědět: Swing API má volnou podporu MVC. Model představuje data komponenty. Swing komponenta má samostatný prvek s názvem Model, zatímco Controller a View jsou udeřeny dohromady v prvcích uživatelského rozhraní. Tato hůl umožňuje houpačce vypadat a cítit se dobře.

Otázka č. 4) Je JavaFX lepší než Swing?

Odpovědět: Swing je tu už dlouho a má vyspělejší podporu IDE. Mělo také velmi velkou knihovnu komponent. JavaFX je poměrně novější a má malou knihovnu komponent, ale s konzistentnějšími aktualizacemi a konzistentní podporou MVC. Záleží tedy na tom, jak se JavaFX dále vyvíjí a poskytuje více funkcí.

Otázka č. 5) Co je lepší AWT nebo Swing?

Odpovědět: Swing je postaven na AWT a poskytuje bohatou a velkou sadu komponent uživatelského rozhraní ve srovnání s AWT. Swing komponenty také mohou vypadat a působit proti komponentám AWT, které vypadají a vypadají jako operační systém.

Swing komponenty jsou rychlejší než AWT. Všechny tyto faktory dělají švih lepší než AWT.

Více o Java Swing

Když vytváříte aplikaci, zpočátku byste měli mít základní kontejner a musíte do kontejneru přidat požadované komponenty, jako jsou tlačítka a textová pole.

A když kliknete na libovolné pole nebo na něj provedete jakoukoli operaci, dojde k události a váš kód by měl události poslouchat a také událost zpracovat.

Kontejner na houpačku

Kontejner je kořenový prvek aplikace. Všechny ostatní komponenty jsou přidány do tohoto kořenového adresáře a tvoří hierarchii.

Existují tři třídy kontejnerů:

  • JFrame
  • JDialog
  • JApplet

Ukázka kontejneru pomocí 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); } }

Ukázka kontejneru pomocí JFrame

Když spustíte výše uvedený program, získáte výstup níže.

základní nádoba

Součásti

Třída JComponent je základní třídou pro všechny komponenty ve švihu.

Mezi často používané komponenty patří,

  • JButton
  • JTextField
  • JTextArea
  • JRadioButton
  • JComboBox atd.

Všechny tyto komponenty by měly být přidány do kontejneru, pokud ne, v aplikaci se nezobrazí.

Příklad:

Chcete-li vytvořit instanci tlačítka,

JButton clickButton = nový JButton ();

Chcete-li přidat tlačítko do kontejneru,

myFrame.add ();

Zpracování událostí

Všechny aplikace jsou řízeny událostmi, jako jsou kliknutí na tlačítka, kliknutí myší, zadávání textu uživatele atd. Když k události dojde, musíte přidat posluchače a musíte předat objekt zdrojové události.

S vnitřní třídou můžete událost zpracovat pomocí své logiky, jak je znázorněno níže.

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

Zpracování událostí

Závěr

V tomto tutoriálu jsme se dotkli základny s Swing API poskytovaným Javou pro vytváření aplikací GUI. Diskutovali jsme o hlavních otočných kontejnerech a součástech a jejich implementaci.

Také jsme diskutovali o zpracování událostí ve Swingu. Ačkoli mechanismus zpracování událostí je AWT, swing implementuje události efektivním způsobem. Poté jsme diskutovali o různých správcích rozložení poskytovaných Swing API, které nám umožňují rozložení nebo uspořádání různých komponent v aplikacích Swing GUI.

=> Podívejte se na průvodce Perfect Java Training Guide zde.

Doporučené čtení

^