Selles lühikeses artiklis tahan kirjeldada väikese programmi loomise protsessi, mis toetab selles keeles GUI-d Java. Eeldatakse, et lugeja on keele põhitõdedega kursis Java.
Niisiis, milliseid tööriistu me vajame:
- Java virtuaalmasin (OpenJDK või Oracle JDK)
- Intellij IDEA(või muu Java IDE)
Pärast paigaldamist vajalik tarkvara, avatud Intellij IDEA ja looge uus projekt: Fail -> Uus projekt…
Panin projektile nime guiBase. Nagu näete ekraanipildil, kaust src ei sisalda midagi, seega loome oma põhiklass mis sisaldab funktsiooni peamine.
Avalik klass Main ( public static void main(String args) ( System.out.println("Tere, Govzalla!"); ) )
Põhiklassi sisu näete ülalt. Nüüd saame luua projekti ( Ehita projekt ) ja käivita see ( Jookse ). All oma terminalis IDE näete sõnumit "Tere, Govzalla!". Kuid nagu te ise aru saite, ei toeta see GUI-d.
Selles etapis on meil juba töötav programm, kuid ilma GUI-toeta. Ja nüüd samas kaustas src loome GUI vorm: Uus -> GUI vorm
Avage loodud GUI vorm, klõpsake nuppu JPanel ja määrake väljale selle identifikaator välja nimi, Ma küsisin paneel.
Seejärel lohistage see vormile parem pool JTekstiväli, JPasswordField Ja JButton:
Jääb üle vaid kood lisada ja meie vorm sellega linkida. Kui lisasime vormi Peaaken, loodi klass automaatselt Peaaken, see klass on loodud vormi klass, st. See klass teenindab kõiki selle vormi üritusi.
Kuigi meie aknaklass sisaldab vajalikud elemendid, kuid isegi praegu pole sellel GUI-ga mingit pistmist, nii et laiendame seda JFrame ja pärivad kõik põhilised ja vajalikud GUI-funktsioonid .
IN Sel hetkel meil on vorm Peaaken ja klass Peaaken pikendatud koos JFrame. Nüüd peame määratlema kõik lisatud GUI elemendid klassi sisuna Peaaken
this.getContentPane().add(paneel);
Pärast seda muudetakse faili MainWindow.java sisu järgmiselt:
Impordi javax.swing.*; avalik klass MainWindow laiendab JFrame'i ( privaatne JTekstivälja tekstiväli1; privaatne JParoolivälja paroolväli1; privaatne JButtoni nupp1; privaatne JPaneli paneel; public MainWindow() ( this.getContentPane().add(panel); ) )
Kui proovite koodi käivitada, näete uuesti sama teadet "Tere, Govzalla!". Fakt on see, et me lõime selle jaoks klassi ja vormi, kuid ei loonud selle klassi eksemplari.
On aeg muuta Main.java faili ja lisada sinna GUI loomise kood:
Impordi java.awt.*; public class Main ( public static void main(String args) ( // MainWindow klassi eksemplari loomine MainWindow mainWindow = new MainWindow(); // Pakkige kõik elemendid vormilt mainWindow.pack(); // Muutke akna suurust mainWindow.setSize( new Dimension(200, 200) // Kuvab loodud akna mainWindow.setVisible(true) )
Koodi käivitamine
Nupu nupul klõpsates märkate, et programm ei reageeri üldse. Asi on selles, et me pole veel kuulajat lisanud ( Kuulaja) sündmuste jaoks ( Sündmused) nupp Nupp.
Sündmuse kuulaja ( Sündmuse kuulaja) JButton peab olema implantatsiooniadapter ActionListener, seega lisame klassi kehasse järgmise koodi Peaaken:
Privaatklass MyButtonListener rakendab ActionListeneri ( @Override public void actionPerformed(ActionEvent actionEvent) ( ) )
meetod toiming sooritatud() töötleb kõiki nupu 1 sündmusi, kuid kõigepealt peate siiski ütlema nupule 1, millist klassi see töötleb, seega lisage MainWindow klassi konstruktorile järgmine kood:
this.button1.addActionListener(new MyButtonListener());
Selleks, et meie töötleja ei oleks mõttetu, lisage meetodile järgmine kood toiming sooritatud():
@Override public void actionPerformed(ActionEvent actionEvent) ( if (textField1.getText().equals(passwordField1.getText())) ( JOptionPane.showMessageDialog(null, "Success"); ) else ( JOptionPane.showMessageDiaalog(nuilullMessageDiaa " ") )
Nüüd reageerib programm sündmustele õigesti, kuid loomulikult mitte kõigile sündmustele. Näiteks kui proovite programmi keelata, klõpsates ristil, siis aken kaob, kuid programm töötab endiselt, sest Peaakna sündmuste töötlejat pole lisatud.
Java graafiline liides on läbinud väga keerulise arengu ja kujunemise tee. Pikka aega süüdistati teda aeglane töö, ahnus süsteemiressursside ja piiratud funktsionaalsuse järele.
Java AWT
Suni esimene katse Java jaoks GUI loomisel oli raamatukogu A.W.T.(Abstract Window Toolkit) – tööriistakomplekt erinevate aknakeskkondadega töötamiseks. Sun tegi Java kihi, mis kutsub C-keeles kirjutatud teekide meetodeid. AWT teegimeetodid loovad ja kasutavad töökeskkonna graafilisi komponente. Ühest küljest on see hea, kuna Java-programm on sarnane teiste sama OS-i programmidega. Kuid selle käivitamisel teisel platvormil võivad komponentide ja fontide suurused erineda, mis rikub programmi välimust.
Mitme platvormi tagamiseks A.W.T. Komponentide kõneliidesed ühtlustati, mille tulemusena vähenes nende funktsionaalsus veidi. Ja komponentide komplekt osutus üsna väikeseks. Näiteks AWT-l pole tabeleid ja nupud ei toeta ikoonide kuvamist. Ikka pakk java.awt on Javasse lisatud alates selle esimesest väljalaskest ja seda saab kasutada GUI-de loomiseks.
Seega komponendid A.W.T. Nad ei tee mingit "tööd". See on lihtsalt "Java ümbris" selle operatsioonisüsteemi juhtelementide jaoks, millel need töötavad. Kõik nende komponentide päringud suunatakse ümber operatsioonisüsteemi, mis teeb kogu töö ära.
Kasutatud ressursid A.W.T. proovib automaatselt vabastada. See muudab arhitektuuri pisut keerukamaks ja mõjutab jõudlust. AWT abil on raske midagi tõsist kirjutada. Tänapäeval kasutatakse seda ainult aplettide jaoks.
SWINGi põhimõisted
Pärast A.W.T. Sun on välja töötanud graafikakomponentide raamatukogu Kiik, kirjutatud täielikult Java keeles. Renderdamisel kasutatakse 2D-d, mis toob endaga kaasa mitmeid eeliseid. Standardkomponentide komplekt ületab oluliselt AWT mitmekesisuse ja funktsionaalsuse poolest. Swing muudab uute komponentide loomise lihtsaks, pärides olemasolevatest, ning toetab erinevaid stiile ja skine.
Uue raamatukogu loojad kasutajaliides Kiik Nad ei leiutanud jalgratast uuesti ja valisid oma raamatukogu aluseks AWT. Loomulikult ei rääkinud me konkreetsete raskekaaluliste AWT komponentide kasutamisest (mida esindavad klassid Button, Label ja muud sarnased). Ainult kergekaalulised komponendid tagasid vajaliku paindlikkuse ja juhitavuse. Pärimisdiagramm näitab seost AWT ja Swingi vahel.
Kõige olulisem erinevus Kiik AWT-st on see, et Swingi komponendid ei ole üldse operatsioonisüsteemiga seotud ning on seetõttu palju stabiilsemad ja kiiremad. Neid komponente nimetatakse Javas kergeteks komponentideks ja nende tööpõhimõtete mõistmine aitab palju selgitada, kuidas Swing töötab.
Kõrgeima taseme kiigekonteinerid
Loomiseks GUI Rakendused peavad kasutama spetsiaalseid Swingi teegi komponente, mida nimetatakse tipptaseme konteineriteks. Need on operatsioonisüsteemi aknad, mis sisaldavad kasutajaliidese komponente. Tipptaseme konteinerite hulka kuuluvad JFrame ja JWindow aknad, JDialogi dialoogiboks ja JAppleti aplett (mis ei ole aken, vaid on mõeldud ka selle apleti käivitava brauseri liidese kuvamiseks). Swingi tipptasemel konteinerid on raskekaalulised komponendid ja on erand üldreeglist. Kõik muud Swingi komponendid on kerged.
Lihtne Kiik näide aknaliidese loomisest JFrame.
Impordi 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).setPreferredSize(new Dimension(200, 100)); Runnable() ( public void run() ( createGUI(); ) ) )
Konstruktor JFrame() loob ilma parameetriteta tühi aken. Konstruktor JFrame (stringi pealkiri) loob tühja akna koos pealkirja pealkiri. Looma kõige lihtsam programm tühja akna korral peate kasutama järgmisi meetodeid:
- setSize(int laius, int kõrgus) - akna suuruse määramine;
- setDefaultCloseOperation(int operation) – toimingu määratlemine programmi lõppedes;
- setVisible(tõveväärtus nähtav) – muudab akna nähtavaks.
Kui te ei määra akna mõõtmeid, on selle kõrgus null, olenemata sellest, mis selles on. Akna mõõtmed ei sisalda mitte ainult "tööala", vaid ka ääriseid ja tiitliriba.
Meetod setDefaultCloseOperation määrab toimingu, mis tuleb sooritada "programmist väljumisel". Selleks peaksite toiminguparameetrina edastama klassis JFrame kirjeldatud konstandi EXIT_ON_CLOSE.
Vaikimisi luuakse aken nähtamatuks. Akna kuvamiseks ekraanil kutsutakse välja meetod setVisible koos tõese parameetriga. Kui kutsutakse välja valeparameetriga, muutub aken nähtamatuks.
Graafiline liides java kiik näide akna loomisest JFrame on esitatud järgmisel joonisel.
Raamatukogu ühendamiseks Kiik rakendus peab importima raamatukogu javax.swing.
Iga kord, kui luuakse tipptaseme konteiner, olgu selleks siis tavaline aken, dialoogiboks või aplett, a juurpaneel JRootPane. Swingi tipptasemel konteinerid tagavad, et teised komponendid ei pääse JRootPane'ist välja.
Juurepall JRootPane lisab konteineritele omaduse “sügavus”, pakkudes võimalust mitte ainult komponente üksteise peale asetada, vaid ka vajadusel nende asukohti muuta, komponentide sügavust suurendada või vähendada. See funktsioon on vajalik mitme dokumendiga rakenduse loomisel. Kiik, milles aknad esindavad üksteise peal paiknevaid kergeid komponente, samuti rippmenüüd (kontekstipõhiseid) ja vihjeid.
Järgmine joonis näitab selgelt juurpaneeli struktuuri JRootPane.
Juurepaneel JRootPane on konteiner, mis on päritud baasklass Kiik JComponent. Selles konteineris vastutab komponentide paigutuse eest spetsiaalne paigutushaldur, mis on juurutatud siseklassis RootPaneLayout. See paigutushaldur vastutab selle eest, et kõik juurpaneeli komponendid oleksid paigutatud nii, nagu peaks: kihiline paneel võtab kogu aknapinna; selle kiht FRAME_CONTENT_LAYER sisaldab menüüriba ja sisupaneeli ning kõige selle kohal on läbipaistev paneel.
Kõik juurpaneeli komponendid JRootPane saab hankida või muuta. Selleks on sellel hankimise/määramise meetodite komplekt. Programmiliselt JRootPane saab hankida meetodi getRootPane() abil.
Lisaks tipptaseme konteineritele kasutatakse juurpaneeli sisemistes JInternalFrame'i akendes, mis on loodud mitme dokumendiga rakendustes ja asuvad JDesktopPane'i töölaual. See võimaldab teil unustada tõsiasja, et need aknad on tavalised kerged komponendid ja töötavad nendega nii, nagu oleksid need tõelised tipptasemel konteinerid.
JLayeredPane
Juurepaneeli (mahuti) põhjas asub nn mitmekihiline paneel JLayeredPane, hõivates kogu konteineri vaba ruumi. Just sellel paneelil asuvad kõik muud juurpaneeli osad, sealhulgas kõik kasutajaliidese komponendid.
JLayeredPane kasutatakse konteinerile sügavuse atribuudi lisamiseks. See tähendab, et mitmekihiline paneel võimaldab teil korraldada konteineris kolmanda mõõtme, mida mööda komponendi kihid asuvad. IN tavaline konteiner Komponendi asukoha määrab ristkülik, mis näitab, kui suure osa konteinerist komponent hõivab. Kihilisele paneelile komponendi lisamisel peate määrama mitte ainult ristküliku, mille komponent hõivab, vaid ka kihi, milles see asub. Sandwich-paneeli kiht on identifitseeritud täisarvuga. Mida suurem on kihti määratlev arv, seda kõrgemal kiht asub.
Esimene konteinerisse lisatud komponent on järjestatud kõrgemale kui hiljem lisatud komponent. Kõige sagedamini ei tegele arendaja komponentide positsioonidega. Komponentide lisamisel muutub nende asukoht automaatselt. Mitmekihiline paneel võimaldab aga komponentide asukohta dünaamiliselt muuta pärast nende konteinerisse lisamist.
Lamineeritud paneelide võimalusi kasutavad mõned komponendid laialdaselt Kiik. Need on eriti olulised mitme dokumendiga rakenduste, vihjete ja menüüde jaoks. Mitme dokumendiga Kiik rakendused kasutavad spetsiaalset konteinerit JDesktopPane("töölaud"), päritud alates JLayeredPane, kus asuvad sisemised Swing aknad. Kõige olulisi funktsioone mitme dokumendiga rakendus - "aktiivse" akna asetamine teiste kohale, akende minimeerimine, nende lohistamine - tagavad mitmekihilise paneeli mehhanismid. Tööriistavihjete ja menüüde kihilise paneeli kasutamise peamine eelis on see, et need töötavad kiiremini. Selle asemel, et luua iga tööriistaspikri või menüü jaoks uus raske aken, mis asub tööriistavihjet või menüüd taotlenud komponendi kohal, Kiik loob kiire ja kerge komponendi. See komponent asetatakse kihilises paneelis piisavalt kõrgele kõigi teiste komponentide virna kohale ja seda kasutatakse tööriistaspikri või menüü kuvamiseks.
Mitmekihiline paneel võimaldab korraldada piiramatul hulgal kihte. Struktuur JLayeredPane sisaldab mitmeid standardkihte, mida kasutavad kõik Swingi komponendid, mis tagab mitmekihilise paneeli kõikide mehhanismide korrektse töö. Standardsed JLayeredPane kihid on näidatud järgmisel joonisel.
Vaikekihti kasutatakse kõigi konteinerisse lisatud tavaliste komponentide paigutamiseks. Sellel kihil asuvad mitme dokumendiga rakenduste siseaknad.
Paletikiht on mõeldud akende paigutamiseks tööriistakomplektiga, mis tavaliselt kattuvad teiste liidese elementidega. Selliseid aknaid saate luua JDesktopPane'i abil, mis asetab need sellele kihile.
Modaalne kiht oli mõeldud kergete modaalsete dialoogibokside majutamiseks. Samas sellised dialoogibokse pole veel rakendatud, seega seda kihti Swingis praegu ei kasutata.
Kõige sagedamini kasutatav kiht hüpikmenüüde ja tööriistavihjete paigutamiseks.
Kõige ülemine kiht. Mõeldud pukseerimisoperatsioonide jaoks ( lohista ja drop), mis peaks olema programmi liideses selgelt nähtav.
Väike näide kihilise paneeliga JLayeredPane'ist näitab, kuidas erinevatele kihtidele komponente lisada ja kuidas kihid üksteise peale laotakse:
Impordi javax.swing.*; import java.awt.*; // klass kahte tüüpi kujundite joonistamiseks tekstiklassiga Joonis laiendab JComponent ( private static final long serialVersionUID = 1L; private Color color; private int type; private String text; // parameetrid: figuuri värv ja tüüp Figure(Color color, int tüüp, String text) ( this.color = color; this.type = type; this.text = text; setOpaque(false); ) public void paintComponent(Graphics g) ( // joonistage joonis g.setColor(color) ; lüliti (tüüp ) ( suurjuht ); drawString(tekst, 10, 35) ) public class JLayeredPaneTest laiendab JFrame'i ( privaatne staatiline lõplik pikk serialVersionUID = 1L; public JLayeredPaneTest() ( // looge aken super("Example LayeredTest"); // sulgege aken setDefaultCloseOperation( EXIT_ON_CLOSE) // mitmekihilise paneeli määratlemine JLayeredPane lp = getLayeredPane( // kolme figuuri loomine Figure figure1 = new Figure(Color.red , 0, "Joonis hüpikaken"); Joonis joonis2 = new Joonis(Värv.sinine, 0, "Joonis 1"); Joonis joonis3 = new Joonis(värv.tsüaan, 1, "Joonis 2"); // kujundite asukoha määramine aknas figure1.setBounds(10, 40, 120, 120); figure2.setBounds(60, 120, 160, 180); figure3.setBounds(90, 55, 250, 180); // kujundite lisamine erinevatele kihtidele lp.add(fig.1, JLayeredPane.POPUP_LAYER); lp.add(joonis2, JLayeredPane.PALETTE_KIHT); lp.add(joonis3, JLayeredPane.PALETTE_KIHT); // ühe kujundi asukoha muutmine lp.setPosition(fig.3, 0); // suuruse määramine ja akna avamine setSize(280, 250); setVisible(tõene); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); uus JLayeredPaneTest(); ) )
Näide loob väikese akna JFrame ja kihilisele paneelile on lisatud mitu figuurikomponenti. Kihilise paneeli saamiseks mis tahes tipptasemel Swingi konteinerisse helistage lihtsalt meetodile getLayeredPane().
Joonis abiklass pärib baasklassi JComponent omadused ja võimaldab joonistada kahte tüüpi kujundeid (ringid ja ristkülikud) erinevates värvides. Jooniste joonistamise parameetrid määratakse klassikonstruktoris.
Liidese määratlemisel luuakse kolm erinevat värvi kujundit (kaks ringi ja ristkülik). Ring asetatakse kihti POPUP_LAYER ja ristkülikud kihti PALETTE_KIHT. Komponentide paigutamisel määrate nende absoluutsed ekraanikoordinaadid, kuna tavalised paigutushaldurid ei tööta kihilisel paneelil.
Lõpuks muudetakse ühe ristküliku asukohta nii, et see oleks kihis esimene, kuigi algselt lisati see teisena. Rakenduse käivitamisel näete, et kihiline paneel töötab ja paigutab komponendid kenasti vastavalt nende kihtidele ja asukohtadele.
IN levinud rakendused Mitmekihilist paneeli kasutatakse harva, see täidab oma funktsioone märkamatult. Kuid mõnikord aitab see luua hämmastavaid efekte ja ebatavalisi liideseid, võimaldades näiteks paigutada animatsiooni või videot tavaliste komponentide peale, ilma et see eeldaks arendajalt üliinimlikke pingutusi ja trikke.
ContentPane
Sisupaan ContentPane on juurpaani järgmine osa, mida kasutatakse programmi kasutajaliidese komponentide majutamiseks. ContentPane võtab suurema osa kihilise paneeli ruumist (v.a menüüriba ruum). Selleks, et sisupaneel ei varjaks hiljem aknale lisatavaid komponente, asetab kihiline paneel selle spetsiaalsesse väga madalasse kihti nimega FRAME_CONTENT_LAYER, numbriga -30000.
Sisupaneelile pääsete juurde meetodi abil getContentPane() klassi JFrame. Kasutades meetodit add(Component komponent), saate sellele lisada mis tahes juhtelemendi. Asenda ContentPane Seda meetodit saate kasutada mis tahes muu JPanel tüüpi paneeliga setContentPane()
Näide nupu sisupaneelile lisamisest:
JButton newButton = new JButton(); getContentPane().add(newButton);
Selle tulemusena saame nupuga akna. Nupp hõivab kogu akna saadaoleva ala. See efekt pole kõigis programmides kasulik, seetõttu tuleb paneelil elementide paigutamiseks kasutada erinevaid viise.
Sisupaneeli saab täielikult välja vahetada. Kaaluge järgmist Kiik näide sisupaneeli kasutamisest ContentPane.
Impordi javax.swing.*; public class ContentPaneReplace laiendab JFrame'i ( privaatne staatiline lõplik pikk serialVersionUID = 1L; public ContentPaneReplace() ( super("Test ContentPane"); setDefaultCloseOperation(EXIT_ON_CLOSE); // Looge paneel kahe nupuga JPanel contents = new JPanel(); sisu. add (new JButton("Perekond")); true); public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new ContentPaneAdd(); ) )
Näites luuakse väike aken ja kahe nupuga paneel, mis siis on setContentPane() asendab akna sisupaneeli. Nii et rohkema asemel kasutati asendust lihtne lisand- meetodi add() kutsumine. Akna liides on näidatud järgmisel ekraanipildil.
Sisu paneel ContentPane iseenesest pole midagi erilist. Peate lihtsalt meeles pidama, et komponendid lisatakse sellele spetsiaalselt.
Läbipaistev JOptionPane
Läbipaistev paneel JOptionPane asetatakse juurpaneelina mitmekihilise paneeli kõigi elementide kohale. JOptionPane'i paigutust juhib juurpaneel, mis asetab läbipaistva paneeli kihilise paneeli kohale nii, et see katab täielikult kogu aknaala, sealhulgas menüüriba poolt hõivatud ala.
JOptionPane Seda kasutatakse rakendustes harva, nii et vaikimisi muudab juurpaneel selle nähtamatuks, mis vähendab joonistussüsteemi koormust. Üks asi, mida meeles pidada, on see, et kui muudate läbipaistva paneeli nähtavaks, peate olema kindel, et see on läbipaistev (selle läbipaistmatu omadus on seatud väärtusele false), sest vastasel juhul varjab see kõik juurpaneeli ja ülejäänud elemendid. liides on nähtamatu.
Millistel juhtudel saab läbipaistvat paneeli kasutada? JOptionPane? Selle abiga saate tuvastada rakenduse funktsioone, mille juurutamine nullist nõuaks tõsist pingutust. Läbipaistvat paneeli saab kohandada kasutajaliidese automaatseks testimiseks. Selles sünteesitud sündmused võimaldavad teil jälgida vahepealseid silumistulemusi. Mõnikord on see lähenemisviis palju tõhusam kui käsitsi testimine.
Läbipaistev paneel JOptionPane saab kasutada laheda animatsiooni jaoks, et "hõljuda" kõigi komponentide, sealhulgas menüüriba peal, või sündmuste pealtkuulamiseks, kui mõnda neist on vaja enne kasutajaliidese põhiossa saatmist töödelda.
Näide läbipaistva Swing JOptionPane'i kasutamise kohta:
// Läbipaistva paneeli kasutamine JOptionPane import java.awt.Dimension; import java.awt.Font; import java.awt.event.WindowEvent; importida java.awt.event.WindowListener; import javax.swing.JDialog; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JOptionPane; importida javax.swing.UIManager; avalik klass JOptionPaneTest laiendab JFrame'i ( privaatne staatiline lõplik pikk serialVersionUID = 1L; avalik staatiline lõplik Font FONT= uus Font("Verdana", Font.PLAIN, 11); public static void createGUI() ( JFrame frame = new JFrame("Testi JOptionPane"); frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); frame.addWindowListener(new WindowListener() ( public void windowAktiveeritud(aknasündmuse aken)C) WindowEvent sündmus) () avalik void akenDesaktiveeritud(WindowEvent sündmus) () avalik tühi aken Deiconified(WindowEvent sündmus) () avalik void akenIconified(WindowEvent sündmus) () avalik tühi akenAvatud(WindowEvent sündmus) () avalik tühi akenSulgemine(WindowEvent sündmus) ( objekt options = ("Jah", "Ei!" ); int rc = JOptionPane.showOptionDialog(event.getWindow(), "Sulge aken?", "Kinnitus", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, valikud, valikud) ; if (rc == 0) ( event.getWindow().setVisible(false); System.exit(0); ) )); ().add(silt);raam.setPreferredSize(new Dimension(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(); ) )); ) )
Kui edastate konstandi meetodile setDefaultCloseOperation JFrame.EXIT_ON_CLOSE, siis kui aken suletakse, lakkab rakendus töötamast. Näites antakse sellele meetodile konstant JFrame.DO_NOTTHING_ON_CLOSE et akna sulgemisel midagi ei juhtuks. Näites toodud rakendus väljub meetodi JFrame kuulajast WindowListener akna sulgemine. Kui aken on suletud, kutsutakse välja windowClosing meetod parameetriga WindowEvent, mis läbipaistvas Swing JOptionPane'is avab kinnitusdialoogi.
Järgmisel ekraanipildil on kaks rakenduse akent. Ülemine peaaken. Kui sulgete selle akna, avaneb alumise kavatsuse kinnituse dialoogiboks.
Menüüriba JMenuBar
Swingis JRootPane'i kasutamise üks olulisi omadusi on vajadus paigutada aknasse menüüriba JMenuBar. Tõsist rakendust ei saa ehitada ilma mingisuguse menüüta programmi funktsioonidele juurdepääsuks. Swingi teek pakub suurepäraseid võimalusi kasutajasõbralike JMenuBari menüüde loomiseks, mis on ka kerged komponendid.
Menüüriba JMenuBar paigutatakse mitmekihilisele paneelile spetsiaalsesse kihti FRAME_CONTENT_LAYER ja see võtab akna ülaosas väikese ruumi. Menüüriba pikkus võrdub akna suurusega. Menüüriba laius oleneb selles sisalduvatest komponentidest.
Juurpaneel tagab sisupaneeli ja menüüriba JMenuBar ei kattunud. Kui menüüriba pole vaja, kasutab juurpaneel sisupaneeli mahutamiseks kogu ruumi.
Näited kiikedest
Lehe tekstis käsitletud näidete lähtekoodid saab alla laadida.
Arvame, et oleme teid väsitanud, rääkides kogu aeg väljundprogrammidest tekstisõnumid konsooli juurde. Selles õppetükis see "tuim" näidete seeria lõpuks katkeb: näitame, kuidas Javas aknaid luuakse, ja näete, et see on lihtne ülesanne. Siin on meie kood (hakkame seda arutama järgmises õppetükis, sest sellel on palju-palju funktsioone, mida sa tõesti teadma pead):
import java.awt.*;
import javax.swing.*;
avalik klass MoneyForNothing laiendab JFrame'i (
// Konstruktor
avalik MoneyForNothing() (
setTitle("Tere tulemast Money for Nothing");
setSize(uus Dimension(600, 400));
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(tõene);
avalik static void main (String args) (
MoneyForNothing mfn = new MoneyForNothing();
Ja siin on sama kood FAR-i redigeerimisaknas:
Muide, soovitame sisestada programmide lähtekoodid kohe CP1251 kodeeringus (või tavakeeles Windowsi kodeering): kodeeringut vahetatakse, vajutades klahvi F8 ja praegune kodeering kuvatakse redigeerimisala kohal olekuribal.
Sisenemispunkt jäi muutumatuks, kuid ülejäänud kood muutus üsna palju (kuid ärgem saagem endast ette). Pärast kompileerimist ja käivitamist peaksite nägema järgmist:
Õnnitleme – vaid mõne reaga olete loonud tõelise graafikaakna! Seda saab lohistada, suurust muuta, ahendada, laiendada ja sulgeda. Tõsi, meie aken osutus mõnevõrra tuhmunud, otse öeldes - “hirmutavaks”. Lisaks kuvatakse aken ekraani vasakus ülanurgas, aga mulle meeldiks see keskel - seal on mugavam kasutada ja see väljund näeb kenam välja. Nii et teeme natuke lihvi.
Kõigepealt lahendame teise probleemi – akna tsentreerimise. Siin soovitame peatuda ja mõelda – kuidas teie seda teeksite?
Olgu öeldud, et Java graafikateegis on meetod setLocation, millele antakse parameetritena edasi akna vasaku ülanurga koordinaadid (just sellest nurgast paigutatakse akna sisse ka teised graafilised elemendid). Kuid kui seate need parameetrid "peapeale", siis peaaegu kindlasti ei tule sellest midagi head. teisel erineva eraldusvõimega monitoril on aken täiesti erinev sellest, kus ootasite. Seetõttu tuleb koordinaadid nutikamalt määrata.
Akna keskele paigutamiseks on vaja ainult teada akna enda mõõtmeid (muide, need on disaineris määratud ja moodustavad ristküliku suurusega 600 x 400 pikslit) ja ekraani eraldusvõimet ning seejärel lihtne aritmeetika, arvutage vajalikud vasaku koordinaadid ülemine nurk. See saavutatakse järgmise koodi sisestamisega
Dimensioon sSize = Toolkit.getDefaultToolkit().getScreenSize(),
fSize = getSize();
if (fSize.height > sSize.height) (fSize.height = sSize.height;)
if (fSize.width > sSize.width) (fSize.width = sSize.width;)
setLocation((sSize.width - fSize.width)/2,
(sSize.height - fSize.height)/2);
kohe pärast rida setSize(new Dimension(600, 400)); konstruktoris. Tehke lähtekoodis vajalikud muudatused, kompileerige programm ja käivitage see; aken peaks ilmuma monitori ekraani keskele.
Nüüd paar sõna akna välimuse kohta. Selle kummaline välimus on seletatav asjaoluga, et Java arendajad püüdsid tagada, et olenemata riistvaraplatvormist ja tarkvara "täidisest" oleks kõigil graafilistel elementidel (aknad, nupud, loendid jne) üks renderdus ja üks. värviskeem. Selleks töötasid nad välja erilise stiili, mida nad nimetasid "METALLiks". Kui arendaja ei tee erilisi jõupingutusi, näevad tema programmide graafilise liidese elemendid välja täpselt selles stiilis, võtmata arvesse konkreetsete arvutite ja nende tarkvara omadusi. Mõnel juhul on see mõistlik, kuid siiski nõustute, et palju parem on, kui Windowsis käivitatud programm sarnaneb Windowsi programmiga ja LINUXis käivitatud programm Linuxi programmiga. Seda on lihtne saavutada. Kõik, mida pead tegema, on sisestada enne klassi käivitamist sisenemispunkti järgmine kood:
proovige (UIManager.setLookAndFeel
(UIManager.getSystemLookAndFeelClassName());
püüda (Erand lfe) ()
Seda me teemegi. Nüüd, pärast koostamist uuendatud versioon meie programm ja käivitage see täitmiseks, näeb graafiline aken palju "korralikum" välja:
Sõltuvalt teie monitori ekraani atribuutide seadistusest on akna kuva erinev; kasutame klassikat Windowsi teema XP. Näiteks võib sama aken välja näha selline:
Veenduge, et kõik toimiks ootuspäraselt: aken ilmub ekraani keskele ja näeb välja ootuspärane.
Sellega on meie esimene õppetund graafiliste liideste kohta lõpetatud. Selles näitasime "fassaadi", kuid jätsime täielikult välja paljud küsimused, mis on äärmiselt olulised ja ilma milleta Java programmeerimine üldiselt ja graafilised liidesed eriti võimatud. Nende probleemidega hakkame tegelema järgmises õppetunnis, kuid praegu mängige sellega ringi lähtekood, mis on.
Harjutusena arvuta välja näiteks meie akna väljundi koordinaadid ekraani paremas alanurgas ja kontrolli tulemust.
Teist harjutust on lihtsam sooritada, kuid selleks on vaja kasutada dokumentatsiooni (peate tõesti millalgi alustama): tehke see nii, et akna suurust pole võimalik muuta, s.t. piirkonda süsteeminupud nägi välja nagu pildil
(vihje: otsige javaxi ja JFrame'i märksõnu). Seega, kääri käised üles ja edu!
Kommenteeri
Võib juhtuda, et loodud aken jääb täielikult või osaliselt nähtamatuks (tõsiasi, et arvutasite valesti selle ekraanil kuvamise koordinaadid). Ka akna juhtnupud võivad muutuda kättesaamatuks. Kuidas saate rakendust katkestada ilma tegumihalduris ülesannet kustutamata või arvutit taaskäivitamata?
Kuna käivitame programmid täitmiseks FAR-ist, siis Java-programmi täitmise katkestamine saavutatakse klahvikombinatsiooni Control-C vajutamisega (siin on “C” ladina täht, ärge ajage seda segi sarnase kirillitsa tähega).
JFace on täiendav abstraktsioonikiht graafika raamatukogu SWT, mis pakub võimalusi MVC (Model View Controller) mudelil põhineva graafilise rakendusliidese arendamiseks. JFace'i põhikomponendid on järgmised:
- Vaatajad - klassid andmete kuvamiseks, filtreerimiseks, sortimiseks jne esitamiseks vajalike ülesannete kapseldamiseks.
- Tegevused ja panused – tutvustavad semantikat kasutaja toimingute kirjeldamiseks ja selle kohta, kuidas need peaksid kasutajale kättesaadavad olema.
- Pildi- ja fondiregistrid – pakkuge klasse ressursside, näiteks piltide ja fondide haldamiseks.
- Dialoogid ja viisardid – raamistik kasutajaga keeruka dialoogisuhtluse loomiseks.
- Väljaabi – pakub valikuid väljade abistavate funktsioonide rakendamiseks, näiteks väljade oleku või sisuvihjete kuvamiseks.
Esimeses osas vaadeldakse lihtsa akna loomist JFace'i abil, lisades sellele menüü, olekuriba ja tööriistariba.
Projekti seadistamine
Selleks, et areneda graafilised rakendused kasutades Eclipse'is JFace'i, peate lisama SWT- ja JFace'i jar-failid.
- Kui Eclipse'i on installitud PDE, saab seda teha, määrates projekti sätetes SWT teegi kasutamise ja märkides ruudu JFace'i toe jaoks.
- Kui PDE-d pole installitud, peate jar-failid projektiga käsitsi ühendama. Need leiate Eclipse'i pistikprogrammide kataloogist, nende nimed on org.eclipse.swt_*.jar ja org.eclipse.jface_*.jar
Akna loomine
JFace'i rakenduse aken pärineb klassist ApplicationWindow, mis pakub võimalusi menüüde, juhtpaneelide ja olekuribade loomiseks.
Lihtsaim viis akna loomiseks on toodud järgmises näites:
import org.eclipse.jface.window.ApplicationWindow; import org.eclipse.swt.widgets.Display; public class MainWindow laiendab ApplicationWindow ( public static void main(String args) ( MainWindow window = new MainWindow(); // Looge meie aken.setBlockOnOpen(true); // Seadke lipp - oodake akna sulgemist window.open (); / / Avage aken Display.getCurrent().dispose(); // Release ressursi
Akna sisu loomine
Mõne akna sisu loomiseks peate alistama klassis ApplicationWindow meetodi Control createContents (Composite parent). Meetod peab tagastama komponendi, millest saab akna sisu.
Samal meetodil saate määrata akna pealkirja, kutsudes välja shellis meetodi setText(String text), millele pääseb ligi käsu getShell() abil.
Selles näites on selline komponent lihtsalt valge silt tõelised rakendused selline komponent on mingi komposiit.
Tegelikult näide:
kaitstud Juhtseade createContents(Composite parent) ( getShell().setText("Minu aken"); // Akna pealkirja määramine Label lbl = new Silt(parent, SWT.NONE); // Loo uus element, meie puhul - lihtsalt silt lbl.setText("Akna sisu"); // Määrab selle teksti lbl.setBackground(new Color(Display.getCurrent(), 255, 255, 255)); // Installi valge värv tausta tagastamine lbl; )
Olekurea lisamine
Olekuriba lisamine rakenduse aknasse ei ole lihtne, kuid väga lihtne. Selleks peate lihtsalt kutsuma kaitstud meetodi addStatusBar(). Tõenäoliselt on sellise kõne jaoks sobivaim koht aknakonstruktor või mõni selle lähtestamise meetod.
Olekuribal teksti kuvamiseks tuleb välja kutsuda meetod setStatus(String status), mille argumendiks on just see string, mida tuleb kuvada.
Menüü loomine
JFace'is menüüriba loomiseks peate kutsuma meetodit addMenuBar(), nagu ka olekuriba loomisel.
Kuid siis peate paneelile menüüelemendid lisama. Seda tehakse järgmiselt.
- Menüüosa kirjeldab MenuManager klass. Konstruktoris saab sellele edastada stringi - jaotise nime, kus märk “&” tähendab, et sellele järgnev märk on võtmeks navigeerimisel kasutades Alt-klahvid. Menüüjaotis lisatakse paneelile konstruktsiooni getMenuBar().add(menu) abil.
- Menüüelementi kirjeldab klass Action. Klass ise on abstraktne, menüüelement peab pärima sellest ja alistama meetodi void run(), mis sisaldab koodi, mis käivitatakse, kui kasutaja valib menüüelemendi. Tegelikult ei pea seda meetodit alistama, aga milleks siis seda menüüelementi vaja on =) Elemendi nime saab määrata, edastades selle konstruktorile või kutsudes välja meetodi void setText(String text). Pärast loomist lisatakse menüüelement jaotisesse, kutsudes menüüjaotise objektil välja lisamismeetodi. Näiteks: menu.add(menuItem)
- Alammenüüd luuakse väga lihtsalt: ühte menüüsse tuleb lisada veel üks jaotis, kasutades lisamismeetodit. See on kõik.
Järgmises näites loome menüü Fail jaotise ja sellesse ühe Tere elemendi, mille valimisel ilmub akna olekureale tekst. Vormindasin menüü loomise koodi üheks meetodiks, mida kutsutakse aknakonstruktorist:
private void createMenu() ( addMenuBar(); // Menüüriba lisamine MenuManager fileMenu = new MenuManager("&File"); // Loo uus menüü getMenuBarManager().add(fileMenu); // Menüü lisamine paneelile fileMenu.add( new Separator() // Eraldi lisamine menüüsse fileMenu.add(new Action("&Tere") ( // Loo uus toiming, määra selle tekst @Override public void run() ( // Kood käivitatakse toimingu aktiveerimisel setStatus( "Tere maailm!!" // Kuvame lihtsalt uue väärtuse olekureal ) ) // Ja lisame toimingu menüüelemendina)
Tööriistariba loomine
Aknas tööriistariba loomiseks tuleb aknakonstruktoris välja kutsuda meetod addToolBar(int style), millele annad edasi paneelikomponendi stiili.
Loodud ribale juurdepääsu saamiseks kasutatakse meetodit getToolBarManager(). Toimingu lisamiseks paneelile kasutage selle paneeli lisamismeetodit, kuhu toiming saadetakse.
Lihtsamal juhul näeb paneeli loomine ja sellele nupu lisamine välja järgmine:
private void createToolBar() ( addToolBar(SWT.NONE); getToolBarManager().add(new Action("&Tere") ( // Loo uus toiming, määra selle tekst @Override public void run() ( // Kood käivitati aktiveerimistoimingud setStatus("Tere maailm!!" // Kuvame lihtsalt uue väärtuse olekureal ) ));
Mitme ujuva tööriistariba loomine
Ühe tööriistariba asemel saate luua teisaldatavate paneelide komplekti (CoolBar). Selleks vajate:
- AddToolBar meetodi asemel kutsuge meetod addCoolBar
- Paneelide komplekti pääsemiseks kasutage meetodit getCoolBarManager().
- Looge tööriistariba, millele saate toiminguid lisada. Selleks peate looma ToolBarManager klassi uue eksemplari, mis esindab paneeli ja kutsub esile CoolBarManageri lisamismeetodi, edastades paneeli sinna.
- Saate loodud paneelile toiminguid lisada
Näidiskood, mis loob kaks ujuvat paneeli:
private void createCoolbar() ( addCoolBar(SWT.NONE); ToolBarManager tm = new ToolBarManager(); getCoolBarManager().add(tm); tm.add(helloAction); ToolBarManager tm2 = new ToolBarManager(); getCoolBarManager().add (tm2); tm2.add(tereAction);
Tähtis! Rakenduse aknas võib olla kas üks juhtpaneel või liigutatavate paneelide komplekt, mille tulemuseks on viga!
Võimalikud probleemid
Siin on mõned probleemid, millega võite kokku puutuda.
- Menüüüksuste lisamisel pärast rakenduse käivitamist neid ei kuvata— selleks, et menüümuudatused kajastuksid aknal pärast akna loomist, tuleb meetod välja kutsuda getMenuBarManager().update(true)— määrake menüüriba värskendamiseks.
Lingid
Lisateavet JFace'i kohta leiate järgmistelt linkidelt:
- Venekeelne tutvustav artikkel saidil ibm.com
- Ingliskeelsete artiklite sari saidil ibm.com
- Eclipse API kirjeldus – muu hulgas on seal SWT ja JFace’iga seotud pakette
Java-l on 2 põhipaketti graafiliste kasutajaliideste loomiseks. Need on Abstract Windows Toolkit (AWT) ja Swing. AWT kasutab operatsioonisüsteemi vidinaid, seega on see teek veidi kiirem. Aga minu meelest on Swing paremini disainitud.
Selles õpetuses vaatleme Swingi teegi põhielemente ja loome näitena lihtsa liidese (GUI).
Liidese komponentide rühmitamiseks kasutatakse konteinereid. Rakenduse põhikonteineri loomiseks kasutatakse kõige sagedamini JFrame konteinerit (on olemas ka JWindows ja JApplet). Lihtsaim viis on pärida JFrame'ilt ja saada seeläbi juurdepääs paljudele meetoditele, näiteks:
setBounds(x, y, w, h) - määrab akna ülemise vasaku tipu koordinaadid, samuti selle laiuse ja kõrguse.
setResizable(bool) – näitab, kas akna suurust saab muuta.
setTitle(str) – määrab akna pealkirja.
setVisible(bool) – kuvab tegelikult akna.
setDefaultCloseOperation(operation) – määrab toimingu, mis tehakse akna sulgemisel.
Põhilised juhtnupud:
- JLabel - element fikseeritud teksti kuvamiseks;
- JTextField – lihtne redigeerimiskast;
- JButton - tavaline nupp (nupp);
- JCheckBox - valikuelement (analoogne märkeruuduga);
- JRadioButton – raadionupp
Nagu näete, on kõik üsna lihtne ja loogiline.
Juhtelementide kuvamisel kasutatakse spetsiaalseid haldureid - LayoutManager. Kõigil LayoutManageritel on meetodid elementide lisamiseks ja eemaldamiseks.
FlowLayout – kasutatakse elementide järjestikuseks kuvamiseks. Kui element ei mahu konkreetsele reale, ilmub see järgmisele reale.
GridLayout – kuvab elemente tabeli kujul samade lahtrisuurustega.
BorderLayout – kasutatakse mitte rohkem kui 5 elemendi kuvamisel. Need elemendid asuvad piki raami servi ja keskel: põhja, lõuna, ida, lääs, keskus.
BoxLayout – kuvab elemente reas või veerus.
GridBagLayout – võimaldab määrata iga vidina asukoha ja suuruse. See on kõige keerulisem, kuid ka kõige tõhusam kuvatüüp.
Tähelepanu tasub pöörata ka sündmuste käsitlemisele. Selleks kasutatakse nn sündmuste kuulajaid.
Noh, piisavalt teooriat, liigume edasi GUI näite juurde:
Impordi java.awt.*; import java.awt.event.*; import javax.swing.*; avalik klass SimpleGUI laiendab JFrame'i ( privaatne JButton nupp = new JButton("Vajuta"); privaatne JTextField sisend = new JTextField("", 5); private JLabel label = new JLabel("Input:"); private JRadioButton radio1 = new JRadioButton ("Select this"); privaatne JRadioButton radio2 = new JRadioButton("Vali see"); (100,100,250,100 see.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); radio2.setSelected(true); ""; sõnum += "Nuppu vajutati\n"; sõnum += "Tekst on " + input.getText() + "\n"; teade += (radio1.isSelected()?"Raadio #1":"Raadio #2") + " on valitud\n"; message += "Märgekast on " + ((check.isSelected()) ?märgistatud":"märkimata"); JOptionPane.showMessageDialog(null, teade, "Väljund", JOptionPane.PLAIN_MESSAGE); ) ) public static void main(String args) ( SimpleGUI rakendus = uus SimpleGUI(); app.setVisible(true); ) )
Märkused:
getContentPane tagastab konteineri kõrgeim tase. ButtonGroupi kasutatakse omavahel ühendatud raadionuppude rühma loomiseks.
Sisemine klass ButtonActionListener rakendab ActionListeneri liidest. Selleks peate esitama meetodi actionPerformed rakenduse.
JOptionPane'i kasutatakse dialoogibokside kuvamiseks.
Ootan teie küsimusi ja kommentaare. Kui soovite Swingi kohta rohkem teada saada, andke mulle sellest teada ja ma kirjutan peagi uue artikli, mis sisaldab täpsemaid tehnikaid ja komponente.
