Menu

Samouczek Java SWING: kontener, komponenty i obsługa zdarzeń

  • Główny
  • Inny
  • Samouczek Java SWING: kontener, komponenty i obsługa zdarzeń

java swing tutorial container

Ten obszerny samouczek wideo Java Swing wyjaśnia różne komponenty GUI Swing Framework i powiązane koncepcje, takie jak JPanel, JFrame, JButton itp:

Korzystamy z graficznych interfejsów użytkownika (powszechnie nazywanych GUI) do tworzenia aplikacji, które mają interfejs wizualny, ułatwiając użytkownikowi korzystanie z aplikacji.

Posiadanie wizualnego interfejsu aplikacji sprawia, że ​​aplikacja jest łatwa w nawigacji, efektywniej wykorzystuje kontrolki, a także jest atrakcyjna wizualnie dla użytkownika.

Swing jest używany głównie do tworzenia GUI dla aplikacji.

=> Odwiedź tutaj, aby zobaczyć serię szkoleń Java dla wszystkich.

Java SWING

Czego się nauczysz:

Samouczek wideo na temat Swing Java

Co to jest Java Swing

Java udostępnia wiele struktur GUI, które pomagają nam w tworzeniu różnorodnych aplikacji GUI. Widzieliśmy jeden w naszym poprzednim samouczku, tj. Abstract Window Toolkit lub AWT. AWT jest jednym z najstarszych frameworków GUI w Javie i jest również zależny od platformy. Kolejną wadą AWT są ciężkie komponenty.

W tym samouczku omówimy jeszcze inny framework GUI w Javie, tj. „SWING”. Struktura Swing w Javie jest częścią Java Foundation Classes lub powszechnie nazywanych JFC. JFC to interfejs API podobny do MFC (Microsoft Foundation Classes) w C ++. JFC zawiera Swing, AWT i Java2D.

Framework Swing w Javie jest zbudowany na frameworku AWT i może być używany do tworzenia aplikacji GUI, tak jak AWT. Ale w przeciwieństwie do AWT, komponenty Swing są lekkie i niezależne od platformy.

Framework Swing został napisany w całości w Javie. Struktura Swing w Javie jest dostarczana za pośrednictwem pakietu „javax.swing”. Klasy w pakiecie javax.swing zaczynają się od litery „J”. Więc w pakiecie javax.swing będziemy mieć klasy takie jak JButton, JFrame, JTextField, JTextArea itp.

Ogólnie rzecz biorąc, Swing API ma wszystkie kontrolki zdefiniowane w pakiecie javax.swing, które są obecne w AWT. Więc swing w pewnym sensie działa jako zamiennik AWT. Ponadto Swing ma różne zaawansowane panele z zakładkami. Swing API w Javie dostosowuje architekturę MVC (Model View Controller).

Główne cechy tej architektury to:

  • Dane komponentu wahadłowego są reprezentowane za pomocą modelu.
  • Jest wizualnie przedstawiony za pomocą widoku.
  • Komponent kontrolera architektury MVC odczytuje dane wejściowe od użytkownika w widoku, a następnie te zmiany są przekazywane do danych składnika.
  • W każdym komponencie Swing widok i kontroler są połączone razem, podczas gdy model jest oddzielny. Dzięki temu huśtawka wygląda i czuje się jak wtyk.

Funkcje API swing są podsumowane poniżej.

  1. Komponenty Swing są niezależne od platformy.
  2. API jest rozszerzalne.
  3. Elementy huśtawki są lekkie. Komponenty swing są napisane w czystej Javie, a także komponenty są renderowane przy użyciu kodu Java zamiast podstawowych wywołań systemowych.
  4. Swing API zapewnia zestaw zaawansowanych kontrolek, takich jak TabbedPane, Tree, Colorpicker, kontrolki tabeli itp., Które są bogate w funkcje.
  5. Sterowanie huśtawką jest wysoce konfigurowalne. Dzieje się tak, ponieważ wygląd lub wygląd komponentu jest niezależny od wewnętrznej reprezentacji, a zatem możemy dostosować go do własnych potrzeb.
  6. Możemy po prostu zmienić wartości, a tym samym zmienić wygląd i działanie w czasie wykonywania.

Komponenty Java Swing

Swing ma duży zestaw komponentów, które możemy włączyć do naszych programów i korzystać z bogatych funkcjonalności, za pomocą których możemy tworzyć wysoce spersonalizowane i wydajne aplikacje GUI.

rozwiązywanie problemów z siecią pytania i odpowiedzi na rozmowę kwalifikacyjną pdf

Więc co to jest komponent?

Komponent można zdefiniować jako element sterujący, który można przedstawić wizualnie i zwykle jest niezależny. Ma określoną funkcjonalność i jest reprezentowany jako indywidualna klasa w Swing API.

Na przykład, class JButton w Swing API jest komponentem przycisku i zapewnia funkcjonalność przycisku.

Jeden lub więcej komponentów tworzy grupę i ta grupa może być umieszczona w „Kontenerze”. Kontener zapewnia przestrzeń, w której możemy wyświetlać komponenty, a także zarządzać ich rozstawem, układem itp.

W Javie kontenery są podzielone na dwa typy, jak pokazano poniżej:

Typy kontenerów

Klasy Swing w Javie

Poniżej przedstawiono hierarchię Swing API w Javie:

Wprowadzenie do klas Swing

Jak widać z powyższej hierarchii, mamy klasy Container - frame, dialog, Panel, Applet itp. Istnieją również klasy Component wywodzące się z klasy JComponent z Swing API. Niektóre klasy, które dziedziczą po JComponent, to JLabel, JList, JTextBox itp.

Oto niektóre z ważnych klas Swing API:

  • JWindow: Klasa JWindow klasy Swing dziedziczy bezpośrednio klasę Window. Klasa JWindow używa „BorderLayout” jako domyślnego układu.
  • JPanel: JPanel jest potomkiem klasy JComponent i jest podobny do panelu klasy AWT i ma domyślny układ „FlowLayout”.
  • JFrame: JFrame pochodzi z klasy Frame. Komponenty dodane do Frame nazywane są zawartością Frame.
  • JLabel: Klasa JLabel jest podklasą JComponent. Służy do tworzenia etykiet tekstowych w aplikacji.
  • JButton: Funkcjonalność przycisku w Swing zapewnia JButton. Z obiektem JButton możemy skojarzyć napis, ikonę lub jedno i drugie.
  • JTextField: Klasa JTextField udostępnia pole tekstowe, w którym możemy edytować pojedynczy wiersz tekstu.

JFrame w Javie

Ogólnie ramka jest kontenerem, który może zawierać inne składniki, takie jak przyciski, etykiety, pola tekstowe itp. Okno ramki może zawierać tytuł, obramowanie, a także menu, pola tekstowe, przyciski i inne składniki. Aplikacja powinna zawierać ramkę, abyśmy mogli dodać do niej komponenty.

Ramka w Java Swing jest zdefiniowana w klasie javax.swing.JFrame. Klasa JFrame dziedziczy klasę java.awt.Frame. JFrame jest jak główne okno aplikacji GUI używającej swing.

Możemy utworzyć obiekt okna JFrame przy użyciu dwóch podejść:

# 1) Poprzez rozszerzenie klasy JFrame

Pierwsze podejście polega na utworzeniu nowej klasy w celu skonstruowania Frame. Ta klasa dziedziczy po klasie JFrame pakietu javax.swing.

Poniższy program realizuje to podejście.

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

Wynik:

Rozszerzając klasę JFrame

# 2) Poprzez utworzenie instancji klasy 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 } }

Wynik:

Poprzez utworzenie instancji klasy JFrame

W powyższym programie stworzyliśmy ramkę z klasy JFrame tworząc instancję klasy JFrame.

JPanel w Javie

Panel to komponent znajdujący się wewnątrz okna ramowego. Rama może mieć w sobie więcej niż jeden element panelowy, przy czym każdy element panelu może mieć kilka innych elementów.

Mówiąc prościej, do podziału ramy możemy użyć paneli. Każdy panel grupuje w nim kilka innych komponentów. Innymi słowy, używamy paneli do organizowania elementów wewnątrz ramy.

Klasa swing API implementująca komponent panelu to JPanel. Klasa JPanel dziedziczy po JComponent i ma układ FlowLayout jako domyślny układ.

Poniższy program demonstruje tworzenie kontenera panelu w ramce przy użyciu klas pakietu 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 } }

Wynik:

JPanel w Javie

Tutaj mamy ramkę. Wewnątrz ramy tworzymy panel. Następnie wewnątrz panelu tworzymy przycisk. W ten sposób możemy użyć panelu do przytrzymania innych komponentów.

JTextArea w Javie

TextArea definiuje edytowalne pole tekstowe. Może mieć wiele linii. Klasą swing, która definiuje obszar tekstowy, jest JTextArea i dziedziczy ona klasę JTextComponent.

klasa publiczna JTextArea rozszerza JTextComponent

Klasa JTextArea zawiera 4 konstruktory, które pozwalają nam stworzyć obszar tekstowy z różnymi opcjami.

  • JTextArea (): Konstruktor domyślny. Utwórz pusty obszar tekstowy.
  • JTextArea (ciąg znaków): Tworzy obszar tekstowy z s jako wartością domyślną.
  • JTextArea (int row, int column): Tworzy obszar tekstowy z określonym wierszem x kolumną.
  • JTextArea (String s, int row, int column): Tworzy tekst are2a z określonym wierszem x kolumną i domyślną wartością s.

Poniższy program Java przedstawia przykład komponentu JTextArea w 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 } }

Wynik:

JTextArea w Javie

JButton w Javie

Przycisk to komponent używany do tworzenia przycisku z nazwą lub etykietą. W swingu klasą, która tworzy przycisk z etykietą, jest JButton. JButton dziedziczy klasę AbstractButton. Możemy skojarzyć zdarzenie ActionListener z przyciskiem, aby po naciśnięciu wykonywał jakąś akcję.

Zaimplementujmy przykładowy program dla wahań JButton w Javie.

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

Wynik:

JButton w Javie

JList w Javie

Lista składa się z wielu elementów tekstowych. Użytkownicy mogą wybrać pojedynczy element lub wiele elementów naraz. Klasa implementująca listę w swing API to JList. JList jest potomkiem klasy JComponent.

Poniżej podano konstruktory klasy JList.

  • JList (): Domyślny konstruktor, który tworzy pustą listę tylko do odczytu.
  • JList (tablica [] listItem): Utwórz listę JList, która początkowo zawiera elementy tablicy listItem.
  • JList (ListModel dataModel): Tworzy listę z elementami z określonego modelu dataModel.

Poniżej przedstawiono prostą demonstrację składnika 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); } }

Wynik:

JList w Javie

W powyższym programie najpierw definiujemy listModel z kolorowymi wpisami. Następnie tworzymy obiekt JList i dodajemy do niego listModel. Następnie obiekt JList jest dodawany do obiektu ramki, który jest następnie wyświetlany.

JComboBox w Javie

Klasa JCombobox zawiera listę opcji, z których użytkownik może wybrać opcję. Wybrany wybór znajduje się u góry. JComboBox pochodzi z klasy JComponent.

Poniżej przedstawiono konstruktory udostępnione przez klasę JComboBox:

  • JComboBox (): Domyślny konstruktor, który tworzy ComboBox z domyślnym modelem danych.
  • JComboBox (elementy Object []): Ten konstruktor tworzy ComboBox zawierający elementy jako elementy danych elementów tablicy.
  • JComboBox (elementy wektorowe): Ten konstruktor odczytuje elementy danego wektora i konstruuje ComboBox z tymi elementami jako elementami.

Klasa JComboBox udostępnia również metody dodawania / usuwania elementów, dodawania ActionListener, ItemListener itp.

Poniższy przykład ilustruje implementację JComboBox w języku Java.

składnia java vs c ++
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(); } }

Wynik:

Implementacja JComboBox

JSlider w Javie

Suwak pozwala nam wybrać określony zakres wartości. W Java Swing API JSlider jest klasą używaną do implementacji suwaka.

Poniżej przedstawiono konstruktory dostarczane przez klasę JSlider.

  • JSlider (): domyślny konstruktor, który tworzy suwak mający 50 jako wartość początkową i zakres 0-100.
  • JSlider (orientacja int): Ten konstruktor tworzy suwak, tak jak powyżej, ale z określoną orientacją. Wartością orientacji może być JSlider.HORIZONTAL lub JSlider.VERTICAL.
  • JSlider (int min, int max): Ten konstruktor służy do tworzenia poziomego suwaka przy użyciu podanych wartości min i max.
  • JSlider (int min, int max, int value): Ten konstruktor tworzy poziomy suwak z określoną wartością min, max i value.
  • JSlider (int orientacja, int min, int max, int value): Ten konstruktor konstruuje suwak z określoną orientacją, min, max i wartością.

Poniższy program demonstruje JSlider w Javie za pomocą znaczników. Ten program demonstruje również użycie metod obsługiwanych przez klasę 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); } }

Wynik:

JSlider w Javie

Obsługa zdarzeń w języku Java

Zdarzenie można zdefiniować jako zmianę stanu obiektu. Z punktu widzenia GUI, zdarzenie występuje, gdy użytkownik końcowy wchodzi w interakcję z komponentami GUI. Zdarzenia wywoływane w GUI mogą obejmować kliknięcie przycisku, przewijanie, wybieranie elementów listy, zmianę tekstu itp.

Zdarzenia występujące w wymienionym powyżej interfejsie GUI są w większości wydarzeniami pierwszoplanowymi. Możemy również mieć pewne zdarzenia w tle, takie jak zakończenie operacji w tle, wygaśnięcie timera itp.

Obsługa zdarzeń to mechanizm, za pomocą którego podejmowana jest akcja, gdy wystąpi zdarzenie. W tym celu definiujemy metodę, która jest również nazywana procedurą obsługi zdarzenia, która jest wywoływana, gdy wystąpi zdarzenie. Java używa standardowego mechanizmu zwanego „modelem zdarzeń delegacji” do generowania i obsługi zdarzeń.

Model zdarzenia Delegacja składa się z:

# 1) Źródło: Źródłem zdarzenia jest obiekt. Obiekt, na którym występuje zdarzenie, jest źródłem, a źródło jest odpowiedzialne za wysyłanie informacji o zdarzeniu do modułu obsługi zdarzeń.

# 2) Słuchacz: Odbiornik to nic innego jak program obsługi zdarzeń odpowiedzialny za podejmowanie akcji w przypadku wystąpienia zdarzenia. W Javie detektor to obiekt, który czeka na zdarzenie. Po wystąpieniu zdarzenia odbiorca przetwarza je.

Wymaganiem jest zarejestrowanie detektora w obiekcie, aby w przypadku wystąpienia zdarzenia odbiornik mógł je przetworzyć.

Na przykład,dla zdarzenia kliknięcia przycisku możemy mieć następującą sekwencję kroków.

  1. Użytkownik klika przycisk generujący zdarzenie Click.
  2. Tworzony jest odpowiedni obiekt klasy zdarzenia, a dane źródłowe i dane zdarzenia są przekazywane do tego obiektu.
  3. Ten obiekt zdarzenia jest następnie przekazywany do klasy detektora zarejestrowanej w obiekcie.
  4. Odbiornik wykonuje i zwraca.

Omówmy teraz niektóre elementy nasłuchujące dostarczane przez Javę.

ActionListener w Javie

Element actionListener to nasłuchiwanie przycisku lub elementu menu. Kiedy klikamy przycisk, zaangażowany przycisk Listener to actionListener. ActionListener jest powiadamiany w ActionEvent.

Pakiet zdarzeń java.awt.an definiuje interfejs ActionListener. Ten interfejs ma tylko jedną metodę actionPerformed ().

public abstract void actionPerformed (ActionEvent e);

Kliknięcie zarejestrowanego składnika, takiego jak Button, powoduje automatyczne wywołanie metody actionPerformed ().

Najpopularniejszym podejściem do włączenia ActionListener do programu jest zaimplementowanie interfejsu ActionListener, a następnie zaimplementowanie metody actionPerformed ().

Kroki implementacji klasy ActionListener są następujące:

# 1) Zaimplementuj interfejs ActionListerner.

public class ActionListenerImpl Implementuje ActionListener

# 2) Zarejestruj komponent w tym nasłuchiwaniu. Jeśli przycisk jest komponentem, który chcemy zarejestrować u słuchacza, zarejestrujemy go w następujący sposób:

button.addActionListener (instanceOfListenerclass);

# 3) Zaimplementuj / zastąp metodę actionPerformed ().

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

Więc korzystając z powyższych kroków, możemy powiązać dowolne zdarzenie z komponentem GUI.

Poniższy przykład ilustruje zdarzenie przycisku Click przy użyciu 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); } }

Wynik:

ActionListener w Javie

Powyższy program implementuje zdarzenie ActionListener. Zdarzeniem jest zdarzenie Button click iz nim skojarzyliśmy ActionListener, który wyświetla tekst w polu tekstowym po kliknięciu przycisku.

KeyListener w Javie

Za każdym razem, gdy nastąpi zmiana stanu klucza, zostanie powiadomiony KeyListener. Podobnie jak ActionListener, KeyListener również znajduje się w pakiecie java.awt.event.

Interfejs KeyListener udostępnia następujące metody:

public abstract void keyPressed (KeyEvent e);

public abstract void keyReleased (KeyEvent e);

public abstract void keyTyped (KeyEvent e);

Musimy zaimplementować powyższe metody, aby skojarzyć kluczowe zdarzenia z komponentem. Pozostawiamy użytkownikowi zaimplementowanie przykładu KeyListener przy użyciu swingów w Javie.

Swing Layouts w Javie

Kiedy układamy różne komponenty w pojemniku, mówimy, że układamy te elementy. Zatem układ można zdefiniować jako rozmieszczenie komponentów w kontenerze.

Dopóki jest mniej komponentów, można je umieszczać ręcznie metodą przeciągnij-upuść. Jednak rozmieszczenie elementów w dużej liczbie staje się trudne. W tym momencie z pomocą przychodzi nam Layout Manager Java.

LayoutManager jest odpowiedzialny za układ komponentów w aplikacjach GUI. LayoutManager jest interfejsem i jest implementowany przez wszystkie klasy menedżera układu. Java udostępnia następujące klasy LayoutManager.

LayoutManagerOpis
javax.swing.GroupLayoutGrupuje komponenty, a następnie umieszcza je w kontenerze.
java.awt.BorderLayoutKomponenty są rozmieszczone w pięciu kierunkach, a mianowicie w środku, na wschodzie, zachodzie, południu i północy.
java.awt.FlowLayoutTo jest domyślny układ. Układa komponenty w kierunku przepływu.
java.awt.GridLayoutUkłada komponenty w prostokątnej siatce.
javax.swing.BoxLayoutKomponenty są ułożone w pudełku.
java.awt.CardLayoutKażdy komponent jest postrzegany jako karta w talii i jednocześnie widoczny jest tylko jeden komponent.
java.awt.GridBagLayoutUkłada komponenty pionowo, poziomo lub nawet wzdłuż ich linii bazowych. Komponenty nie muszą być tego samego rozmiaru.
javax.swing.ScrollPaneLayoutUżywany przez klasę JScrollPane i jest odpowiedzialny za rozmieszczenie komponentów w przewijalnych kontenerach.
javax.swing.SpringLayout itp.Zapewniony jest zestaw wiązań, takich jak odległość pozioma i pionowa między komponentami itp., A komponenty są ułożone zgodnie z tym zestawem wiązań.

W tym samouczku omówimy tylko FlowLayout i GridLayout.

FlowLayout w Javie

FlowLayout rozmieszcza komponenty w kierunku przepływu, jeden po drugim. To jest domyślny układ kontenerów, takich jak Panel i Aplet.

Klasa FlowLayout w języku Java, która reprezentuje menedżera FlowLayout, zawiera następujące pola i konstruktory.

Fields Of FlowLayout Class

  • publiczny statyczny finał int LEADING
  • publiczny statyczny końcowy int TRAILING
  • public static final int LEFT
  • public static final int RIGHT
  • public static final int CENTER

Powyższe pola definiują pozycje, w których komponenty zostaną umieszczone lub wyrównane.

Konstruktorzy klasy FlowLayout

  • FlowLayout (): To jest domyślny konstruktor. Ten konstruktor tworzy układ przepływu zawierający centralnie wyrównane komponenty z domyślną przerwą 5 jednostek w kierunku poziomym i pionowym.
  • FlowLayout (int align): Ten konstruktor tworzy układ przepływu z określoną wartością wyrównania oraz z poziomą i pionową przerwą równą 5 jednostek.
  • FlowLayout (int align, int hgap, int vgap): Tworzy układ przepływu z określoną wartością wyrównania oraz odstępem poziomym i pionowym.

Poniżej podano przykład FlowLayout w Javie.

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

Wynik:

Konstruktory klasy FlowLayout

GridLayout w Javie

Za pomocą GridLayout możemy rozmieścić komponenty w formie prostokątnej siatki, tj. Każdy komponent jest ułożony w każdym prostokącie.

Konstruktorzy klasy GridLayout

  1. GridLayout (): domyślny konstruktor, który generuje układ siatki zawierający jedną kolumnę na jeden komponent w wierszu.
  2. GridLayout (int wiersze, int kolumny): ten konstruktor generuje układ siatki z określonymi wierszami i kolumnami. Nie ma przerwy między komponentami.
  3. GridLayout (int wiersze, int kolumny, int hgap, int vgap): Używając tego konstruktora, generujemy układ siatki z określonymi wierszami i kolumnami oraz poziomymi i pionowymi przerwami.

Poniższy przykład implementuje GridLayout w języku 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(); } }

Wynik:

GridLayout w Javie

Setbounds w Javie

Jeśli sprawdzimy przykłady programowania w tym samouczku przed tematem dotyczącym układu, zobaczymy, że ustawiliśmy układ jako null w tych przykładach (setLayout (null)). Widzieliśmy, że kiedy używamy menedżerów układu w naszym programie, automatycznie pozycjonują one komponenty.

Gdy menedżery układu nie są używane, możemy użyć metody setBounds do rozmiaru i położenia komponentu. Dlatego metoda setBounds służy do ręcznego pozycjonowania komponentu, a także ustawiania rozmiaru.

Ogólna składnia metody setBounds jest następująca:

setBounds (int x-współrzędna, int y - współrzędna, int szerokość, int wysokość)

Zaimplementujmy teraz przykład 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); } }

Wynik:

Setbounds w Javie

W powyższym programie mamy komponent Button. Nie ustawiliśmy żadnego układu, ale użyliśmy metody setBounds, aby ustawić jego położenie i wymiary.

Swing Vs JavaFX

HuśtawkaJavaFX
Swing udostępnia API do tworzenia komponentów GUI.JavaFX zapewnia skrypty i szybkie tworzenie interfejsu użytkownika związane z narzędziem do tworzenia ekranu.
Nie będzie żadnych nowych funkcji dodanych do Swing w przyszłych wersjach.JavaFX zapewnia bogatą funkcjonalność i może mieć więcej funkcji w przyszłych wersjach.
Możemy stworzyć wszystkie standardowe komponenty za pomocą Swing API.JavaFX pozwala nam tworzyć bogate komponenty GUI przy użyciu zaawansowanego wyglądu.
Swing zawiera dużą liczbę komponentów.JavaFX ma stosunkowo mniejszą liczbę komponentów.
Swing to w pełni funkcjonalna biblioteka interfejsu użytkownika.JavaFX to nowy i nadchodzący interfejs API z bogatymi komponentami interfejsu użytkownika.
Swing ma luźną obsługę MVC.JavaFX konsekwentnie obsługuje wzorzec MVC.

Często Zadawane Pytania

Pytanie 1) Czy Swing jest nadal używany w Javie?

Odpowiedź: Tak, Swing jest nadal używany w Javie i to zbyt często. Czasami jest używany jako kompletny zamiennik AWT. Czasami jest również używany wraz z niektórymi komponentami AWT. Jest nawet używany z najnowszą wersją JavaFX. Więc Swing jest nadal używany i będzie używany przez długi czas.

Pytanie 2) Jak działa Java Swing?

Odpowiedź: Swing w Javie jest napisany na szczycie frameworka AWT. Tak więc obsługa zdarzeń AWT jest dziedziczona całkowicie przez swing. Swing zapewnia również dużą liczbę komponentów, których możemy użyć do tworzenia wydajnych aplikacji GUI.

P # 3) Czy Swing jest zgodny z MVC?

sql zapytania do ćwiczenia z odpowiedziami pdf

Odpowiedź: Swing API ma luźną obsługę MVC. Model przedstawia dane komponentu. Komponent swing ma oddzielny element o nazwie Model, podczas gdy kontroler i widok są połączone razem w elementach interfejsu użytkownika. To klubowanie sprawia, że ​​huśtawka ma wygląd i styl, który można podłączyć.

Pytanie 4) Czy JavaFX jest lepszy niż Swing?

Odpowiedź: Swing istnieje od dłuższego czasu i ma bardziej dojrzałe wsparcie dla IDE. Miał też bardzo dużą bibliotekę komponentów. JavaFX jest stosunkowo nowsza i ma małą bibliotekę komponentów, ale z bardziej spójnymi aktualizacjami i spójną obsługą MVC. Zależy to zatem od dalszego rozwoju JavaFX i zapewnienia większej liczby funkcji.

P # 5) Który jest lepszy AWT czy Swing?

Odpowiedź: Swing jest zbudowany na bazie AWT i zapewnia bogaty i duży zestaw komponentów UI w porównaniu z AWT. Komponenty Swing mogą również wyglądać i działać w porównaniu z komponentami AWT, które wyglądają i działają w systemie operacyjnym.

Komponenty huśtawki są szybsze niż AWT. Wszystkie te czynniki sprawiają, że swing jest lepszy niż AWT.

Więcej o Java Swing

Kiedy tworzysz aplikację, na początku powinieneś mieć podstawowy kontener i musisz dodać wymagane komponenty, takie jak przyciski i pola tekstowe w kontenerze.

Gdy klikniesz lub wykonasz jakąkolwiek operację na jakimkolwiek polu, nastąpi zdarzenie, a Twój kod powinien nasłuchiwać zdarzeń, a także obsługiwać zdarzenie.

Pojemnik na huśtawkę

Kontener to element główny aplikacji. Wszystkie pozostałe komponenty są dodawane do tego katalogu głównego i tworzą hierarchię.

Istnieją trzy klasy kontenerów:

  • JFrame
  • JDialog
  • JApplet

Demo kontenera przy użyciu 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 kontenera przy użyciu JFrame

Po uruchomieniu powyższego programu otrzymasz poniższe dane wyjściowe.

pojemnik podstawowy

składniki

Klasa JComponent jest klasą bazową dla wszystkich komponentów w ruchu.

Często używane komponenty obejmują:

  • JButton
  • JTextField
  • JTextArea
  • JRadioButton
  • JComboBox itp.

Wszystkie te składniki należy dodać do kontenera, jeśli nie, to nie pojawią się w aplikacji.

Przykład:

Aby utworzyć instancję przycisku,

JButton clickButton = new JButton ();

Aby dodać przycisk do kontenera,

myFrame.add ();

Obsługa zdarzeń

Wszystkie Aplikacje są sterowane przez zdarzenia, takie jak kliknięcia przycisków, kliknięcia myszą, wprowadzanie tekstu przez użytkownika itp. Gdy wystąpi zdarzenie, należy dodać detektor i przekazać obiekt zdarzenia źródłowego.

W przypadku klasy wewnętrznej możesz obsłużyć zdarzenie za pomocą swojej logiki, jak pokazano poniżej.

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

Obsługa zdarzeń

Wniosek

W tym samouczku dotknęliśmy podstawy za pomocą interfejsu API Swing dostarczanego przez Javę do tworzenia aplikacji GUI. Omówiliśmy najważniejsze pojemniki i komponenty wahadłowe oraz ich implementację.

Omówiliśmy również obsługę zdarzeń w Swing. Chociaż mechanizm obsługi zdarzeń to AWT, swing implementuje zdarzenia w efektywny sposób. Następnie omówiliśmy różne menedżery układów dostarczane przez Swing API, które pozwalają nam układać lub układać różne komponenty w aplikacjach Swing GUI.

=> Sprawdź idealny przewodnik szkoleniowy języka Java tutaj.

rekomendowane lektury

^