Meny

Java SWING-handledning: Container, komponenter och händelsehantering

  • Huvud
  • Övrig
  • Java SWING-handledning: Container, komponenter och händelsehantering

java swing tutorial container

Prova Vårt Instrument För Att Eliminera Problem

Denna omfattande Java Swing-videohandledning förklarar olika komponenter i GUI Swing Framework och relaterade koncept som JPanel, JFrame, JButton, etc:

Vi använder grafiska användargränssnitt (vanligtvis kallad GUI) för att bygga applikationer som har ett visuellt gränssnitt genom att göra det enkelt för användaren att använda programmet.

Att ha ett visuellt gränssnitt för en applikation gör applikationen lätt att navigera, använda kontroller mer effektivt, och det är också visuellt tilltalande för användaren.

Swing används främst för att skapa GUI för applikationer.

=> Besök här för att se Java Training Series för alla.

Java SWING

Vad du kommer att lära dig:

Videohandledning om Java Swing

Vad är Java Swing

Java erbjuder många GUI-ramar som hjälper oss att utveckla en mängd olika GUI-applikationer. Vi har sett en i vår tidigare handledning, dvs. Abstract Window Toolkit eller AWT. AWT är en av de äldsta GUI-ramarna i Java och är också plattformsberoende. En annan nackdel med AWT är dess tunga komponenter.

I den här guiden kommer vi att diskutera ytterligare ett GUI-ramverk i Java, dvs. ”SWING”. Swing-ramverket i Java är en del av Java Foundation Classes eller vanligtvis kallade JFC. JFC är ett API som liknar MFC (Microsoft Foundation Classes) i C ++. JFC innehåller Swing, AWT och Java2D.

Swing-ramverket i Java är byggt ovanpå AWT-ramverket och kan användas för att skapa GUI-applikationer precis som AWT. Men till skillnad från AWT är Swing-komponenterna lätta och plattformsoberoende.

Swing-ramverket är skrivet helt på Java. Swing-ramverket i Java tillhandahålls genom paketet 'javax.swing'. Klasserna i paketet javax.swing börjar med bokstaven 'J'. Så i ett javax.swing-paket kommer vi att ha klasser som JButton, JFrame, JTextField, JTextArea, etc.

I allmänhet har Swing API alla kontroller definierade i javax.swing-paketet som finns i AWT. Så sväng på ett sätt fungerar som en ersättning för AWT. Swing har också olika avancerade rutor med flikar med komponenter. Swing API i Java anpassar MVC (Model View Controller) -arkitektur.

De viktigaste egenskaperna hos denna arkitektur är:

  • Gungkomponentens data representeras med hjälp av modell.
  • Det representeras visuellt med hjälp av en vy.
  • Styrenhetskomponenten i MVC-arkitekturen läser inmatning från användaren i vyn och sedan skickas dessa ändringar till komponentdata.
  • I varje Swing-komponent är vyn och styrenheten ihop medan modellen är en separat. Detta ger sväng en pluggbar look och känsla-funktion.

Funktionerna i swing API sammanfattas nedan.

  1. Gungkomponenter är plattformsoberoende.
  2. API: t är utbyggbart.
  3. Gungkomponenter är lätta. Swing-komponenterna är skrivna i ren Java och komponenter återges med Java-kod istället för underliggande systemanrop.
  4. Swing API tillhandahåller en uppsättning avancerade kontroller som TabbedPane, Tree, Colorpicker, tabellkontroller etc. som är rika på funktionalitet.
  5. Gungkontrollerna är mycket anpassningsbara. Detta beror på att komponentens utseende eller utseende är oberoende av intern representation och därför kan vi anpassa den på det sätt vi önskar.
  6. Vi kan helt enkelt ändra värdena och därmed ändra utseendet på runtime.

Java Swing Components

Swing har en stor uppsättning komponenter som vi kan inkludera i våra program och utnyttja de rika funktionerna med vilka vi kan utveckla mycket skräddarsydda och effektiva GUI-applikationer.

Så vad är en komponent?

En komponent kan definieras som en kontroll som kan representeras visuellt och vanligtvis är oberoende. Den har en specifik funktionalitet och representeras som en individuell klass i Swing API.

Till exempel, klass JButton i sväng API är en knappkomponent och ger funktionaliteten för en knapp.

En eller flera komponenter bildar en grupp och denna grupp kan placeras i en 'behållare'. En container ger ett utrymme där vi kan visa komponenter och även hantera deras avstånd, layout etc.

I Java är containrar uppdelade i två typer enligt nedan:

Behållartyper

Gungklasser i Java

En Swing API-hierarki i Java visas nedan:

Introduktion till gungklasser

Som vi ser från ovanstående hierarki har vi behållarklasser - ram, dialog, panel, applet, etc. Det finns också komponentklasser härledda från JComponent-klassen i Swing API. Några av klasserna som ärver från JComponent är JLabel, JList, JTextBox, etc.

Några av de viktiga klasserna i Swing API är som följer:

  • JFönster: JWindow-klassen Swing ärver Window-klassen direkt. JWindow-klassen använder ”BorderLayout” som standardlayout.
  • JPanel: JPanel är en ättling till JComponent-klass och är på liknande linjer som AWT-klasspanelen och har ”FlowLayout” som standardlayout.
  • JFrame: JFrame kommer från ramklassen. Komponenterna som läggs till i ramen kallas ramens innehåll.
  • JLabel: JLabel-klassen är en underklass av JComponent. Den används för att skapa textetiketter i applikationen.
  • JButton: Tryckknappsfunktionen i Swing tillhandahålls av JButton. Vi kan associera en sträng, en ikon eller båda med JButton-objektet.
  • JTextField: JTextField-klassen tillhandahåller ett textfält där vi kan redigera en enda textrad.

JFrame i Java

En ram är i allmänhet en behållare som kan innehålla andra komponenter som knappar, etiketter, textfält etc. Ett ramfönster kan innehålla en titel, en ram och även menyer, textfält, knappar och andra komponenter. En applikation ska innehålla en ram så att vi kan lägga till komponenter i den.

The Frame in Java Swing definieras i klassen javax.swing.JFrame. JFrame-klassen ärver klassen java.awt.Frame. JFrame är som huvudfönstret i GUI-applikationen med hjälp av swing.

Vi kan skapa ett JFrame-fönsterobjekt med två metoder:

c # intervjufrågor med svar

# 1) Genom att utöka JFrame-klassen

Det första tillvägagångssättet är att skapa en ny klass för att konstruera en ram. Den här klassen ärver från JFrame-klassen i paketet javax.swing.

Följande program implementerar detta tillvägagångssätt.

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

Produktion:

Genom att utöka klassen JFrame

# 2) Genom att starta JFrame-klassen

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

Produktion:

Genom att starta JFrame-klassen

I programmet ovan har vi skapat en ram från JFrame-klassen genom att skapa en instans av JFrame-klassen.

JPanel i Java

En panel är en komponent som finns i ett ramfönster. En ram kan ha mer än enpanelskomponenter inuti den, varvid varje panelkomponent har flera andra komponenter.

I enklare termer kan vi använda paneler för att partitionera ramen. Varje panel grupperar flera andra komponenter inuti den. Med andra ord använder vi paneler för att organisera komponenter inuti ramen.

Swing API-klassen som implementerar panelkomponenten är JPanel. JPanel-klass ärver från JComponent och har FlowLayout som standardlayout.

Följande program visar skapandet av en panelbehållare i en ram med hjälp av paketklasserna 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 } }

Produktion:

JPanel i Java

Här har vi en ram. Inuti ramen skapar vi en panel. Sedan inuti panelen skapar vi en knapp. På så sätt kan vi använda en panel för att hålla de andra komponenterna.

JTextArea i Java

TextArea definierar ett redigerbart textfält. Det kan ha flera rader. Swingklassen som definierar textområdet är JTextArea och den ärver JTextComponent-klassen.

public class JTextArea utökar JTextComponent

JTextArea-klassen innehåller fyra konstruktörer som låter oss skapa ett textområde med olika alternativ.

  • JTextArea (): Standardkonstruktör. Skapa ett tomt textområde.
  • JTextArea (strängar): Skapar ett textområde med s som standardvärde.
  • JTextArea (intrad, int-kolumn): Skapar ett textområde med en angiven rad x kolumn.
  • JTextArea (sträng s, intrad, int-kolumn): Skapar en text are2a med angiven rad x kolumn och standardvärde s.

Följande Java-program visar ett exempel på JTextArea-komponenten i svingen.

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

Produktion:

JTextArea i Java

JButton i Java

En knapp är en komponent som används för att skapa en tryckknapp med namn eller etikett. I sväng är klassen som skapar en märkt knapp JButton. JButton ärver klassen AbstractButton. Vi kan associera ActionListener-händelsen till knappen för att få den att vidta några åtgärder när den trycks in.

Låt oss implementera ett exempelprogram för JButton i Java-svängningar.

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

Produktion:

JButton i Java

JList i Java

En lista består av flera textobjekt. Användare kan antingen välja ett objekt eller flera objekt åt gången. Klassen som implementerar listan i swing-API är JList. JList är en ättling till JComponent-klassen.

Nedan följer konstruktörerna av JList-klassen.

  • JList (): Standardkonstruktör som skapar en tom, skrivskyddad lista.
  • JList (array () listItem): Skapa en JList som ursprungligen innehåller element i array listItem.
  • JList (ListModel dataModel): Skapar en lista med element från den angivna modelldatamodellen.

En enkel demonstration av JList-komponenten ges nedan.

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

Produktion:

JList i Java

I ovanstående program definierar vi först en listModell med färgposter i den. Sedan skapar vi ett JList-objekt och lägger till listModel till det. Därefter läggs JList-objektet till ramobjektet som sedan visas.

bästa appen för att ladda ner youtube-videor

JComboBox i Java

JCombobox-klassen visar en lista över val som en användare kan välja ett alternativ från. Det valda valet är högst upp. JComboBox härrör från JComponent-klassen.

Följande är konstruktörerna från JComboBox-klass:

  • JComboBox (): Standardkonstruktör som skapar en ComboBox med standarddatamodellen.
  • JComboBox (objekt () objekt): Den här konstruktören skapar en ComboBox med objekt som element i de angivna matrisobjekten.
  • JComboBox (vektorartiklar): Denna konstruktör läser elementen i den givna vektorn och konstruerar en ComboBox med dessa element som dess objekt.

JComboBox-klassen tillhandahåller också metoder för att lägga till / ta bort objekt, lägga till ActionListener, ItemListener, etc.

Följande exempel visar JComboBox-implementeringen i 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(); } }

Produktion:

JComboBox-implementering

JSlider i Java

Med en skjutreglage kan vi välja ett visst värdeintervall. I Java Swing API är JSlider den klass som används för att implementera reglaget.

Följande är konstruktörerna från JSlider-klassen.

  • JSlider (): En standardkonstruktör som skapar en skjutreglage med 50 som startvärde och intervall 0-100.
  • JSlider (int-orientering): Den här konstruktören skapar en skjutreglage precis som ovan men med en angiven orientering. Orienteringsvärde kan vara antingen JSlider.HORIZONTAL eller JSlider.VERTICAL.
  • JSlider (int min, int max): Den här konstruktören används för att skapa en horisontell skjutreglage med den angivna min och max.
  • JSlider (int min, int max, int värde): Den här konstruktören skapar en skjutreglage som är horisontell med det angivna värdet min, max och värde.
  • JSlider (int-orientering, int min, int max, int-värde): Den här konstruktören konstruerar en skjutreglage med angiven orientering, min, max och värde.

Följande program visar JSlider i Java med fästingar. Detta program visar också användningen av de metoder som stöds av JSlider-klassen.

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

Produktion:

JSlider i Java

Händelsehantering i Java

En händelse kan definieras som ett ändringsläge för ett objekt. Ur GUI-synvinkel inträffar en händelse när slutanvändaren interagerar med GUI-komponenterna. Händelserna som utlöses i GUI kan vara att klicka på en knapp, rulla, välja listobjekt, ändra text etc.

Händelser som inträffar i GUI som anges ovan är mestadels förgrundshändelser. Vi kan också ha några bakgrundshändelser som bakgrundsfärdigställande, timer utgång etc.

Händelsehantering är en mekanism genom vilken en åtgärd vidtas när en händelse inträffar. För detta definierar vi en metod som också kallas en händelsehanterare som kallas när en händelse inträffar. Java använder en standardmekanism som kallas ”delegationshändelsemodellen” för att generera och hantera händelser.

Delegationshändelsemodellen består av:

# 1) Källa: Källan till händelsen är objektet. Objektet som en händelse inträffar på är källan och källan ansvarar för att skicka information om händelsen till händelsehanteraren.

# 2) Lyssnare: Lyssnaren är inget annat än händelseshanteraren som är ansvarig för att vidta en åtgärd när en händelse inträffar. I Java är en lyssnare ett objekt som väntar på en händelse. När händelsen inträffar behandlar lyssnaren händelsen.

Kravet är att registrera lyssnaren med objektet så att när en händelse inträffar kan lyssnaren bearbeta den.

Till exempel,för en knappklickningshändelse kan vi ha följande sekvens av steg.

  1. Användaren klickar på knappen som genererar en klickhändelse.
  2. Lämpligt händelseklassobjekt skapas och käll- och händelsesdata skickas till detta objekt.
  3. Detta händelseobjekt skickas sedan till lyssnarklassen som är registrerad med objektet.
  4. Lyssnaren kör och återvänder.

Låt oss nu diskutera några av de lyssnare som tillhandahålls av Java.

ActionListener i Java

En actionListener är lyssnaren på en knapp eller ett menyalternativ. När vi klickar på en knapp är knappen Listener som är inblandad actionListener. ActionListener meddelas i ActionEvent.

Eventpaketet java.awt.an definierar ActionListener-gränssnittet. Detta gränssnitt har bara en metodåtgärdPerformed ().

offentlig abstrakt ogiltig handlingPerformerad (ActionEvent e);

När man klickar på en registrerad komponent som en knapp aktiveras automatiskt metoden actionPerformed ().

Det vanligaste sättet att inkludera ActionListener i programmet är att implementera ActionListener-gränssnittet och sedan implementera actionPerformed () -metoden.

Stegen för att implementera ActionListener-klassen är som följer:

# 1) Implementera gränssnittet ActionListerner.

public class ActionListenerImpl Implementerar ActionListener

# 2) Registrera komponenten hos den här lyssnaren. Om knappen är en komponent som vi vill registrera hos lyssnaren registrerar vi den enligt följande:

button.addActionListener (instansOfListenerclass);

# 3) Implementera / åsidosätta metoden actionPerformed ().

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

Så med hjälp av ovanstående steg kan vi associera alla händelser med GUI-komponenten.

Följande exempel visar en knapp Klicka på händelse med 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); } }

Produktion:

ActionListener i Java

Ovanstående program implementerar en ActionListener-händelse. Händelsen är knappklickhändelsen och med den har vi associerat en ActionListener som visar texten i textfältet när du klickar på knappen.

KeyListener I Java

När nyckelns tillstånd ändras, meddelas en KeyListener. Precis som ActionListener finns KeyListener också i paketet java.awt.event.

KeyListener-gränssnittet innehåller följande metoder:

offentlig abstrakt ogiltig nyckelTryckt (KeyEvent e);

public abstract void keyReleased (KeyEvent e);

public abstract void keyTyped (KeyEvent e);

Vi måste implementera ovanstående metoder för att associera nyckelhändelserna med komponenten. Vi överlåter till användaren att implementera ett KeyListener-exempel med hjälp av svängningar i Java.

Gunglayouter i Java

När vi ordnar olika komponenter i en container, säger vi att vi lägger ut dessa komponenter. Så en layout kan definieras som placering av komponenter i en container.

Så länge det finns färre komponenter kan de placeras genom att dra-släppa manuellt. Men det blir svårt att ordna komponenterna i stort antal. Vid denna tidpunkt kommer Layout Manager för Java till vårt hjälp.

LayoutManager ansvarar för komponenternas layout i GUI-applikationer. LayoutManager är ett gränssnitt och det implementeras av alla layouthanterarklasser. Java tillhandahåller följande LayoutManager-klasser.

LayoutManagerBeskrivning
javax.swing.GroupLayoutGrupperar komponenterna och placerar dem sedan i behållaren.
java.awt.BorderLayoutKomponenterna är utformade för att passa i fem riktningar, nämligen centrum, öst, väst, söder, norr.
java.awt.FlowLayoutDetta är standardlayouten. Den lägger komponenterna i riktningsflödet.
java.awt.GridLayoutOrdnar komponenterna i ett rektangulärt galler.
javax.swing.BoxLayoutKomponenter är ordnade i en låda.
java.awt.CardLayoutVarje komponent ses som ett kort i en kortlek och på en gång är bara en komponent synlig.
java.awt.GridBagLayoutOrdnar komponenter vertikalt, horisontellt eller till och med längs baslinjerna. Komponenter behöver inte ha samma storlek.
javax.swing.ScrollPaneLayoutAnvänds av JScrollPane-klassen och ansvarar för att ordna komponenter i rullningsbara behållare.
javax.swing.SpringLayout etc.En uppsättning begränsningar som det horisontella och vertikala avståndet mellan komponenter etc. tillhandahålls och komponenterna är ordnade enligt dessa uppsättningar av begränsningar.

I denna handledning kommer vi bara att diskutera FlowLayout och GridLayout.

FlowLayout i Java

FlowLayout ordnar komponenterna i en flödesriktning, en efter en. Detta är standardlayouten för behållare som Panel och Applet.

FlowLayout-klassen i Java som representerar FlowLayout-hanteraren innehåller följande fält och konstruktörer.

Fält av FlowLayout-klass

  • public static final int LEADING
  • offentlig statisk slutlig INTRAILING
  • offentlig statisk slutlig int VÄNSTER
  • offentlig statisk final int RÄTT
  • offentlig statisk slutlig int CENTER

Ovanstående fält definierar positionerna där komponenterna kommer att placeras eller justeras.

Konstruktörer av FlowLayout-klass

  • FlowLayout (): Detta är en standardkonstruktör. Denna konstruktör skapar en flödeslayout med centralt inriktade komponenter med ett standardavstånd på 5 enheter i horisontell och vertikal riktning.
  • FlowLayout (int align): Denna konstruktör skapar en flödeslayout med det angivna justeringsvärdet och med ett horisontellt och vertikalt gap på 5 enheter.
  • FlowLayout (int align, int hgap, int vgap): Skapar en flödeslayout med specificerat justeringsvärde och horisontellt och vertikalt gap.

Nedan följer ett exempel på FlowLayout i 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(); } }

Produktion:

Konstruktörer i FlowLayout-klassen

GridLayout i Java

Med hjälp av GridLayout kan vi utforma komponenterna på ett rektangulärt rutnät, dvs. varje komponent är ordnad i varje rektangel.

Konstruktörer av GridLayout-klass

  1. Rutnätslayout (): standardkonstruktör som genererar en rutnätlayout med en kolumn per en komponent i rad.
  2. GridLayout (int-rader, int-kolumner): Den här konstruktören genererar en rutnätlayout med angivna rader och kolumner. Det finns inget mellanrum mellan komponenterna.
  3. GridLayout (int rader, int kolumner, int hgap, int vgap): Använd den här konstruktorn, vi genererar en rutnätlayout med angivna rader och kolumner och horisontella och vertikala luckor.

Följande exempel implementerar GridLayout i 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(); } }

Produktion:

GridLayout i Java

Bakgränser i Java

Om vi ​​kontrollerar programmeringsexemplen i denna handledning före layoutämnet kan vi se att vi har ställt layouten som null i dessa exempel (setLayout (null)). Vi har sett att när vi använder layoutchefer i vårt program placerar de komponenterna automatiskt.

När layouthanterare inte används kan vi använda metoden setBounds för komponentens storlek och position. Så metoden setBounds används för att manuellt placera komponenten och också ställa in storleken.

Den allmänna syntaxen för setBounds-metoden är som följer:

setBounds (int x-koordinat, int y - koordinat, int bredd, int höjd)

Låt oss nu implementera ett exempel på SetBounds-metoden.

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

Produktion:

hur man tittar gratis på anime

Bakgränser i Java

I ovanstående program har vi en knappkomponent. Vi har inte ställt in någon layout men vi har använt setBounds-metoden för att ställa in dess position och dimensioner.

Sväng mot JavaFX

GungaJavaFX
Swing tillhandahåller ett API för att skapa GUI-komponenter.JavaFX ger skript och snabb UI-utveckling associerad med skärmbyggare.
Det kommer inte att läggas till någon ny funktionalitet i Swing i framtida versioner.JavaFX ger rik funktionalitet och har potential för fler funktioner i framtida versioner.
Vi kan skapa alla standardkomponenter med Swing API.JavaFX tillåter oss att skapa rika GUI-komponenter med avancerat utseende.
Ett stort antal komponenter finns i Swing.JavaFX har ett jämförelsevis mindre antal komponenter.
Swing är ett fullt utrustat UI-bibliotek.JavaFX är ett nytt och kommande API med rika UI-komponenter.
Swing har löst MVC-stöd.JavaFX stöder MVC-mönster konsekvent.

Vanliga frågor

F # 1) Används Swing fortfarande i Java?

Svar: Ja, Swing används fortfarande i Java och det för tungt. Ibland används den som en komplett ersättning för AWT. Ibland används det också tillsammans med några av AWT-komponenterna. Den används även med den senaste JavaFX. Så Swing används fortfarande och kommer att användas under lång tid framöver.

F # 2) Hur fungerar Java Swing?

Svar: Swing in Java är skrivet ovanpå AWT-ramverket. Så händelsehantering av AWT ärvs genom att svänga helt. Swing tillhandahåller också ett stort antal komponenter som vi kan använda för att utveckla effektiva GUI-applikationer.

F # 3) Följer Swing MVC?

Svar: Swing API har löst MVC-stöd. Modellen representerar komponentens data. Gungkomponenten har ett separat element som kallas Model medan Controller och View klubbas ihop i UI-element. Denna klubba gör att gungan får ett pluggbart utseende.

F # 4) Är JavaFX bättre än Swing?

Svar: Swing har funnits länge och har mer moget IDE-stöd. Det hade också ett mycket stort bibliotek med komponenter. JavaFX är relativt nyare och har ett litet bibliotek med komponenter men med mer konsekventa uppdateringar och konsekvent MVC-stöd. Således beror det på hur JavaFX utvecklas vidare och ger fler funktioner.

F # 5) Vilket är bättre AWT eller Swing?

Svar: Swing är byggt ovanpå AWT och ger en rik och stor uppsättning UI-komponenter jämfört med AWT. Gungkomponenter kan också se ut och kännas mot AWT-komponenter som ser ut och känns av operativsystemet.

Gungkomponenter är snabbare än AWT. Alla dessa faktorer gör gungan bättre än AWT.

Mer om Java Swing

När du skapar en applikation bör du till en början ha en basbehållare och du måste lägga till nödvändiga komponenter som knappar och textfält i behållaren.

Och när du klickar eller utför någon åtgärd i vilket fält som helst kommer händelsen att inträffa och din kod ska lyssna på händelserna och även hantera händelsen.

Swing Container

En container är ett rotelement för en applikation. Alla andra komponenter läggs till den roten och den bildar en hierarki.

Det finns tre behållarklasser:

  • JFrame
  • JDialog
  • JApplet

Behållardemo med 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); } }

Behållardemo med JFrame

När du kör ovanstående program får du utmatningen nedan.

basbehållare

Komponenter

JComponent-klass är en basklass för alla komponenter i en gunga.

De ofta använda komponenterna inkluderar,

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

Alla dessa komponenter bör läggas till behållaren om inte, det kommer inte att visas i applikationen.

Exempel:

För att skapa knappinstansen,

JButton clickButton = ny JButton ();

För att lägga till knappen i behållaren,

myFrame.add ();

Händelsehantering

Alla applikationer drivs av händelser som knappklick, musklick, användartextinmatning etc. När händelsen inträffar måste du lägga till en lyssnare och måste skicka källhändelseobjektet.

Med en inre klass kan du hantera händelsen med din logik enligt nedan.

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

Händelsehantering

Slutsats

I denna handledning har vi berört basen med Swing API som tillhandahålls av Java för att bygga GUI-applikationer. Vi har diskuterat de viktigaste svängbehållarna och komponenterna och deras implementering.

Vi har också diskuterat händelsehantering i Swing. Även om händelseshanteringsmekanismen är av AWT, implementerar swing händelserna på ett effektivt sätt. Sedan diskuterade vi de olika layouthanterarna som tillhandahålls av Swing API som gör det möjligt för oss att layoutera eller ordna olika komponenter i Swing GUI-applikationerna.

=> Kolla in den perfekta Java-träningsguiden här.

Rekommenderad läsning

^