• hjem
  •  > 
  • Android
  •  > 
  • Grensesnitt i Java til fingerspissene. Grunnleggende om grafisk brukergrensesnitt Komponenter og beholdere

Grensesnitt i Java til fingerspissene. Grunnleggende om grafisk brukergrensesnitt Komponenter og beholdere

I denne korte artikkelen vil jeg beskrive prosessen med å lage et lite program som støtter GUI på språket Java. Det forutsettes at leseren er kjent med det grunnleggende i språket Java.

Så, hvilke verktøy trenger vi:

  • Java Virtual Machine (OpenJDK eller Oracle JDK)
  • Intellij IDEA(eller annen Java IDE)

Etter installasjon nødvendig programvare, åpen Intellij IDEA og skape nytt prosjekt: Fil -> Nytt prosjekt...

Jeg kalte prosjektet guiBase. Som du kan se på skjermbildet, mappen src inneholder ikke noe, så vi lager hovedklassen vår i den som inneholder funksjonen hoved-.

Offentlig klasse Main ( public static void main(String args) ( System.out.println("Hei, Govzalla!"); ) )

Du kan se innholdet i hovedklassen ovenfor. Vi kan nå lage et prosjekt ( Bygge prosjekt ) og kjør den ( Løpe ). Nede i terminalen din IDE du vil se en melding "Hei, Govzalla!". Men som du selv forsto, støtter den ikke GUI.

På dette stadiet har vi allerede et fungerende program, men uten GUI-støtte. Og nå i samme mappe src la oss skape GUI-skjema: Ny -> GUI-skjema

Åpne det opprettede GUI-skjemaet, klikk på JPanel og angi identifikatoren i feltet feltnavn, Jeg spurte panel.

Dra den deretter til skjemaet på høyre side JTextField, JPasswordField Og JButton:

Alt som gjenstår er å legge til koden og koble skjemaet vårt til det. Da vi la til skjemaet Hovedvindu, ble klassen automatisk opprettet Hovedvindu, denne klassen er klassen til den opprettede formen, dvs. Det er denne klassen som vil betjene alle arrangementer av denne formen.

Selv om vindusklassen vår inneholder de nødvendige elementene, har den ikke nå noe med GUI å gjøre, så la oss utvide den med JFrame og arve all den grunnleggende og nødvendige GUI-funksjonaliteten .

Foreløpig har vi skjemaet Hovedvindu og klasse Hovedvindu utvidet med JFrame. Nå må vi definere alle de ekstra GUI-elementene som innholdet i klassen Hovedvindu
this.getContentPane().add(panel);
Deretter vil innholdet i MainWindow.java-filen endres som følger:

Importer javax.swing.*; offentlig klasse MainWindow utvider JFrame (privat JTextField textField1; privat JPasswordField passordField1; private JButton button1; private JPanel panel; public MainWindow() ( this.getContentPane().add(panel); ) )

Hvis du prøver å kjøre koden, vil du se den samme "Hei, Govzalla!"-meldingen igjen. Faktum er at vi opprettet en klasse og et skjema for den, men ikke opprettet en forekomst av denne klassen.

Det er på tide å endre Main.java-filen og legge til koden for å lage vår GUI der:

Importer java.awt.*; public class Main ( public static void main(String args) ( // Opprett en forekomst av MainWindow-klassen MainWindow mainWindow = new MainWindow(); // Pakk alle elementene fra skjemaet mainWindow.pack(); // Endre størrelsen på vinduet mainWindow.setSize( new Dimension(200, 200)); // Vis det opprettede vinduet mainWindow.setVisible(true); ) )

Kjører koden

Ved å klikke på knappen, vil du legge merke til at programmet ikke reagerer i det hele tatt. Saken er at vi ikke har lagt til lytteren ennå ( Lytter) for arrangementer ( arrangementer)-knapp Knapp.

Hendelseslytter ( Event lytter) JButton må være implantasjonsadapter ActionListener, så la oss legge til følgende kode i klassekroppen Hovedvindu:

Privatklasse MyButtonListener implementerer ActionListener ( @Override public void actionPerformed(ActionEvent actionEvent) ( ) )

Metode handlingUtført() vil behandle alle hendelser av button1, men først må du fortsatt fortelle button1 hvilken klasse den skal behandle, så legg til følgende kode til konstruktøren av MainWindow-klassen:
this.button1.addActionListener(ny MyButtonListener());
For å forhindre at behandleren vår er meningsløs, legg til følgende kode i metoden handlingUtført():

@Override public void actionPerformed(ActionEvent actionEvent) ( if (textField1.getText().equals(passwordField1.getText())) ( JOptionPane.showMessageDialog(null, "Success"); ) else ( JOptionPane.showMessageDialog(Fail) " "); ) )

Nå vil programmet reagere riktig på arrangementer, men ikke på alle arrangementer, selvfølgelig. For eksempel, hvis du prøver å deaktivere programmet ved å klikke på krysset, vil vinduet forsvinne, men programmet vil fortsatt fungere, fordi Hovedvinduets hendelsesbehandler er ikke lagt til.

Det grafiske grensesnittet i Java har gått gjennom en svært vanskelig vei for utvikling og dannelse. I lang tid ble den beskyldt for å være treg, grådig etter systemressurser og begrenset funksjonalitet.

Java AWT

Suns første forsøk på å lage en GUI for Java var biblioteket A.W.T.(Abstract Window Toolkit) - et verktøysett for arbeid med ulike vindusmiljøer. Sun laget et Java-lag som kaller opp metoder fra biblioteker skrevet i C. AWT-biblioteksmetoder lages og brukes grafiske komponenter driftsmiljø. På den ene siden er dette bra, siden et Java-program ligner på andre programmer innenfor samme OS. Men når du kjører den på en annen plattform, kan det være forskjeller i størrelsene på komponenter og fonter som vil ødelegge programmets utseende.

For å sikre multi-plattform A.W.T. Komponentanropsgrensesnittene ble samlet, som et resultat av at funksjonaliteten deres ble litt redusert. Og settet med komponenter viste seg å være ganske lite. For eksempel har ikke AWT tabeller, og knapper støtter ikke visning av ikoner. Fortsatt pakken java.awt har vært inkludert i Java siden den aller første utgivelsen og kan brukes til å lage GUIer.

Så komponentene A.W.T. De gjør ikke noe "arbeid". Det er rett og slett en "Java wrapper" for kontrollene til operativsystemet de kjører på. Alle forespørsler til disse komponentene blir omdirigert til operativsystemet, som gjør alt arbeidet.

Ressurser brukt A.W.T. prøver å frigjøres automatisk. Dette legger litt kompleksitet til arkitekturen og påvirker ytelsen. Det vil være litt vanskelig å skrive noe seriøst med AWT. I dag brukes den kun til appleter.

Grunnleggende konsepter for SWING

Etter A.W.T. Sol utviklet seg grafikkbibliotek komponenter Svinge, skrevet helt i Java. 2D brukes til gjengivelse, noe som gir flere fordeler. Settet med standardkomponenter overgår betydelig AWT i variasjon og funksjonalitet. Swing gjør det enkelt å lage nye komponenter ved å arve fra eksisterende, og støtter ulike stiler og skinn.

Skaperne av det nye biblioteket brukergrensesnitt Svinge De "oppfant ikke hjulet på nytt" og valgte AWT som grunnlag for biblioteket deres. Selvfølgelig snakket vi ikke om å bruke spesifikke tungvekts AWT-komponenter (representert av knappene, etiketten og lignende). Kun lette komponenter ga den nødvendige grad av fleksibilitet og kontrollerbarhet. Arvediagrammet viser forholdet mellom AWT og Swing.

Den viktigste forskjellen Svinge fra AWT er at Swing-komponenter ikke er koblet til operativsystemet i det hele tatt og er derfor mye mer stabile og raske. Disse komponentene kalles lettvektere i Java, og å forstå de grunnleggende prinsippene for hvordan de fungerer, vil langt på vei forklare hvordan Swing fungerer.

Svingbeholdere på høyeste nivå

For å skape GUI applikasjoner må bruke spesielle Swing-bibliotekskomponenter kalt containere toppnivå(beholdere på øverste nivå). De er operativsystemvinduer som inneholder brukergrensesnittkomponenter. Beholdere på toppnivå inkluderer JFrame- og JWindow-vinduene, JDialog-dialogboksen og JApplet-appleten (som ikke er et vindu, men også designet for å vise grensesnittet i nettleseren som starter denne appleten). Swings øverste containere er tungvektskomponenter og er unntaket fra hovedregelen. Alle andre Swing-komponenter er lette.

Enkel Svinge eksempel på å lage et vindusgrensesnitt JFrame.

Importer java.awt.Dimension; import javax.swing.JFrame; import javax.swing.JLabel; public class JFrameTest ( public static void createGUI() ( JFrame frame = new JFrame("Test frame"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JLabel label = new JLabel("Test label"); frame.getContentPane(). add(label); frame.setPreferredSize(new Dimension(200, 100)); frame.pack(); frame.setVisible(true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); javax. swing.SwingUtilities.invokeLater(new Runnable() ( public void run() ( createGUI(); ) )); ) )

Konstruktør JFrame() uten parametere oppretter et tomt vindu. Konstruktør JFrame (strengtittel) oppretter et tomt vindu med tittel tittel. For å lage et enkelt program med et tomt vindu, må du bruke følgende metoder:

  • setSize(int width, int height) - bestemme størrelsen på vinduet;
  • setDefaultCloseOperation(int-operasjon) - definerer handlingen når programmet avsluttes;
  • setVisible(boolean synlig) - gjør vinduet synlig.

Hvis du ikke definerer dimensjonene til et vindu, vil det ha null høyde uansett hva som er i det. Vindusdimensjonene inkluderer ikke bare "arbeidsområdet", men også kantlinjene og tittellinjen.

Metoden setDefaultCloseOperation spesifiserer handlingen som skal utføres når "programmet avsluttes". For å gjøre dette, bør du sende konstanten EXIT_ON_CLOSE, beskrevet i JFrame-klassen, som operasjonsparameter.

Som standard er vinduet laget usynlig. For å vise vinduet på skjermen kalles setVisible-metoden med den sanne parameteren. Hvis det kalles opp med parameteren false, vil vinduet bli usynlig.

GUI java swing eksempel på å lage et vindu JFrame er presentert i følgende figur.

For å koble til biblioteket Svinge applikasjonen må importere biblioteket javax.swing.

Hver gang en beholder på øverste nivå opprettes, det være seg et vanlig vindu, en dialogboks eller en applet, en rotpanel JRootPane. Swings toppnivåbeholdere sikrer at andre komponenter ikke kan komme utenfor JRootPane.

Rotpalel JRootPane legger til "dybde"-egenskapen til containere, og gir muligheten til ikke bare å plassere komponentene over hverandre, men også, om nødvendig, endre plassering, øke eller redusere dybden til komponentene. Denne funksjonen er nødvendig når du oppretter en flerdokumentapplikasjon. Svinge, der vinduer representerer lette komponenter plassert oppå hverandre, samt rullegardinmenyer (kontekstuelle) og verktøytips.

Følgende figur viser tydelig strukturen til rotpanelet JRootPane.

Rotpanel JRootPane er en beholder som er arvet fra Swing-baseklassen JComponent. I denne beholderen er en spesiell layout manager, implementert i den interne klassen RootPaneLayout, ansvarlig for arrangementet av komponenter. Denne layoutadministratoren er ansvarlig for å sørge for at alle komponentdelene i rotpanelet er plassert som de skal: et lagdelt panel tar opp hele vindusplassen; laget FRAME_CONTENT_LAYER inneholder menylinjen og innholdspanelet, og fremfor alt dette er det et gjennomsiktig panel.

Alle komponenter i rotpanelet JRootPane kan fås eller endres. For å gjøre dette har den et sett med get/set-metoder. Programmatisk JRootPane kan fås ved å bruke getRootPane()-metoden.

I tillegg til beholdere på toppnivå, brukes rotpanelet i interne JInternalFrame-vinduer som er opprettet i multi-dokumentapplikasjoner og plassert på JDesktopPane "skrivebord". Dette lar deg glemme det faktum at disse vinduene er vanlige lettvektskomponenter og jobber med dem som om de var ekte toppnivåcontainere.

JLayeredPane

I bunnen av rotpanelet (beholderen) ligger det såkalte flerlagspanelet JLayeredPane, som opptar all tilgjengelig plass i beholderen. Det er i dette panelet alle andre deler av rotpanelet er plassert, inkludert alle brukergrensesnittkomponenter.

JLayeredPane brukes til å legge til en dybdeegenskap til beholderen. Det vil si at et flerlagspanel lar deg organisere en tredje dimensjon i beholderen, langs hvilken lagene til komponenten er plassert. I en vanlig beholder bestemmes plasseringen av en komponent av et rektangel som viser hvor mye av beholderen komponenten opptar. Når du legger til en komponent i et lagdelt panel, må du spesifisere ikke bare rektangelet som komponenten skal okkupere, men også laget den skal plasseres i. Laget i et sandwichpanel identifiseres med et heltall. Jo høyere tall som definerer et lag, jo høyere er laget plassert.

Den første komponenten som legges til beholderen er rangert høyere enn komponenter som legges til senere. Oftest håndterer ikke utvikleren posisjonene til komponentene. Når du legger til komponenter, endres deres posisjon automatisk. Imidlertid lar et flerlagspanel deg endre posisjonen til komponenter dynamisk, etter at de er lagt til beholderen.

Laminerte panelfunksjoner er mye brukt av noen komponenter Svinge. De er spesielt viktige for multidokumentapplikasjoner, verktøytips og menyer. Multi-dokument Svinge applikasjoner bruker en spesiell beholder JDesktopPane("skrivebord"), arvet fra JLayeredPane, som huser de innvendige Swing-vinduene. Det meste viktige funksjoner flerdokumentapplikasjon - å plassere det "aktive" vinduet over andre, minimere vinduer, dra dem - leveres av mekanismene til flerlagspanelet. Hovedfordelen med å bruke et lagdelt panel for verktøytips og menyer er at de fungerer raskere. I stedet for å lage et nytt kraftig vindu for hvert verktøytips eller meny som sitter over komponenten som ba om verktøytipset eller menyen, Svinge skaper en rask, lett komponent. Denne komponenten er plassert høyt nok i det lagdelte panelet over stabelen med alle andre komponenter og brukes til å vise et verktøytips eller meny.

Flerlagspanelet lar deg organisere et ubegrenset antall lag. Struktur JLayeredPane inkluderer flere standardlag, som brukes av alle Swing-komponenter, noe som sikrer korrekt drift av alle mekanismene til flerlagspanelet. Standard JLayeredPane-lagene er vist i følgende figur.

Standardlaget brukes til å huse alle de normale komponentene som legges til beholderen. Dette laget inneholder de interne vinduene i multidokumentapplikasjoner.

Palettlaget er designet for å huse vinduer med et sett med verktøy, som vanligvis overlapper andre grensesnittelementer. Du kan lage slike vinduer ved å bruke JDesktopPane, som plasserer dem på dette laget.

Modal-laget var ment å være vert for lette modale dialogbokser. Imidlertid slik dialogbokser har ennå ikke blitt implementert, så dette laget brukes foreløpig ikke i Swing.

Det mest brukte laget for å plassere popup-menyer og verktøytips.

Det øverste laget. Designet for dra-og-slipp-operasjoner som skal være godt synlig i programgrensesnittet.

Et lite eksempel på en JLayeredPane med et lagdelt panel viser hvordan du legger til komponenter i forskjellige lag og hvordan lagene stables oppå hverandre:

Importer javax.swing.*; importer java.awt.*; // klasse for tegning av to typer figurer med tekstklasse Figur utvider JComponent (privat statisk endelig lang serialVersionUID = 1L; privat Fargefarge; privat int-type; privat strengtekst; // parametere: farge og type figur Figur(Fargefarge, int type, String text) ( this.color = color; this.type = type; this.text = text; setOpaque(false); ) public void paintComponent(Graphics g) ( // tegne figuren g.setColor(color) ; bryter (type ) ( case 0: g.fillOval(0, 0, 90, 90); break; case 1: g.fillRect(0, 0, 130, 80); break; ) g.setColor(Color.yellow ); g. drawString(text, 10, 35); ) ) public class JLayeredPaneTest utvider JFrame (privat statisk endelig lang serialVersionUID = 1L; public JLayeredPaneTest() ( // opprette et vindu super("Eksempel LayeredTest"); // exit når du lukker vinduet setDefaultCloseOperation( EXIT_ON_CLOSE); // definerer et flerlagspanel JLayeredPane lp = getLayeredPane(); // oppretter tre figurer Figur figur1 = ny figur(Color.red , 0, "Figur popup"); Figur figur2 = ny figur(Color.blue, 0, "Figur 1"); Figur figur3 = ny figur(Color.cyan, 1, "Figur 2"); // bestemme plasseringen av figurene i vinduet figure1.setBounds(10, 40, 120, 120); figure2.setBounds(60, 120, 160, 180); figur3.setBounds(90, 55, 250, 180); // legge former til forskjellige lag lp.add(figur1, JLayeredPane.POPUP_LAYER); lp.add(figur2, JLayeredPane.PALETTE_LAYER); lp.add(figur3, JLayeredPane.PALETTE_LAYER); // endre posisjonen til en av figurene lp.setPosition(figur3, 0); // bestemme størrelsen og åpne vinduet setSize(280, 250); setVisible(true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new JLayeredPaneTest(); ) )

Eksemplet skaper lite vindu JFrame og flere figurkomponenter er lagt til det lagdelte panelet. For å få et lagdelt panel i en hvilken som helst Swing-beholder på toppnivå, ring bare metoden getLayeredPane().

Hjelpeklassen Figur arver egenskapene til basisklassen JComponent og lar deg tegne to typer former (sirkler og rektangler) i forskjellige farger. Parametre for tegning av figurer settes i klassekonstruktøren.

Når du definerer et grensesnitt, opprettes tre former med forskjellige farger (to sirkler og et rektangel). Sirkelen plasseres i POPUP_LAYER-laget, og rektanglene plasseres i PALETTE_LAYER-laget. Når du plasserer komponenter, spesifiserer du deres absolutte skjermkoordinater fordi vanlige layoutadministratorer ikke fungerer i et lagdelt panel.

Til slutt endres plasseringen av et av rektanglene slik at det er det første i laget, selv om det opprinnelig ble lagt til nummer to. Når du starter applikasjonen, vil du se at det lagdelte panelet fungerer og ordner komponentene pent i henhold til deres lag og posisjoner.

I konvensjonelle applikasjoner brukes sandwichpanelet sjelden direkte, der det utfører sine funksjoner usynlig. Noen ganger hjelper det imidlertid å lage fantastiske effekter og uvanlige grensesnitt, som for eksempel lar deg plassere animasjon eller video på toppen av vanlige komponenter, uten å kreve overmenneskelig innsats og triks fra utvikleren.

Innholdspanel

Innholdsrute ContentPane er den neste delen av rotruten, som brukes til å huse programmets brukergrensesnittkomponenter. Innholdspanel tar opp mesteparten av plassen til et lagdelt panel (bortsett fra plassen som opptas av menylinjen). For å forhindre at innholdspanelet skjuler komponenter som senere legges til vinduet, plasserer det lagdelte panelet det i et spesielt, veldig lavt lag kalt FRAME_CONTENT_LAYER, nummerert -30000.

Du kan få tilgang til innholdspanelet ved å bruke metoden getContentPane() klasse JFrame. Ved å bruke add(Component component)-metoden kan du legge til et hvilket som helst kontrollelement til den. Erstatte Innholdspanel med et hvilket som helst annet panel av typen JPanel kan du bruke metoden setContentPane()

Eksempel på å legge til en knapp i innholdspanelet:

JButton newButton = new JButton(); getContentPane().add(newButton);

Som et resultat får vi et vindu med en knapp. Knappen opptar hele det tilgjengelige området av vinduet. Denne effekten er ikke nyttig i alle programmer, så det er nødvendig å bruke forskjellige måter å arrangere elementer på panelet.

Innholdspanelet kan erstattes fullstendig. Vurder følgende Svinge eksempel på bruk av innholdspanelet Innholdspanel.

Importer javax.swing.*; public class ContentPaneReplace utvider JFrame (privat statisk endelig lang serialVersionUID = 1L; public ContentPaneReplace() ( super("Test ContentPane"); setDefaultCloseOperation(EXIT_ON_CLOSE); // Lag et panel med to knapper JPanel contents = new JPanel(); contents. add (new JButton("Familie")); contents.add(new JButton("School")); // Erstatter innholdspanelet setContentPane(contents); // Bestemmer størrelsen på vinduet setSize(200, 100); // Åpner vinduet setVisible (true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new ContentPaneAdd(); ) )

Eksemplet lager et lite vindu og et panel med to knapper, som er deretter setContentPane() erstatter vinduets innholdspanel. Dermed ble en erstatning brukt i stedet for en enklere addisjon - kalle add()-metoden. Vindusgrensesnittet vises i følgende skjermbilde.

Innholdspanel Innholdspanel i seg selv er ikke noe spesielt. Du trenger bare å huske at komponentene er lagt spesifikt til den.

Gjennomsiktig JOptionPane

Gjennomsiktig panel JOptionPane plassert som rotpanel over alle elementene i flerlagspanelet. Plasseringen av JOptionPane styres av rotpanelet, som plasserer det gjennomsiktige panelet over det lagdelte panelet slik at det dekker hele vindusområdet, inkludert området som er okkupert av menylinjen.

JOptionPane Det brukes sjelden i applikasjoner, så som standard gjør rotpanelet det usynlig, noe som reduserer belastningen på tegnesystemet. En ting du bør huske på er at hvis du gjør et gjennomsiktig panel synlig, må du være sikker på at det er gjennomsiktig (dets ugjennomsiktige egenskap er satt til falsk) fordi ellers vil det skjule alle andre elementer i rotpanelet og resten av grensesnittet vil være usynlig.

I hvilke tilfeller kan et gjennomsiktig panel brukes? JOptionPane? Med dens hjelp kan du identifisere applikasjonsfunksjoner som vil kreve alvorlig innsats å implementere fra bunnen av. Det gjennomsiktige panelet kan tilpasses for automatisert brukergrensesnitttesting. Hendelsene syntetisert i den lar deg spore mellomliggende feilsøkingsresultater. Noen ganger er denne tilnærmingen mye mer effektiv enn manuell testing.

Gjennomsiktig panel JOptionPane kan brukes til en kul animasjon for å "flyte" på toppen av alle komponenter, inkludert menylinjen, eller for å avskjære hendelser hvis noen av dem må behandles før de sendes til hoveddelen av brukergrensesnittet.

Eksempel på bruk av en gjennomsiktig Swing JOptionPane:

// Ved hjelp av et gjennomsiktig panel JOptionPane import java.awt.Dimension; importer java.awt.Font; importer java.awt.event.WindowEvent; importer java.awt.event.WindowListener; import javax.swing.JDialog; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JOptionPane; import javax.swing.UIManager; offentlig klasse JOptionPaneTest utvider JFrame (privat statisk endelig lang serialVersionUID = 1L; offentlig statisk endelig Font FONT = new Font("Verdana", Font.PLAIN, 11); public static void createGUI() ( JFrame frame = new JFrame("Test JOptionPane "); frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); frame.addWindowListener(new WindowListener() ( public void windowActivated(WindowEvent event) () public void windowClosed(WindowEvent event) () public void windowEvented event) (Window) public void event) (Window) windowDeiconified(WindowEvent event) () public void windowIconified(WindowEvent event) () public void windowOpened(WindowEvent event) () public void windowClosing(WindowEvent event) ( Object options = ( "Ja", "Nei!" ); int rc = JOptionPane.showOptionDialog(event.getWindow(), "Lukk vindu?", "Confirmation", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, options); if (rc == 0) ( event.getWindow().setVisible (false); System.exit(0); ) ) )); JLabel label = new JLabel("Bruk gjennomsiktig panel når du lukker vinduet"); frame.getContentPane().add(label); frame.setPreferredSize(ny dimensjon(350, 80)); frame.pack(); frame.setLocationRelativeTo(null); frame.setVisible(true); ) public static void main(String args) ( javax.swing.SwingUtilities.invokeLater(new Runnable() ( public void run() ( UIManager.put("Button.font", FONT); UIManager.put("Label.font ", FONT); JFrame.setDefaultLookAndFeelDecorated(true); JDialog.setDefaultLookAndFeelDecorated(true); createGUI(); ) )); ) )

Hvis du sender en konstant til metoden setDefaultCloseOperation JFrame.EXIT_ON_CLOSE, så når vinduet lukkes, slutter programmet å fungere. I eksemplet sendes en konstant til denne metoden JFrame.DO_NOTHING_ON_CLOSE slik at det ikke skjer noe når vinduet lukkes. Applikasjonen i eksemplet er avsluttet fra JFrame-lytteren WindowListener i metoden vindu lukkes. Når et vindu er lukket, kalles windowClosing-metoden med WindowEvent-hendelsesparameteren, som i den gjennomsiktige Swing JOptionPane åpner en bekreftelsesdialog.

Følgende skjermbilde viser to programvinduer. Øverste hovedvindu. Når du lukker dette vinduet, åpnes den nedreen.

Menylinje JMenuBar

En av de viktige funksjonene ved å bruke JRootPane i Swing er behovet for å plassere en menylinje i vinduet JMenuBar. En seriøs applikasjon kan ikke bygges uten en slags meny for å få tilgang til programmets funksjoner. Swing-biblioteket gir utmerkede muligheter for å lage brukervennlige JMenuBar-menyer som også er lette komponenter.

Menyfelt JMenuBar er plassert i et flerlagspanel i et spesiallag FRAME_CONTENT_LAYER og opptar en liten plass øverst i vinduet. Lengden på menylinjen er lik størrelsen på vinduet. Bredden på menylinjen avhenger av komponentene den inneholder.

Rotpanelet sørger for at innholdspanelet og menylinjen JMenuBar ikke overlappet. Hvis en menylinje ikke er nødvendig, bruker rotpanelet all plass til å romme innholdspanelet.

Eksempler på sving

Kildekodene til eksemplene som er omtalt i teksten på siden kan lastes ned.

Et skjermskjema er et område som er synlig på skjermen i form av et vindu med ulike elementer- knapper, tekst, nedtrekkslister, etc. Og disse elementene i seg selv kalles komponenter.

Miljøer som lar deg interaktivt plassere komponenter på skjemaer og sette deres parametere under applikasjonsutvikling kalles RAD-miljøer. RAD står for Rapid Application Development – ​​rask applikasjonsutvikling.

I NetBeans og andre moderne utviklingsmiljøer er denne prosessen basert på komponentobjektmodellen, som er grunnen til at den kalles Object-Oriented Design (OOD).

NetBeans er et RAD-miljø som lar deg raskt og enkelt lage applikasjoner med et rikt grafisk brukergrensesnitt (GUI). Selv om Java-språkkonstruksjonene som lar deg gjøre dette ikke er veldig enkle, det første stadiet arbeider med skjermformer og deres elementer, er det ingen grunn til å fordype seg i disse finessene. Det er nok å kjenne til de grunnleggende prinsippene for å jobbe med slike prosjekter.

For det første lærer du helt fra begynnelsen hvordan du lager fullverdige applikasjoner som kan brukes til nyttige formål. Det er vanskelig å studere abstrakte konsepter i flere måneder og bare bli en profesjonell for å kunne skape noe som kan vises til andre. Det er mye mer interessant og nyttig å umiddelbart begynne å bruke den ervervede kunnskapen i praksis.

For det andre lar et slikt grensesnitt, når du løser ethvert problem, bedre formulere hvilke parametere som må angis, hvilke handlinger som skal utføres og i hvilken rekkefølge, og hva som til slutt oppnås. Og vis alt dette på skjermen: tekstinndataelementer vil tilsvare de angitte parameterne, knapper og menyelementer vil tilsvare handlinger, tekstutgangselementer vil samsvare med resultatene.

Et eksempel på å åpne et prosjekt med eksisterende kildekode.

NetBeans 5.0 hadde godt eksempel GUI-applikasjoner, men det er ikke tilgjengelig i NetBeans 5.5. Derfor bør du kopiere for videre arbeid lignende eksempel fra forfatterens nettsted eller nettstedet som dette kurset er lagt ut på. Eksemplet heter JavaApplicationGUI_example.

Først bør du pakke ut zip-arkivet og pakke ut mappen med prosjektfilene i den til mappen med prosjektene dine (for eksempel C:\Documents and Settings\User). Start deretter NetBeans-miljøet hvis det ikke allerede kjørte, og lukk eventuelle åpne prosjekter for å holde dem unna. Velg deretter Fil/Åpne prosjekt fra menyen, eller ikonet med en åpningslilla mappe på verktøylinjen, eller trykk på tastekombinasjonen ++O. Velg en mappe i dialogboksen som åpnes JavaApplicationGUI_example(det er bedre å ikke gå inn i det, men bare angi valget til denne mappen), og klikk deretter på Åpne prosjektmappe-knappen.

I dette tilfellet, hvis du ikke fjerner merket for "Åpne som hovedprosjekt", blir prosjektet automatisk hovedprosjektet.

Følgende tekst vises i kildekoderedigeringsvinduet:

* GUI_application.java

pakke java_gui_example;

* @forfatter Vadim Monakhov

public class GUI_application utvider javax.swing.JFrame (

* Oppretter nytt skjema GUI_application

offentlig GUI_application() (

initComponents();

/** Denne metoden kalles fra konstruktøren til

* Initialiser skjemaet.

* ADVARSEL: IKKE modifiser denne koden. Innholdet i denne metoden er

* alltid regenerert av Form Editor.

private void exitMenuItemActionPerformed(java.awt.event.ActionEvent evt)

* @param argumenterer kommandolinjeargumentene

public static void main(String args) (

java.awt.EventQueue.invokeLater(new Runnable() (

public void run() (

ny GUI_application().setVisible(true);

// Variabledeklarasjon - ikke modifiser

privat javax.swing.JMenuItem aboutMenuItem;

privat javax.swing.JMenuItem contentsMenuItem;

privat javax.swing.JMenuItem copyMenuItem;

privat javax.swing.JMenuItem cutMenuItem;

privat javax.swing.JMenuItem deleteMenuItem;

privat javax.swing.JMenu editMenu;

privat javax.swing.JMenuItem exitMenuItem;

privat javax.swing.JMenu filMeny;

privat javax.swing.JMenu hjelpMeny;

privat javax.swing.JMenuBar menyBar;

privat javax.swing.JMenuItem openMenuItem;

privat javax.swing.JMenuItem pasteMenuItem;

privat javax.swing.JMenuItem saveAsMenuItem;

privat javax.swing.JMenuItem saveMenuItem;

// End of variables declaration

La oss forklare noen av delene. Vi er allerede kjent med å spesifisere java_gui_example-pakken som applikasjonsklassens kode skal ligge i. Erklæringen av selve GUI_application-klassen i dette tilfellet er noe mer komplisert enn før:

public class GUI_application utvider javax.swing.JFrame

Det betyr at den offentlige klassen GUI_application er definert, som er en etterkommer av JFrame-klassen definert i swing-pakken, nestet i javax-pakken. Ordet utvider er oversatt som "utvider" (en etterkommerklasse utvider alltid evnene til forfedreklassen).

Den offentlige GUI_application()-konstruktøren oppretter et applikasjonsobjekt og initialiserer alle dets komponenter ved å bruke initComponents()-metoden, som genereres automatisk av utviklingsmiljøet og skjules i kildekoden av +Generated Code-noden.

Ved å utvide noden kan du se implementeringen av denne metoden, men du kan ikke endre koden. Vi vil ikke dvele ved hva som gjøres i den.

privat void exitMenuItemActionUtført

Det vil bli diskutert litt senere. Metode

offentlig statisk tomrom hoved(String args)

vi er allerede kjent med dette - dette er hovedmetoden for applikasjonen. Det er en metode i applikasjonsklassen vår og kjøres automatisk av Java-maskinen når applikasjonen starter. I dette eksemplet lager metoden et søknadsskjermskjema og gjør det synlig. For å forstå hvordan dette gjøres, må du studere ganske mye materiale i dette kurset.

Kjører applikasjon. En applikasjon med utvidet meny.

Når applikasjonen starter, ser skjermskjemaet ut som det som vises på figuren. Den har allerede en menymal som kan utvides og skjules, og til og med Exit-elementet fungerer. Ved å klikke på den avsluttes applikasjonen.

ExitMenuItemActionPerformed-operatøren er ansvarlig for å klikke på dette menyelementet. Ved utforming av et skjermskjema er det tilordnet som hendelsesbehandler– en underrutine som utføres når en hendelse inntreffer. I vårt tilfelle er hendelsen valget av menyelementet Exit, og exitMenuItemActionPerformed-behandleren kalles. Det er bare én linje inni den

Det får hovedmetoden til å slutte å kjøre og avslutte applikasjonen med en utgangskode på null. Som regel returneres en avslutningskode som ikke er null når en applikasjon avsluttes unormalt, slik at verdien kan brukes til å bestemme årsakene til programkrasj.

Skjermredigerer

Klikk på Design-fanen øverst til venstre i kildekoderedigeringsprogrammet. Samtidig vil vi bytte fra kildekoderedigeringsmodus (Kildefanen er aktiv) til skjermformredigeringsmodus, som vist i figuren.

Redigere et skjermskjema.

I stedet for kildekoden vises utseendet til skjermskjemaet og komponentene som er plassert på det. Til høyre for vinduet der skjermformen vises i redigeringsmodus, er det Palett-vinduene for komponentpaletten og Egenskaper-vinduet for å vise og redigere egenskapene til gjeldende komponent.

En egenskap er et datafelt som kan utføre en handling etter å ha endret verdien. For eksempel, når du endrer verdien på bredden til en komponent, tegner du komponenten med den nye bredden på skjermen. Et "vanlig" datafelt er ikke i stand til dette. Dermed er en egenskap et "smart datafelt".

Komponentpaletten er designet for å velge typen komponent som programmereren må plassere på skjermskjema. La oss for eksempel legge til en komponent av typen JButton i skjemaet vårt (forkortelse for Java Button - "Java-knapp"). For å gjøre dette, klikk på JButton-elementet på paletten og flytt musen til ønsket plassering på skjermbildet. Når musen treffer et område av skjermbildet, vises en knapp på den standard størrelse, som beveger seg med musen. Klikk inn på rett sted form fører til at knappen forblir på det stedet. En ramme og små firkanter vises rundt den, som indikerer at komponenten vår er valgt. Egenskaper for den vises og redigeres i vinduet Egenskaper.

I tillegg kommer linjer fra den valgte komponenten, som det er en snap for å angi posisjonen til komponenten på skjemaet.

Som standard er komponentetiketter spesifisert som typenavn etterfulgt av komponentnummer. Men istedet stor bokstav, i motsetning til typenavnet, brukes små bokstaver. Derfor vil den første knappen bli merket jButton1, den andre - jButton2, og så videre. Variabler som tilsvarer knapper opprettet automatisk i kildekoden vil ha samme navn.

Det er flere måter å endre etiketten på en knapp. Først dobbeltklikker du på den og redigerer teksten. For det andre, ved å gå til Egenskaper-vinduet, endre verdien på Tekst-egenskapen og klikke for å fullføre oppføringen. For det tredje, ved å endre etikettegenskapen på samme måte. Til slutt, i Egenskaper-vinduet kan du ikke redigere tekst i et enkeltlinjes verdiinntastingsfelt for tekst- eller etikettegenskapene, men ved å åpne en flerlinjeredigering ved å klikke på knappen til høyre foret. Imidlertid hjelper ikke editorens flerlinjers natur til å gjøre etiketten på knappen flerlinjet.

Skriv inn "OK" på knappen – bruk denne knappen for å avslutte programmet.

Redigere komponentegenskaper

Størrelsen på komponenten stilles inn med musen ved å ta tak i rammen og utvide eller trekke seg sammen i passende retninger. Installasjon til et nytt sted ved å dra komponenten med musen.

Noen egenskaper for den valgte komponenten (dens størrelse, plassering, tekst) kan endres direkte i visningsområdet. Imidlertid vises og endres de fleste egenskapene i vinduet for redigering av egenskaper. Den består av to kolonner: den venstre viser egenskapsnavnene, den høyre viser verdiene deres. Verdiene i høyre kolonne kan i mange tilfeller redigeres direkte i tabellcellene. I dette tilfellet avsluttes inntastingen ved å trykke eller gå ut av den redigerte cellen, og du kan avbryte resultatene av uferdige inndata ved å trykke .

På høyre side av hver celle er det en knapp merket "..." - i moderne operativsystemer er det vanlig å legge til tre prikker i navnene på menyelementer og knapper, etter å ha klikket som en dialogboks åpnes. I dette tilfellet åpnes et spesialisert redigeringsvindu for den tilsvarende egenskapen, hvis den finnes.

Hvis du trenger å vise og redigere et stort antall komponentegenskaper, kan det være mer praktisk å høyreklikke på ønsket komponent og velge "Egenskaper" fra hurtigmenyen som vises. I dette tilfellet åpnes et eget vindu for redigering av komponentegenskaper. Du kan holde et vilkårlig antall slike vinduer åpne samtidig.

Boolske egenskaper i egenskapsverdikolonnen vises som avkrysningsboksvalgknapper - firkanter med mulighet for å sette et hake inni. Hvis det ikke er noen hake, er egenskapsverdien usann; hvis det er en hake, er egenskapsverdien sann.

Ved å bruke en knapp som eksempel lister vi opp en rekke av noen av de viktigste egenskapene som kan settes for komponenter. Mange av dem gjelder også for andre komponenter.

Eiendomsnavn Hva spør den om?
bakgrunn Bakgrunnsfarge
komponentPopupMenu Lar deg angi en hurtigmeny som vises når du høyreklikker i komponentområdet.
font Skriften som brukes til å skrive på komponenten.
forgrunnen Fargen på fonten som brukes for inskripsjonen på komponenten.
ikon Et bilde som er tegnet på komponenten ved siden av teksten.
tekst Tekst (etikett) på komponenten.
toolTipText Et verktøytips som dukker opp etter en stund når du holder musen over en komponent.
grense Type ramme rundt komponenten.
kantmalt Om det er tegnet en kant rundt komponenten.
contentAreaFilled Er det en fargefylling for det indre området av komponenten (for knapper skaper den en tredimensjonal effekt; uten fylling ser knappen flat ut).
defaultCapable Er knappen i stand til å være en "standardknapp": når den trykkes "Standardknappen" trykkes automatisk (det bør være en slik knapp på skjermskjemaet).
aktivert Om komponenten er tilgjengelig. Som standard er alle komponenter som er opprettet på skjemaet tilgjengelige. Utilgjengelige komponenter er malt med matte farger.

Som et eksempel, la oss legge til et verktøytips for knappen vår: skriv inn teksten "Denne knappen er ment å avslutte programmet" i feltet som tilsvarer egenskapen toolTipText. Dessverre kan hintet bare være én linje - oversettelse av tegn til ny linje Når de vises, ignoreres hint, selv om de er angitt programmatisk i linjen.

Til slutt, la oss angi handlingen som skal utføres når knappen klikkes - hendelsesbehandler(hendelsesbehandler) knappen klikker. For å gjøre dette, velg først knappen, høyreklikk deretter på den, og velg Hendelser/Handling/Utført handling i hurtigmenyen som vises.

Tilordne en hendelsesbehandler

Hendelser betyr "Hendelser", Handling betyr "Handling", handling Utført betyr "utført handling".

Etter dette vil en automatisk overgang til kildekodeeditoren skje, og en mal hendelsesbehandler vil vises der:

// TODO legg til håndteringskoden din her:

Et lignende resultat kan oppnås enda mer på en rask måte– etter at vi har valgt en knapp i skjemaredigeringsvinduet (Design), vises og utheves navnet på denne knappen i Navigator-vinduet. Dobbeltklikk på dette navnet i navigatorvinduet fører til opprettelse av en mal hendelsesbehandler.

Ved siden av jButton1ActionPerformed-behandleren vil det være en eksisterende hendelsesbehandler som utløses når menyelementet "Avslutt" klikkes:

private void exitMenuItemActionPerformed(java.awt.event.ActionEvent evt) (

La oss erstatte linjen med kommentaren i vår hendelsesbehandler med koden som får programmet til å avslutte:

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) (

Nå, etter å ha startet programmet vårt, vil det å flytte musepekeren til knappen føre til at et verktøytips vises, og å klikke på knappen for å avslutte programmet.

Et vanlig tilfelle er å vise en melding når en hendelse inntreffer, for eksempel ved å trykke på en knapp. I dette tilfellet kalles panelet opp med meldingen:

javax.swing.JOptionPane.showMessageDialog(null,"Jeg ble klikket");

Hvis javax.swing-pakkeklassene er importert, er javax.swing-prefikset ikke nødvendig når du ringer dem.

Søknadsutseende

På applikasjonsredigeringsstadiet tilsvarer utseendet til komponentene plattformen. Når den først er lansert, blir den imidlertid helt annerledes, siden som standard vises alle Java-applikasjoner på en plattformuavhengig måte:

Utseende til en kjørende applikasjon med et plattformuavhengig brukergrensesnitt satt som standard

I tillegg vises applikasjonen vår i øvre venstre hjørne av skjermen, men vi vil gjerne at den skal vises i midten.

For å vise applikasjonen i en plattformspesifikk form (det vil si i skjemaet som bruker komponentene og innstillingene til operativsystemet), må du endre applikasjonskonstruktørkoden ved å sette inn en brukergrensesnitttype (User's Interface, forkortet UI) før du kaller initComponents-metoden:

import javax.swing.*;

importer java.awt.*;

offentlig GUI_application() (

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

)catch(Unntak e)();

initComponents();

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

Dimensjon frameSize = getSize();

setLocation(new Point((screenSize.width-frameSize.width)/2,

(screenSize.height-frameSize.width)/2)

Utseende til en kjørende applikasjon med et plattformorientert brukergrensesnitt i Windows-operativsystemet ® XP

Koden etter initComponents()-kallet er å sette programvinduet til midten av skjermen.

Det er mulig å spesifisere en annen plattformuavhengig type applikasjon - i Motiff-stilen som brukes i Solaris ® -operativsystemet. For å angi denne typen i stedet for å ringe

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()

Bør skrives

UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");

Utseende til en kjørende applikasjon med et plattformuavhengig brukergrensesnitt i Motiff-stil

Konstruksjonene som brukes vil bli tydelige for leseren etter å ha studert ytterligere deler av håndboken.

Prosjektledelse

For ikke å bli forvirret i forskjellige prosjekter og deres versjoner, spesielt med tanke på det faktum at utdanningsprosjekter ofte må overføres fra en datamaskin til en annen, bør du ta prosjektledelse på alvor. Forfatteren, som et resultat av mange års erfaring med å jobbe med forskjellige språk og programmeringsmiljøer, har følgende system blitt utviklet (korrigert i applikasjon til NetBeans-miljøet):

· For hvert prosjekt opprettes en mappe med navnet på prosjektet. Vi vil kalle det arkivmappen for dette prosjektet. Navnene på mappene som brukes kan være på russisk, så vel som navnene på applikasjoner og filer.

· Når du oppretter et nytt prosjekt, ber utviklingsmiljøet deg om å angi et mappenavn der du skal lagre det - du bør angi navnet på arkivmappen. Du blir også bedt om å angi et prosjektnavn. Dette navnet vil bli brukt av NetBeans til å lage både prosjektmappen og navnet på applikasjonen din. For å gjøre det enklere å jobbe med søknaden din i forskjellige land, anbefales det å lage dette navnet på engelsk. I prosjektmappen vil utviklingsmiljøet automatisk lage et system med undermapper for prosjektet og alle dets filer. NetBeans prosjektmappestruktur er beskrevet tidligere.

· Hvis et prosjekt med eksisterende kildekode tas, kopieres mappen til arkivmappen vår, enten manuelt eller ved å velge riktig rekkefølge av handlinger i NetBeans Project Creation Wizard.

· Når du mottar en litt brukbar versjon av prosjektet, bør du klare det arkivkopi. For å gjøre dette, i et åpent prosjekt i "Prosjekter"-vinduet, høyreklikker du bare på prosjektnavnet og velger "Kopier prosjekt" fra hurtigmenyen som vises. Et dialogskjema åpnes der et automatisk generert kopinavn foreslås - et understrek og et kopinummer legges til det opprinnelige prosjektnavnet. For den første kopien er det _1, for den andre _2, og så videre. Dessuten forblir hovedmappen til arkivet som standard den samme som det opprinnelige prosjektet. Noe som er veldig praktisk, fordi det gjør det mulig å lage en kopi med bare tre museklikk uten å skrive noe fra tastaturet.

Opprette en arbeidskopi av prosjektet

Det kopierte prosjektet vises automatisk i "Prosjekter"-vinduet, men blir ikke det viktigste. Det vil si at du fortsetter å jobbe med det forrige prosjektet, og alle åpne vinduer lagres. Du kan umiddelbart lukke et nytt prosjekt ved å høyreklikke på navnet og velge "Lukk prosjekt" fra hurtigmenyen som vises.

Hvorfor trengs et slikt prosjektstyringssystem? Faktum er at nybegynnere programmerere har en vane med å ødelegge resultatene av sitt eget arbeid. De utvikler prosjektet uten å vedlikeholde arkiver. De bringer den til en nesten fungerende tilstand, hvoretter de forbedrer den litt mer, så litt til - og alt slutter å fungere. Og siden de blir helt forvirret, er det ingen måte å gjenopprette en fungerende versjon. Og de har ingenting å vise til læreren eller sjefen!

Derfor bør du venne deg til å kopiere inn i arkivet alle mellomversjoner av prosjektet som er mer effektive enn de som allerede er lagret i arkivet. I virkelige prosjekter er det vanskelig å huske alle endringene som er gjort i en bestemt versjon og, enda viktigere, alle relasjonene som forårsaket disse endringene. Derfor må til og med erfarne programmerere innrømme fra tid til annen: "Ingenting fungerer!" Og gjenopprett en versjon som ennå ikke hadde de innovasjonene som førte til forvirring. Dessuten skjer det ofte det en ny versjon I noen situasjoner fungerer det ikke riktig. Og du må gå tilbake dusinvis av versjoner på leting etter den der det ikke var slike "feil". Og sammenlign deretter arbeidet til de to versjonene nøye, og finn ut årsaken til feil drift av den senere versjonen. Eller sørg for at alt er det tidligere versjoner fungerte også feil, de la bare ikke merke til feilen.

  • USSRs utenrikspolitikk i krigsårene. Låne-Leie. Teheran-konferansen. Yalta og Potsdam-konferanser 1945 Opprettelse av FN.
  • USSRs utenrikspolitikk under krigen Lend-Lease. Teheran-konferansen. Yalta og Potsdam-konferansen 1945 Opprettelse av FN.
  • Gjenopptakelse av BSG-aktiviteter. Opprettelse av Belnats partier og organisasjoner

    • Bidraget av Saleem Gul og Tomas Pavek

    I dette treningskurs Vi ser på å lage et enkelt grafisk brukergrensesnitt og legge til enkel serverfunksjonalitet til det. Spesielt skal vi se på koden som definerer oppførselen til knapper og felt på et Swing-skjema.

    Vi skal se på oppsettet og strukturen til GUI, og deretter legge til noen knapper og tekstfelt. Tekstfelt er utformet for å motta brukeroppgitt informasjon og vise resultatet av programmet. Knappen vil starte driften av funksjoner innebygd i klientdelen av programmet. Applikasjonen blir opprettet er en enkel, men fullverdig kalkulator.

    For en mer detaljert veiledning til GUI Designer-utviklingsfunksjonene, inkludert videodemonstrasjoner av ulike utviklingsfunksjoner, se.

    Estimert varighet: 20 minutter

    Oppgave 1: Opprette et prosjekt

    Det første trinnet er å lage et IDE-prosjekt for applikasjonen du utvikler. La oss gi prosjektet et navn for NumberAddition.

    1. Velg Fil > Nytt prosjekt. Du kan også klikke på New Project-ikonet på IDE-verktøylinjen.
    2. I kategorier-området velger du Java-noden. I "Prosjekter"-området velger du "Java-applikasjon". Klikk "Neste".
    3. Skriv inn NumberAddition i feltet Prosjektnavn og spesifiser en bane, for eksempel hjemmekatalogen din, som prosjektplassering.
    4. Merk av for "Bruk en separat mappe til å lagre biblioteker" og spesifiser plasseringen til bibliotekmappen (valgfritt). For mer informasjon, se Del et bibliotek med andre i et dokument Utvikle applikasjoner med NetBeans IDE.
    5. Fjern avmerkingsboksen "Opprett hovedklasse" hvis den er merket.
    6. Klikk på "Ferdig"-knappen.

    Øvelse 2: Lage grensesnittet

    For å fortsette prosessen for å lage grensesnitt, må du opprette en Java-beholder der de andre nødvendige GUI-elementene vil bli plassert. I denne aktiviteten vil en beholder bli opprettet ved hjelp av et JFrame-element. Beholderen vil bli plassert i en ny pakke, som vil vises i "Kildepakker"-noden.

    Opprette en JFrame-beholder

    1. I prosjektvinduet høyreklikker du på NumberAddition-noden og velger Ny > Annet.
    2. I dialogboksen Lag fil velger du kategorien Swing GUI Forms og filtypen JFrame Form. Klikk "Neste".
    3. Skriv inn NumberAdditionUI som klassenavn.
    4. Velg my.numberaddition-pakken.
    5. Klikk på "Ferdig"-knappen.

    IDE oppretter NumberAdditionUI-skjemaet og NumberAdditionUI-klassen i NumberAddition-applikasjonen og åpner NumberAdditionUI-skjemaet i GUI Builder. My.NumberAddition-pakken erstatter standardpakken.

    Legge til elementer: Opprette et grensesnitt

    Deretter bruker du "Palett"-vinduet frontenden søknaden er fylt med JPanel. Etter dette legges tre JLabel-elementer (tekstetiketter), tre JTextField-elementer (tekstfelt) og tre JButton-elementer (knapper) til. Hvis du ikke har jobbet med GUI-designeren før, se Designe en Swing GUI i NetBeans IDE for informasjon om komponentplassering.

    Etter å ha trukket og plassert elementene ovenfor, skal JFrame-elementet se ut som bildet nedenfor.

    Hvis det ikke er noe palettvindu i øvre høyre hjørne av IDE, velger du Vindu > Palett.

    1. For å begynne, velg et panel fra kategorien Swing Containers i paletten og dra det til JFrame.
    2. JPanel vil bli uthevet. Gå til Egenskaper-vinduet og klikk på ellipse-knappen (...) ved siden av kantfeltet for å velge en kantlinje.
    3. I Border-dialogboksen velger du TitledBorder fra listen og skriver inn Nummertilføyelse i Tittel-feltet. Klikk "OK" for å lagre endringene og lukke dialogboksen.
    4. Skjermen skal nå vise et tomt "JFrame"-element med tittelen "Number Addition" som vist på bildet. I henhold til bildet, legg til tre JLabels, tre JTextFields og tre JButtons til den.

    Gi nytt navn til elementer

    Dette trinnet vil gi nytt navn til elementene som er lagt til JFrame-elementet.

    1. Dobbeltklikk jLabel1 og endre ntrcn ("tekst"-egenskapen) til First Number.
    2. Dobbeltklikk på jLabel2 og endre teksten til Second Number.
    3. Dobbeltklikk på jLabel3 og endre teksten til Resultat.
    4. Fjern standardteksten fra jTextField1. Den viste teksten kan konverteres til redigerbar tekst. For å gjøre dette, høyreklikk tekstfeltet og velg "Rediger tekst" fra hurtigmenyen. Dette kan kreve at du gjenoppretter jTextField1 til sin opprinnelige størrelse. Gjenta dette trinnet for feltene jTextField2 og jTextField3.
    5. Endre visningsteksten til jButton1 til Clear . (Hvis du vil endre teksten til en knapp, høyreklikker du på knappen og velger Rediger tekst. Alternativt kan du klikke på knappen, sette på pause og klikke igjen.)
    6. Endre visningsteksten til jButton2 til Add .
    7. Endre visningsteksten til jButton3 til Exit .

    Nå skal det ferdige GUI se ut som bildet nedenfor:

    Øvelse 3: Legge til funksjonalitet

    Denne øvelsen vil legge til den nødvendige funksjonaliteten til knappene Legg til, Slett og Avslutt. Feltene jTextField1 og jTextField2 vil bli brukt for brukerinndata, og jTextField3 vil bli brukt til å vise resultatet av programmet. Det opprettede programmet er en enkel kalkulator. Så la oss komme i gang!

    Legger til funksjonalitet til Exit-knappen

    For at knappene skal bli funksjonelle, må hver av dem tildeles en hendelsesbehandler, som vil være ansvarlig for å svare på hendelser. I vårt tilfelle må vi identifisere knappen klikk-hendelsen - enten ved å klikke med musen eller bruke tastaturet. Derfor vil "ActionListener"-grensesnittet brukes til å håndtere "ActionEvent"-hendelser.

    1. Høyreklikk på "Avslutt"-knappen. Fra hurtigmenyen velger du Hendelser > Handling > handling Utført. Vær oppmerksom på at menyen inneholder mange andre arrangementer som programmet kan svare på! Når du velger actionPerformed-hendelsen, vil IDE automatisk legge til en ActionListener til Exit-knappen og opprette en behandlermetode for å håndtere actionPerformed-lyttermetoden.
    2. IDE-en åpner automatisk kildekodevinduet, og viser deg hvor du skal sette inn handlingen du vil at knappen skal utføre når du klikker på den (med musen eller tastaturet). "Kildekode"-vinduet skal inneholde følgende linjer: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( //TODO legg til håndteringskoden din her: )
    3. La oss nå legge til koden for handlingen som "Avslutt"-knappen skal utføre. Erstatt TODO-linjen med System.exit(0); . Den ferdige koden for "Avslutt"-knappen skal se slik ut: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( System.exit(0); )

    Legger til funksjonalitet til "Slett"-knappen

    1. Høyreklikk på "Slett"-knappen (jButton1). Fra menyen som vises, velg "Hendelser > Handling > handling Utført".
    2. Ved å klikke på "Slett"-knappen skal all tekst fjernes fra alle "jTextField"-tekstfelt. For å gjøre dette, legg til kode som ligner på den ovenfor. Den ferdige kildekoden skal se slik ut: private void jButton1ActionPerformed(java.awt.event.ActionEvent evt)( jTextField1.setText(""); jTextField2.setText(""); jTextField3.setText(""); )

    Denne koden fjerner tekst fra alle tre JTextFields, og lar dem stå tomme.

    Legger til funksjonalitet til "Legg til"-knappen

    "Legg til"-knappen skal gjøre tre ting.

    1. Den tar først brukerens input i feltene jTextField1 og jTextField2 og konverterer dem fra en "String"-type til en "Float"-type.
    2. Den vil deretter legge til de to tallene.
    3. Til slutt vil den konvertere summen til en streng og plassere den i jTextField3 .
    La oss begynne!
    1. Klikk på Design-fanen øverst i arbeidsområdet for å gå tilbake til Skjemadesign-skjermen.
    2. Høyreklikk på "Legg til"-knappen (jButton2). Fra hurtigmenyen velger du Hendelser > Handling > handling Utført.
    3. Legg til kode for handlingene som "Legg til"-knappen skal utføre. Den ferdige kildekoden skal se slik ut: private void jButton2ActionPerformed(java.awt.event.ActionEvent evt)( // Først definerer vi floatvariabler. float num1, num2, result; // Vi må analysere teksten til en type float . num1 = Float.parseFloat(jTextField1.getText()); num2 = Float.parseFloat(jTextField2.getText()); // Nå kan vi utføre addisjonen. resultat = num1+num2; // Vi vil nå sende verdien av resultat til jTextField3. // Samtidig skal vi // endre verdien av resultatet fra en flytende til en streng. jTextField3.setText(String.valueOf(result)); )

    Nå er programmet helt klart, og du kan begynne å sette sammen og utføre det.

    Øvelse 4: Utføring av programmet

    Følg disse trinnene for å kjøre programmet i IDE:

    1. Velg Kjør > Kjør hovedprosjekt (alternativt trykk F6).

      Merk. Hvis du åpner et vindu som indikerer at Project NumberAddition ikke har en hovedklasse spesifisert, bør du velge my.NumberAddition.NumberAdditionUI som hovedklasse i samme vindu og klikke OK.

    Følg disse trinnene for å kjøre programmet utenfor IDE:

    Etter noen sekunder vil applikasjonen starte.

    Merk. Hvis dobbeltklikk på en JAR-fil ikke starter programmet, se JAR-filtilknytninger på operativsystemet for mer informasjon.

    Du kan også kjøre programmet fra kommandolinjen.

    Følg disse trinnene for å kjøre programmet fra kommandolinjen:

    1. Åpne en ledetekst eller terminalvindu.
    2. Ved ledeteksten endrer du gjeldende katalog til NumberAddition/dist-katalogen.
    3. Ved ledeteksten skriver du inn følgende setning: java -jar NumberAddition.jar

      Merk. Sørg for at my.NumberAddition.NumberAdditionUI er satt som hovedklasse før du kjører applikasjonen. For å sjekke dette, høyreklikk NumberAddition-prosjektnoden i Prosjekter-panelet, velg Egenskaper fra hurtigmenyen og velg Kjør-kategorien i dialogboksen Prosjektegenskaper. Hovedklasse-feltet skal vise my.numberaddition.NumberAdditionUI .

    Event Processing Engine

    Denne opplæringen så på å svare på en enkel knappeklikk-hendelse. Det er mange hendelser som en applikasjon kan svare på. I IDE kan du se listen over tilgjengelige hendelser som kan behandles av GUI-elementer som følger:

    1. Gå tilbake til NumberAdditionUI.java-filen i redigeringsprogrammet. Klikk på "Design"-fanen for å se GUI-strukturen i GUI Builder.
    2. Høyreklikk på et GUI-element og velg "Hendelser" fra menyen som vises. Nå kan du ganske enkelt utforske innholdet i menyen uten å velge noen elementer.
    3. Alternativt kan du velge "Egenskaper" fra "Vindu"-menyen. I vinduet Egenskaper klikker du på kategorien Hendelser. "Hendelser"-fanen lar deg se og endre hendelsesbehandlere knyttet til det aktive GUI-elementet.
    4. Applikasjonen kan også svare på tastetrykk, enkelt-, dobbelt- eller trippelklikk, musepekerbevegelser, endring av størrelse på vinduer og inndatafokusbevegelser. "Hendelser"-menyen lar deg automatisk opprette hendelsesbehandlere for alle disse hendelsene. Den vanligste av disse er "Action"-arrangementet. (For mer informasjon, se hvordan du håndterer hendelser i Sun Java Events Tutorial.)

    Hvordan behandles hendelser? Hver gang du velger en hendelse fra hendelsesmenyen, oppretter IDE automatisk det som kalles en hendelseslytter og knytter den til utviklerkomponenten. For å lære mer om hendelsesbehandling, følg disse trinnene:

    1. Gå tilbake til NumberAdditionUI.java-filen i redigeringsprogrammet. Klikk på "Kilde"-fanen for å se GUI-kildekoden.
    2. Rull ned for å se de implementerte jButton1ActionPerformed() , jButton2ActionPerformed() og jButton3ActionPerformed()-metodene. Disse metodene kalles hendelsesbehandlere.
    3. Gå nå til initComponents()-metoden. Hvis denne metoden mangler, finn Generated Code-linjen og klikk på +-tegnet ved siden av den linjen for å vise den skjulte initComponents()-metoden.
    4. Legg merke til den blå blokken rundt initComponents()-metoden. Denne koden ble automatisk generert av IDE og kan ikke endres av brukeren.
    5. Se nå på selve initComponents()-metoden. Den inneholder blant annet kode som initialiserer GUI-elementer og plasserer dem på skjemaet. Denne koden genereres og oppdateres automatisk når du plasserer og endrer elementer i designmodus.
    6. I initComponents()-metoden finner du følgende kodebit: jButton3.setText("Exit"); jButton3.addActionListener(new java.awt.event.ActionListener() ( public void actionPerformed(java.awt.event.ActionEvent evt) ( jButton3ActionPerformed(evt); ) ));

      På dette tidspunktet legges et "ActionListener"-hendelseslytterobjekt til GUI-elementet, i dette tilfellet jButton3 . "ActionListener"-grensesnittet har en "actionPerformed"-metode på "ActionEvent"-objektet, som implementeres ved ganske enkelt å kalle opp hendelsesbehandleren jButton3ActionPerformed. Denne knappen svarer nå på handlingshendelser. Hver gang knappen klikkes, genereres en "ActionEvent" og sendes til "actionPerformed"-metoden til hendelseslyttergrensesnittet, som kjører koden utvikleren ga for den hendelsen i hendelsesbehandleren.

    7. Lærekort for Java GUI-applikasjoner

    Java har 2 hovedpakker for å lage grafiske grensesnitt (Graphics Brukergrensesnitt). Disse er Abstract Windows Toolkit (AWT) og Swing. AWT bruker widgets for operativsystemet, så dette biblioteket er litt raskere. Men etter min mening er Swing mer godt designet.

    I denne opplæringen vil vi se på de grunnleggende elementene i Swing-biblioteket og lage et enkelt grensesnitt (GUI) som et eksempel.

    Beholdere brukes til å gruppere grensesnittkomponenter. For å lage hovedbeholderen for en applikasjon, brukes JFrame-beholderen oftest (det finnes også JWindows og JApplet). Den enkleste måten er å arve fra JFrame og dermed få tilgang til mange metoder, for eksempel:

    setBounds(x, y, w, h) - spesifiserer koordinatene til øverste venstre toppunkt i vinduet, samt dets bredde og høyde.

    setResizable(bool) - indikerer om vinduet kan endres størrelse.

    setTitle(str) - setter vindustittelen.

    setVisible(bool) - viser faktisk vinduet.

    setDefaultCloseOperation(operation) - spesifiserer operasjonen som skal utføres når vinduet lukkes.

    Hovedkontroller:

    • JLabel - element for visning av fast tekst;
    • JTextField - enkel redigeringsboks;
    • JButton vanlig knapp(knapp);
    • JCheckBox - utvalgselement (analogt med avkrysningsboks);
    • JRadioButton - radioknapp

    Som du kan se, er alt ganske enkelt og logisk.

    Ved visning av kontroller brukes spesielle ledere - LayoutManager. Alle LayoutManagers har metoder for å legge til og fjerne elementer.

    FlowLayout - brukes til å vise elementer sekvensielt. Hvis et element ikke passer på en bestemt linje, vises det i den neste.

    GridLayout - viser elementer i form av en tabell med samme cellestørrelser.

    BorderLayout - brukes når du ikke viser mer enn 5 elementer. Disse elementene er plassert langs kantene av rammen og i midten: Nord, Sør, Øst, Vest, Senter.

    BoxLayout - viser elementer i en rad eller kolonne.

    GridBagLayout - lar deg tilordne plasseringen og størrelsen på hver widget. Dette er den mest komplekse, men også den mest effektive typen skjerm.

    Det er også verdt å være oppmerksom på arrangementshåndtering. Til dette formålet brukes såkalte Event Listeners.

    Vel, nok teori, la oss gå videre til GUI-eksemplet:

    Importer java.awt.*; importer java.awt.event.*; import javax.swing.*; offentlig klasse SimpleGUI utvider JFrame (privat JButton-knapp = ny JButton("Press"); privat JTextField-inngang = ny JTextField("", 5); privat JLabel-etikett = ny JLabel("Input:"); privat JRadioButton radio1 = ny JRadioButton ("Velg dette"); privat JRadioButton radio2 = new JRadioButton("Velg det"); privat JCheckBox check = new JCheckBox("Check", usant); public SimpleGUI() ( super("Enkelt eksempel"); this.setBounds (100,100,250,100); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); Container container = this.getContentPane(); container.setLayout(new GridLayout(3,2,2,2)); container.add(label); container.add( input); ButtonGroup group = new ButtonGroup(); group.add(radio1); group.add(radio2); container.add(radio1); radio1.setSelected(true); container.add(radio2); container.add( check); button.addActionListener(new ButtonEventListener()); container.add(button); ) class ButtonEventListener implementerer ActionListener ( public void actionPerformed(ActionEvent e) ( String message = ""; melding += "Knappen ble trykket\n"; melding += "Teksten er " + input.getText() + "\n"; melding += (radio1.isSelected()?"Radio #1":"Radio #2") + " er valgt\n"; melding += "Avmerkingsboksen er " + ((check.isSelected()) ?"checked":"unchecked"); JOptionPane.showMessageDialog(null, melding, "Output", JOptionPane.PLAIN_MESSAGE); ) ) public static void main(String args) ( SimpleGUI app = new SimpleGUI(); app.setVisible(true); ) )

    Merknader:

    getContentPane returnerer toppnivåbeholderen. ButtonGroup brukes til å lage en gruppe med sammenkoblede radioknapper.

    Den indre klassen ButtonActionListener implementerer ActionListener-grensesnittet. For å gjøre dette, må du gi en implementering av actionPerformed-metoden.

    JOptionPane brukes til å vise dialogbokser.

    Jeg ser frem til dine spørsmål og kommentarer. Hvis du vil lære mer om Swing, gi meg beskjed, så skriver jeg en annen artikkel med mer avanserte teknikker og komponenter snart.