Grafikus könyvtárak java. A Java grafikus felületi keretrendszerek és az első egyszerű Swing GUI-alkalmazásom rövid áttekintése

Tehát a Game of Life logikája megvalósul. Szeretném élvezni az "Élet" formáinak sokféleségét szemlélni a monitorom képernyőjén. Mire lesz szükség ehhez?

Maga az ablak menükkel és gombokkal, valamint viselkedése a könyvtár segítségével jön létre Hinta.„Életünk” fejlődési folyamatának megrajzolása – a könyvtáron keresztül A.W.T.(pontosabban Java 2D). Ez a két fő csomag a GUI-k Java nyelven történő létrehozásához.

Az AWT munkája kezdetben az úgynevezett peer interfészekre épül. A lényeg az, hogy ha egy Java objektumot kell megjeleníteni a képernyőn, akkor az operációs rendszer egy párosított grafikus objektumot hoz létre hozzá, amely valójában megjelenik. Ez a két objektum kölcsönhatásba lép egymással a program futása közben. Ez a megvalósítás oda vezet, hogy minden platformnak ki kell adnia saját JDK-ját.

Később az AWT olyan komponenseket hozott létre, amelyek nem használnak peer interfészt – „könnyű” (könnyű) komponenseket. Ezeknek az összetevőknek a könyvtára a Swing nevet kapta. Vagyis a Swing valójában az AWT kiterjesztése.

Maga az AWT új rajz- és képmegjelenítő eszközökkel, ún Java 2D.

Rövid leírással felsorolom a Swing főbb elemeit.

A teljes Swing vizuális komponens könyvtár alapvető építőköve az JComponent. Ez az egyes komponensek szuperosztálya. Ez egy absztrakt osztály, így nem igazán lehet JComponentet létrehozni, de szó szerint több száz függvényt tartalmaz, amelyeket minden Swing komponens használhat az osztályhierarchia eredményeként.

jFrame(alkalmazásablak) - a fő tároló, amely lehetővé teszi, hogy további összetevőket adjon hozzá magának, hogy rendszerezze őket, és biztosítsa azokat a felhasználónak. A JFrame hídként működik az operációs rendszertől független Swing részek és a tényleges operációs rendszer között, amelyen futnak. A JFrame ablakként van regisztrálva az operációs rendszerben, és így számos ismerős ablaktulajdonságot kap operációs rendszer.

JMenu/JMenuItem/JMenuBar- Menürendszer fejlesztésére tervezték JFrame-ben. Minden menürendszer gerince a JMenuBar, minden JMenu és JMenuItem ezzel jön létre. A JMenu a JMenuItem alosztálya. Megjelenésük azonban különbözik: a JMenu más JMenuItem és JMenu elemeket tartalmaz; A JMenuItem kiválaszt egy műveletet.

JLabel(címke) - egyéb elemek leírására szolgál (szöveg vagy grafika).

jButton(gomb) - a fő aktív összetevő, amely lehetővé teszi bizonyos műveletek végrehajtását, amikor megnyomják. A komponens megjelenítését vezérlő szabványos módszereken túlmenően az állapot kezelésére szolgáló módszerek csoportját tartalmazza (aktív / inaktív, kiválasztott / nincs kiválasztva, egér fel / nincs egér, lenyomva / felengedve).

JTextField(szövegmező) - lehetővé teszi a felhasználó számára a programban feldolgozható szöveges adatok megadását.

JTextArea kiterjeszti a JTextField-et, hogy több sor is beírható legyen.

JPasswordField(jelszómező) - a JTextField típusa, amely lehetővé teszi a beírt karakterek elrejtését.

JComboBox(kombinált lista) – Lehetővé teszi a felhasználó számára, hogy elemet válasszon egy meglévő listából (vagy új elemet adjon hozzá a listához).

JCheckBox(jelölőnégyzet) és JRadioButton(rádiógomb) – Lehetőségeket biztosít a felhasználó számára, amelyek közül választhat. A JRadioButtonokat általában úgy csoportosítják, hogy a felhasználónak egy kényszerített választ kapjon (a válaszok kölcsönösen kizárják egymást – kérdésenként csak egy válasz lehet). Miután kiválasztott egy JRadioButtont, nem törölheti a bejelölést, amíg nem választ másik lehetőséget a csoportból. A JCheckBox másként működik. Lehetővé teszi, hogy bármikor kipipáljon/töröljön egy opciót, és kérdésenként több választ is kiválaszthat. Az osztály, amely lehetővé teszi a JCheckBox vagy JRadioButton komponensek csoportosítását, az osztály Gombcsoport.

JSlider— egy elem egy számérték kiválasztására egy grafikusan ábrázolt tartományból.

JSpinner-értékcsoportból való választásra szolgál. Ebben hasonló a JComboBoxhoz, bár használatuk nem lehet felcserélhető. A JSpinnert csak logikailag szekvenciális választásokhoz használja - a számok és a dátumok tökéletesek erre. A JComboBox viszont több egy jó választás látszólag véletlenszerű lehetőségeket ábrázolni, amelyeknek nincs kapcsolatuk egymással.

JToolBar konténerként működik más összetevők számára (JButtonok, JComboBoxok stb.), amelyek együtt alkotják a legtöbb alkalmazásban megtalálható eszköztárat. Az eszköztárak lehetővé teszik a program számára, hogy a gyakran használt parancsokat kényelmes helyre helyezze és csoportosítsa. Az eszköztár gombjai általában a menü parancsainak felelnek meg.

JToolTip- Ezek kis "buborékok", amelyek akkor jelennek meg, amikor az egérmutatót valami fölé viszi és tartja. Nagyon hasznosak lehetnek alkalmazásokban, eszköztippeket adnak az elemekhez, részleteznek információkat, vagy akár egy elem teljes szövegét is megjelenítik tömör felhasználói felületen. A Swingben úgy aktiválhatók, hogy az egérmutatót egy adott komponens felett egy bizonyos ideig hagyják; általában körülbelül egy másodperccel az egér leállása után jelennek meg, és mindaddig láthatóak maradnak, amíg a kurzor az összetevő felett marad.

JOptionPane- egy osztály a felhasználói felület fejlesztői számára egyszerű üzenetek (hiba vagy egyéb információk) kibocsátására és adatok (például név vagy szám) gyors fogadására.

jscrollpane- Swing összetevő az összes görgetési művelet kezelésére.

jlist hasznos összetevő, amely számos választási lehetőséget biztosít a felhasználónak. JComboBox kiterjesztésként is felfoghatja. A JList több választási lehetőséget kínál, és több választási lehetőség kiválasztását is lehetővé teszi. A JList és a JComboBox közötti választás gyakran a következők egyike: Ha több kijelölésre van szüksége, vagy 15-nél több választási lehetősége van (bár ez a szám nem általános szabály), mindig válassza a JList lehetőséget. Használja a JList-et a JScrollPane-nel együtt, mert több lehetőséget kínál, mint amennyi a látható területen elfér. A JList-nek van egy kiválasztott modellje is, amelyet beállíthat Különféle típusok választási lehetőségek. Ezek a típusok a következők: egy választás (csak egy opciót választhat), egy tartomány (bármennyi szomszédos opciót kiválaszthat) és több tartomány (bármilyen kombinációban tetszőleges számú opciót választhat).

A Java grafikus felülete nagyon bonyolult fejlődési és formálódási pályán ment keresztül. Hosszú ideig lassú munkával, rendszererőforrás-mohósággal és korlátozott funkcionalitással vádolták.

Java AWT

A Sun első kísérlete Java grafikus felhasználói felületre a könyvtár volt A.W.T.(Abstract Window Toolkit) - eszközkészlet különféle ablakkörnyezetekkel való munkához. A Sun készített egy Java réteget, amely metódusokat hív meg a C nyelven írt könyvtárakból. Az AWT könyvtári metódusok hozzák létre és használják az operációs környezet grafikus összetevőit. Ez egyrészt jó, mert a Java program hasonló az ugyanazon az operációs rendszeren belüli többi programhoz. De ha más platformon futtatja, eltérések lehetnek az összetevők és a betűtípusok méretében, amelyek elrontják kinézet programokat.

Több platform biztosítása érdekében A.W.T. A komponenshívási interfészek egységesítésre kerültek, ami némileg csökkent funkcionalitást eredményezett. Az alkatrészkészlet pedig elég kicsinek bizonyult. Például az AWT-ben nincsenek táblázatok, és az ikonok nem támogatottak a gombokban. Azonban a csomag java.awt a Java része a legelső kiadástól kezdve, és grafikus felhasználói felületek létrehozására használható.

Tehát az alkatrészek A.W.T. ne végezzen semmilyen "munkát". Ez csak egy "Java burkoló" az operációs rendszer vezérlőihez, amelyeken futnak. Az ezekhez az összetevőkhöz intézett összes kérés az operációs rendszerhez kerül átirányításra, amely elvégzi az összes munkát.

Felhasznált erőforrások A.W.T. megpróbál automatikusan elengedni. Ez kissé bonyolítja az architektúrát és befolyásolja a teljesítményt. Az AWT használatával komoly dolgokat írni kissé nehéz lesz. Most már csak kisalkalmazásokhoz használják.

Alapvető SWING fogalmak

Után A.W.T. A Sun kifejlesztett egy grafikus komponens könyvtárat Hinta, teljes egészében Java nyelven íródott. A rendereléshez 2D-t használnak, ami egyszerre több előnnyel is jár. A szabványos alkatrészek készlete változatosságban és funkcionalitásban messze meghaladja az AWT-t. A Swing egyszerűvé teszi új komponensek létrehozását a meglévőkből való örökléssel, és számos stílust és skint támogat.

Az új felhasználói felület könyvtárának alkotói Hinta nem "feltalálták újra a kereket", és az AWT-t választották könyvtáruk alapjául. Természetesen nem konkrét nehézsúlyú AWT komponensek használatáról beszéltünk (amelyeket a Button, Label és hasonló osztályok képviselnek). Csak a könnyű alkatrészek biztosították a szükséges fokú rugalmasságot és irányíthatóságot. Az öröklődési diagram az AWT és a Swing közötti kapcsolatot mutatja.

A legfontosabb különbség Hinta Az AWT-től az, hogy a Swing összetevői egyáltalán nem csatlakoznak az operációs rendszerhez, ezért sokkal stabilabbak és gyorsabbak. Az ilyen összetevőket a Javaban könnyűsúlyúnak nevezik, és működésük alapelveinek megértése sokat segít a Swing működésének magyarázatában.

Swing felső szintű konténerek

Az alkotáshoz GUI az alkalmazásoknak a Swing könyvtár speciális, konténereknek nevezett összetevőit kell használniuk felső szint(legfelső szintű konténerek). Ezek olyan operációs rendszer ablakok, amelyek felhasználói felület összetevőit tárolják. A legfelső szintű tárolók közé tartozik a JFrame és a JWindow ablak, a JDialog párbeszédpanel és a JApplet kisalkalmazás (amely nem egy ablak, hanem egy interfész megjelenítésére is szolgál a kisalkalmazást futtató böngészőben). A felső szintű Swing konténerek nehézsúlyú alkatrészek, és kivételt képeznek az általános szabály alól. Az összes többi Swing alkatrész könnyű.

Egyszerű Hinta ablak interfész példa jFrame.

Java.awt.Dimension importálása; import javax.swing.JFrame; import javax.swing.JLabel; public class JFrameTest ( public static void createGUI() ( JFrame frame = new JFrame("Teszt keret"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JLabel label = new JLabel("Tesztcímke"); frame.getContentPane(). add(címke); 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() paraméterek nélkül üres ablakot hoz létre. Konstruktőr JFrame (karakterlánc címe)üres ablakot hoz létre a cím címével. Készíteni a legegyszerűbb programüres ablak esetén a következő módszereket kell alkalmazni:

  • setSize(int szélesség, int magasság) - az ablak méretének meghatározása;
  • setDefaultCloseOperation(int művelet) - a program leállítására vonatkozó művelet meghatározása;
  • setVisible(logikai látható) - az ablak láthatóvá tétele.

Ha nem határozza meg az ablak méretét, akkor annak nulla lesz a magassága, függetlenül attól, hogy mi van benne. Az ablak méretei nem csak a "munka" területet tartalmazzák, hanem a szegélyeket és a címsort is.

A setDefaultCloseOperation metódus határozza meg a „programból való kilépéskor” végrehajtandó műveletet. Ehhez adja meg a JFrame osztályban leírt EXIT_ON_CLOSE állandót műveleti paraméterként.

Alapértelmezés szerint az ablak láthatatlan. Az ablak képernyőn való megjelenítéséhez a setVisible metódust a true paraméterrel hívjuk meg. Ha false paraméterrel hívja meg, az ablak láthatatlanná válik.

GUI java swing ablak létrehozási példa jFrame a következő ábrán látható.

A könyvtár csatlakoztatásához Hinta az alkalmazásnak importálnia kell a könyvtárat javax.swing.

Minden alkalommal, amikor létrehoz egy legfelső szintű tárolót, legyen az egy normál ablak, párbeszédpanel vagy kisalkalmazás, a tároló konstruktora létrehozza JRootPane gyökérpanel. A legfelső szintű Swing tárolók biztosítják, hogy más összetevők ne tudjanak „mászni” a JRootPane-n kívül.

Root Pale JRootPane"mélység" tulajdonságot ad a konténerekhez, lehetővé téve nemcsak az összetevők egymás fölé helyezését, hanem szükség esetén cseréjét, az összetevők mélységének növelését vagy csökkentését is. Ez a funkció akkor szükséges, ha több dokumentumot tartalmazó alkalmazást hoz létre. Hinta, amelynek ablakai egymásra rakott könnyű komponenseket, valamint legördülő (kontextus) menüket és eszköztippeket jelenítenek meg.

A következő ábra jól mutatja a gyökérpanel felépítését JRootPane.

Gyökérpanel JRootPane egy olyan tároló, amely az alap Swing JComponent osztályból örökli. Ebben a konténerben a belső RootPaneLayout osztályban megvalósított speciális elrendezéskezelő felelős a komponensek elrendezéséért. Ez az elrendezéskezelő felelős azért, hogy a gyökérpanel minden alkotóeleme úgy legyen elhelyezve, ahogyan kell: a rétegelt panel az ablak teljes területét elfoglalja; ennek FRAME_CONTENT_LAYER-je a menüsort és a tartalompanelt tartalmazza, felette pedig egy átlátszó panel.

A gyökérpanel összes összetevője JRootPane beszerezhető vagy megváltoztatható. Ehhez rendelkezik egy get/set metódussal. Programozottan JRootPane a getRootPane() metódussal szerezhető be.

A legfelső szintű tárolókon kívül a gyökérpanel a több dokumentumot tartalmazó alkalmazásokban létrehozott belső JInternalFrame ablakokban használatos, és az „asztali” JDesktopPane felületen található. Ez lehetővé teszi, hogy elfelejtse, hogy ezek az ablakok közönséges könnyű alkatrészek, és úgy dolgozhatnak velük, mintha valódi felső szintű konténerek lennének.

Réteges panel JLayeredPane

A gyökérpanel (konténer) alján található az úgynevezett réteges panel JLayeredPane A, amely az összes rendelkezésre álló helyet elfoglalja a tárolóban. Ezen a panelen található a gyökérpanel összes többi része, beleértve az összes felhasználói felület összetevőt.

JLayeredPane mélységi tulajdonság hozzáadására szolgál a tárolóhoz. Vagyis a többrétegű panel lehetővé teszi egy harmadik dimenzió megszervezését a tartályban, amely mentén az összetevő rétegei (rétegei) helyezkednek el. Egy normál tartályban az alkatrész helyét egy téglalap határozza meg, amely megmutatja, hogy az alkatrész a tartályból mekkora részt foglal el. Amikor egy komponenst ad hozzá egy többrétegű panelhez, nem csak az összetevő által elfoglalt téglalapot kell megadnia, hanem azt a réteget is, amelyben az elhelyezni fog. A réteges panelen egy fóliát egész szám definiál. Minél nagyobb a réteget meghatározó szám, annál magasabb a réteg.

A tartályba adott első komponens magasabb, mint a később hozzáadott komponensek mennyisége. Leggyakrabban a fejlesztő nem foglalkozik az összetevők helyzetével. Ha alkatrészeket ad hozzá, azok pozíciója automatikusan megváltozik. A réteges panel azonban lehetővé teszi az összetevők helyzetének dinamikus megváltoztatását, miután hozzáadta őket a tárolóhoz.

A réteges panelek képességeit egyes összetevők széles körben használják Hinta. Különösen fontosak a több dokumentumot tartalmazó alkalmazások, eszköztippek és menük esetében. Többdokumentum Hinta alkalmazások speciális tárolót használnak JDesktopPane("asztal") innen öröklődött JLayeredPane A, amely a belső Swing ablakokat tartja. A legtöbb fontos jellemzőit többdokumentumú alkalmazást - az "aktív" ablak mások feletti elhelyezkedését, az ablakok minimalizálását, elhúzását - a többrétegű panel mechanizmusai biztosítják. A réteges panel eszköztippekhez és menükhöz való használatának fő előnye a gyorsaság. Ahelyett, hogy minden elemleíráshoz vagy menühöz új nehéz ablakot hozna létre, amely azon összetevő felett található, amelyben az eszköztippet vagy menüt kérték, Hinta gyors könnyű alkatrészt hoz létre. Ezt az összetevőt a fenti réteges panel kellően magas rétegébe kell elhelyezni az összes többi komponens kötegében, és egy eszköztipp vagy menü megjelenítésére szolgál.

A többrétegű panel lehetővé teszi korlátlan számú réteg elrendezését. Szerkezet JLayeredPane több szabványos réteget tartalmaz, amelyeket minden Swing alkatrész használ, ami biztosítja, hogy a rétegelt panel összes mechanizmusa megfelelően működjön. A szabványos JLayeredPane rétegek a következő ábrán láthatók.

Az Alapértelmezett réteg a tárolóhoz hozzáadott összes normál összetevő tárolására szolgál. Ez a réteg a több dokumentumot tartalmazó alkalmazások belső ablakait tartalmazza.

A Paletta réteget úgy tervezték, hogy olyan eszközökkel rendelkező ablakokat fogadjon, amelyek általában átfedik a felület többi részét. A JDesktopPane panel lehetővé teszi ilyen ablakok létrehozását, amelyek erre a rétegre helyezik őket.

A Modal réteget könnyű modális párbeszédpanelek fogadására szánták. Az ilyen párbeszédpanelek azonban még nincsenek implementálva, így ez a réteg jelenleg nem használatos a Swingben.

A leggyakrabban használt réteg előugró menük és eszköztippek számára.

A legfelső réteg. Fogd és vidd műveletekre tervezték, aminek jól láthatónak kell lennie a program felületén.

Egy kis példa egy réteges panellel rendelkező JLayeredPane-re, amely bemutatja, hogyan adhat hozzá komponenseket a különböző rétegekhez, és hogyan rakódnak egymásra a rétegek:

Javax.swing.* importálása; import java.awt.*; // osztály kétféle ábra rajzolásához szöveges osztállyal ábra kiterjeszti JComponent ( private static final long serialVersionUID = 1L; private Color color; private int type; private String text; // paraméterek: szín és ábra típusa Figure(Color color, int type, String text) ( this.color = color; this.type = type; this.text = text; setOpaque(false); ) public void paintComponent(Graphics g) ( // rajzolja meg az ábrát g.setColor(color); kapcsoló (típus ) ( 0. eset: g.fillOval(0, 0, 90, 90); break; 1. eset: g.fillRect(0, 0, 130, 80); break; ) g.setColor(Color.yellow) pl. drawString(text, 10, 35); ) ) public class JLayeredPaneTest kiterjeszti a JFrame-et ( privát statikus végleges hosszú serialVersionUID = 1L; public JLayeredPaneTest() ( // ablak létrehozása super("Példa rétegteszt"); // kilépés ablakkor zárva van setDefaultCloseOperation( EXIT_ON_CLOSE); // réteges panel meghatározása JLayeredPane lp = getLayeredPane(); // három alakzat létrehozása Figure figure1 = new Figure(Color.red , 0, "Figure po kölyökkutya"); ábra ábra 2 = new ábra (Szín.kék, 0, "1. ábra"); ábra ábra 3 = new ábra(szín.cián, 1, "2. ábra"); // a figurák helyének meghatározása az ablakban figure1.setBounds(10, 40, 120, 120); ábra2.setBounds(60, 120, 160, 180); ábra3.setBounds(90, 55, 250, 180); // alakzatok hozzáadása különböző rétegekhez lp.add(figure1, JLayeredPane.POPUP_LAYER); lp.add(2. ábra, JLayeredPane.PALETTE_LAYER); lp.add(ábra3, JLayeredPane.PALETTE_LAYER); // az egyik figura pozíciójának megváltoztatása lp.setPosition(figure3, 0); // a méret meghatározása és az ablak megnyitása setSize(280, 250); setVissible(true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new JLayeredPaneTest(); ) )

A példa egy kis ablakot hoz létre jFrameés több ábra komponenst adunk a réteges panelhez. Ha réteges panelt szeretne kapni bármely felső szintű Swing tárolóban, hívja meg a metódust getLayeredPane().

A Figure helper osztály örökli a JComponent alaposztály tulajdonságait, és lehetővé teszi kétféle alakzat (kör és téglalap) rajzolását különböző színekkel. Az alakzatok rajzolásának paraméterei az osztálykonstruktorban vannak beállítva.

Interfész definiálásakor három különböző színű forma (két kör és egy téglalap) jön létre. A kör a POPUP_LAYER rétegbe, a téglalapok pedig a PALETTE_LAYER rétegbe kerülnek. A komponensek elhelyezésénél az abszolút képernyőkoordinátáikat adjuk meg, mert a szokásos helykezelők nem rétegpanelben működnek.

A végén az egyik téglalap helyzete megváltozik, hogy az legyen az első a rétegben, bár eredetileg a második lett hozzáadva. Az alkalmazás futtatásakor látni fogja, hogy a réteges panel működik, és szépen elrendezi az összetevőket rétegeik és pozícióik szerint.

A hagyományos alkalmazásokban a réteges panelt ritkán használják közvetlenül, és láthatatlanul látják el funkcióit. Néha azonban segít csodálatos effektusok és szokatlan felületek létrehozásában, például lehetővé teszi, hogy animációt vagy videót helyezzen el a szokásos összetevők tetején anélkül, hogy a fejlesztőtől emberfeletti erőfeszítéseket és trükköket igényelne.

ContentPane

A ContentPane a gyökérpanel következő része, és a program felhasználói felület összetevőinek tárolására szolgál. ContentPane a réteges panel területének nagy részét elfoglalja (kivéve a menüsor által elfoglalt területet). Annak elkerülése érdekében, hogy a tartalompanel lefedje az ablakhoz később hozzáadott összetevőket, a réteges panel egy speciális, nagyon alacsony, FRAME_CONTENT_LAYER nevű, -30000-es rétegre helyezi azt.

A tartalom panelt a segítségével érheti el getContentPane() JFrame osztály. Az add(Component Component) metódus használatával bármilyen vezérlőt hozzáadhat hozzá. Cserélje ki ContentPane bármely más JPanel típusú panelt használhatja a módszert setContentPane()

Példa gomb hozzáadására a tartalompanelhez:

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

Ennek eredményeként egy gombos ablakot kapunk. A gomb az ablak teljes elérhető területét elfoglalja. Ez a hatás nem minden programban hasznos, ezért különböző módokat kell használnia az elemek elrendezésére a panelen.

A tartalompanel teljesen kicserélhető. Tekintsük a következő Hinta tartalom panel példa ContentPane.

Javax.swing.* importálása; public class A ContentPaneReplace kiterjeszti a JFrame-et ( privát statikus végső hosszú sorosVersionUID = 1L; public ContentPaneReplace() ( super("Test ContentPane"); setDefaultCloseOperation(EXIT_ON_CLOSE); // Hozzon létre egy panelt két gombbal JPanel contents = new JPanel(); tartalom. add (new JButton("Family")); contents.add(new JButton("School")); // A tartalompanel cseréje setContentPane(contents); // Az ablak méretének meghatározása setSize(200, 100); // A setVisible (true) ablak megnyitása; ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new ContentPaneAdd(); ) )

A példa létrehoz egy kis ablakot és egy panelt két gombbal, ami aztán setContentPane() lecseréli az ablak tartalompanelét. Így egy egyszerűbb kiegészítés helyett helyettesítést alkalmaztak - az add () metódus meghívásával. Az ablak felülete a következő képernyőképen látható.

Tartalom panel ContentPaneönmagában semmi különös. Csak emlékeznie kell arra, hogy az összetevőket hozzáadják hozzá.

Átlátszó JOptionPane

Átlátszó panel JOptionPane gyökérpanelként a réteges panel minden eleme fölé helyezve. A JOptionPane elhelyezését a gyökérpanel kezeli, amely az átlátszó ablaktáblát a réteges ablaktábla fölé helyezi úgy, hogy az teljesen lefedje az ablak teljes területét, beleértve a menüsor által elfoglalt területet is.

JOptionPane ritkán használják alkalmazásokban, így alapértelmezés szerint a gyökérpanel láthatatlanná teszi, ami csökkenti a rajzrendszer terhelését. Ne feledje, hogy ha egy átlátszó panelt láthatóvá tesz, akkor meg kell győződnie arról, hogy az átlátszó (átlátszatlan tulajdonsága hamis), mert ellenkező esetben a gyökérpanel összes többi elemét lefedi, és a felület többi része láthatatlan.

Milyen esetekben használható átlátszó panel? JOptionPane? Használható olyan alkalmazási funkciók meghatározására, amelyek megvalósítása jelentős erőfeszítést igényelne a semmiből. Az átlátszó panel adaptálható a felhasználói felület automatikus tesztelésére. A benne szintetizált események lehetővé teszik a közbenső hibakeresési eredmények nyomon követését. Néha ez a megközelítés sokkal hatékonyabb, mint a kézi tesztelés.

Átlátszó panel JOptionPane felhasználható olyan díszes animációk készítésére, amelyek "lebegnek" az összes összetevő tetején, beleértve a menüsort is, vagy elkapják az eseményeket, ha néhányat kezelni kell, mielőtt elküldené a fő felhasználói felületre.

Példa egy átlátszó Swing JOptionPane használatára:

// Átlátszó JOptionPane importálása java.awt.Dimension; import java.awt.Font; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; import javax.swing.JDialog; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JOptionPane; import javax.swing.UIManager; public class A JOptionPaneTest kiterjeszti a JFrame-et (privát static final long serialVersionUID = 1L; public static final BETŰTÍPUS= new Font("Verdana", Font.PLAIN, 11); public static void createGUI() ( JFrame frame = new JFrame("JOptionPane tesztelése"); frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); frame.addWindowListener(new WindowListener() ( public void windowActivated(WindowEvent event)C () WindowEvent esemény) () public void windowDeaktivált(WindowEvent esemény) () public void windowDeiconified(WindowEvent esemény) () public void windowIconified(WindowEvent esemény) () public void windowMennyitva(WindowEvent esemény) () public void windowZárás(WindowEvent esemény) ( Objektum options = ( "Igen", "Nem!" ); int rc = JOptionPane.showOptionDialog(event.getWindow(), "Ablak bezárása?", "Megerősítés", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, options) ; if (rc == 0) ( event.getWindow().setVisible(false); System.exit(0); ) ) )); JLabel label = new JLabel("Átlátszó panel használata ablak bezárásakor"); keret. getContentPane().add(label);frame.setPreferredSize(new Dimension(350, 8 0)); 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(); ) )); ) )

Ha a setDefaultCloseOperation metódus egy állandót ad át JFrame.EXIT_ON_CLOSE, majd az ablak bezárásakor az alkalmazás leáll. A példában egy állandót adunk át ennek a módszernek JFrame.DO_NOTHING_ON_CLOSE hogy az ablak becsukásakor ne történjen semmi. A példában szereplő alkalmazásból való kilépés a metódusban szereplő JFrame figyelő WindowListenerből történik ablak bezárása. Az ablak bezárásakor a windowClosing metódus meghívásra kerül egy WindowEvent eseményparaméterrel, amely egy átlátszó Swing JOptionPane-ben megerősítő párbeszédablakot nyit meg.

A következő képernyőképen két alkalmazás ablak látható. Felső főablak. Az ablak bezárásával megnyílik az alsó szándék megerősítését kérő párbeszédpanel.

JMenuBar menüsor

Az egyik fontos jellemzőit A JRootPane gyökérpanel használata a Swingben egy menüsor elhelyezése az ablakban JMenuBar. Komoly alkalmazás nem építhető fel a program funkcióinak elérésére szolgáló menüsor nélkül. A Swing könyvtár biztosítja kiváló lehetőségeket kényelmes JMenuBar menük létrehozásához, amelyek egyben könnyű összetevők is.

Menüsor JMenuBar réteges panelbe helyezve egy speciális FRAME_CONTENT_LAYER rétegben, és kis helyet foglal el az ablak tetején. A menüsor hossza megegyezik az ablak méretével. A menüsor szélessége a benne lévő összetevőktől függ.

A gyökérpanel gondoskodik arról, hogy a tartalompanel és a menüsor JMenuBar nem fedte egymást. Ha a menüsorra nincs szükség, akkor a gyökérpanel minden helyet felhasznál a tartalompanel elhelyezésére.

Swing példák

Az oldal szövegében tárgyalt példák forráskódja letölthető.

Előrejelzés

Ellentétben az előző ülésekkel, ahol alapvetően a „csináld úgy, ahogy én” elve alapján jártunk el, és a fogalmakról és a technikai részletekről beszéltünk az úgynevezett „ujjakon”, az előadás stílusa ettől a leckétől kezdve némileg megváltozik, technikaibb legyen.

Ezt sajnos nem lehet elkerülni, mert. előbb-utóbb el kell jutnunk egy ponthoz, ami után az „ujjakon” megközelítés tarthatatlanná válik. Most jön el ez a pillanat. Szóval szedjük össze a bátorságunkat, tegyük fel az ingujjunkat és kezdjük el.

Az előző leckében () grafikus ablakot alakítottunk ki és jelenítettünk meg a monitor képernyőjén, és közben megoldottunk néhány problémát a megjelenésével és elhelyezkedésével kapcsolatban. Most megvitatjuk, mi maradt a színfalak mögött.

Valószínűleg észrevette, hogy a forráskód elején két következő sor található:

import java.awt.*;

import javax.swing.*;

Itt el kell időznünk egy kicsit. Emlékezzünk vissza, hogy korábban említettük, hogy a környezet Java programozás számos olyan könyvtárat tartalmaz, amelyeket a hálózatépítés, a grafika, az adatbázis-műveletek, az üzenetkezelés stb. támogatására terveztek. A könyvtárak azok, amelyek a Java minden erejét és sokoldalúságát biztosítják.

A Java nyelven a "könyvtár" kifejezés helyett a "csomag" fogalmát használják. A fenti sorok csak összekötik a szükséges csomagokat, hogy grafikus felületet alkossanak. Később látni fogod, hogy más csomagokat fogunk használni, de egyelőre ez a kettő elég nekünk.

A csomagok tartalmazzák a szükséges osztályokat és interfészeket (az interfészekről időben beszélünk), amelyek biztosítják a jövőbeni alkalmazás egyik vagy másik funkcióját. A csillag ("*") azt jelzi, hogy a programozó a csomag teljes tartalmát importálja anélkül, hogy pontos jelzés a benne található osztályokat vagy interfészeket. Úgy tűnhet, hogy nagy csomagok esetén a kapott objektumkód túl nagy lehet, de ne aggódj: a Java fordító elég "okos" ahhoz, hogy csak azt használja, amire a programodnak valóban szüksége van; mindazt, amire a programnak nincs szüksége, a fordító egyszerűen nem veszi fel az objektumkódot. Ha tetszik, használhat egy kicsit más formát is a csomagok beillesztésére, például

import java.awt.window;

import javax.swing.JFrame;

de ez feltételezi, hogy a programozó már jól ismeri ezeknek a csomagoknak a felépítését és képességeit. A csomagok összekapcsolásának korábban jelzett egyszerűbb formáját fogjuk használni.

Egy csomag importálása (csatlakoztatása) a fejlesztés alatt álló programhoz az import kulcsszóval történik, amely után név megy csomag. Minden csomagot külön kell importálni (azaz nem írhat import java.awt.*, javax.swing.*;). Természetesen a forráskód mennyisége némileg megnőtt, de nagyon kis mértékben. Minden osztályt és interfészt, amely a programját alkotja, szigorúan az import konstrukciók után kell elhelyezni, különben a fordító fordítási hibaüzenetet generál.

Az első csomag (a java.awt-tól kezdve) elsősorban a Java programok interakcióját biztosítja az operációs rendszer grafikus alrendszerével. Emlékezzünk vissza, hogy a Java egy többplatformos programozási nyelv, és egyetlen objektumkódot hoz létre, függetlenül attól, hogy melyik operációs rendszeren futtatjuk ezt a kódot. Ezért a Java „kénytelen” hozzáférni a felhasználó számítógépére telepített operációs rendszer által biztosított erőforrásokhoz. Az egyik ilyen erőforrás a grafika (a grafika mellett a Java az operációs rendszer "szolgáltatásait" hívja meg a hozzáféréshez fájlrendszerés egyéb források). Tehát a java.awt.* csomag lehetővé teszi, hogy a Java nyelven írt grafikus felületek az operációs rendszer grafikus képességeit használják, és megjelenjenek a Java-ban létrehozott grafikus objektumokon. Java programok, a monitor képernyőjén. Itt elidőzünk egy kicsit.

A Java minden grafikus összetevője két kategóriába sorolható: könnyű (könnyű) és nehézsúlyú (nehézsúly). A grafikus komponensek túlnyomó többsége (gombok, listák, fák, címkék, táblázatok stb.) könnyű. Ez azt jelenti, hogy az operációs rendszer egyáltalán nem tud róluk, és nem is "gyanítja" a létezésüket. A könnyű komponensek az ablakokhoz tartoznak (mint az előző leckében bemutatott), és ezekben az ablakokban jelennek meg.

Ha egy gombot szeretnénk megjeleníteni egy ablakban, akkor azt csak egy kóddal kell megadnunk, mint az alábbiak

JButton buttonPressMe = new JButton("Nyomd meg");

és helyezze el az ablakban a megadott helyre (a vonatkozó részleteket később ismertetjük). A gomb egy könnyű objektum, és az operációs rendszer nem ismeri a gombot (a gomb nem létezik az operációs rendszerhez). Csak az az ablak "tud" a gombról, amelyben található. Az ablak megrajzolja a gombot, elfogja a gombbal előforduló eseményeket, újrarajzolja a gombot, ha valami eltakarta, stb. De maga az ablak, mint olyan - az operációs rendszer tisztában van vele, és pontosan azért, mert az ablak nehéz alkatrész. Csak az ablak fér hozzá az operációs rendszer erőforrásaihoz (különösen a grafikus erőforrásokhoz).

Nézd meg a forráskódot. Amikor kiszámoltuk az ablak bal felső sarkának koordinátáit, mielőtt megjelenítettük a képernyőn, tudnunk kellett a képernyő felbontását

Dimension sSize = Toolkit.getDefaultToolkit().getScreenSize()

Mi adhat ilyen információkat? Operációs rendszer és csak az! Ezután a kódot használtuk

try(UIManager.setLookAndFeel

(UIManager.getSystemLookAndFeelClassName());

fogás (Exceptionlfe)()

hogy az ablak megjelenése megfeleljen az adott operációs rendszerben elfogadott szabványnak. Mi adhat ilyen információkat? Ismét - az operációs rendszer! Tehát a grafikus felületek létrehozásához nem nélkülözhetjük a java.awt.* csomagot.

Amikor egy ablak megjelenik a képernyőn, az operációs rendszer hozzárendeli az ablakhoz a szükséges erőforrásokat (elsősorban a memóriát), és az ablak láthatóvá válik. Ezután a könnyű alkatrészek lépnek életbe, és az egész további munka szinte kizárólag velük végezték.

A második importcsomag (a javax.swing-től kezdve) a könnyű grafikus felületek felépítéséért felel (vannak más csomagok is, de ez a legfontosabb és szinte mindig használt). Ezt a csomagot fokozatosan tanulmányozzuk és sajátítjuk el, mert. elég nagy és meglehetősen összetett. Ezt a következő leckében kezdjük el, de most nézzük meg a forráskód következő sorát:

nyilvános osztály MoneyForNothing kiterjeszti a JFrame(

Két elem új itt: az extends kulcsszó és a JFrame szó.

Kulcsszó kiterjeszt (fordítva "kiterjed", de jelentésében közel áll az "örököl" szóhoz vagy a "kölcsöntulajdonságok és viselkedés" kifejezéshez) az objektum-orientált programozás (vagy egyszerűbben az osztályalapú programozás) alapkoncepcióját fejezi ki. . Ezt a fogalmat "öröklődésnek" nevezik. Ezt jól kell kezelni.

Ne feledje, az egyik első leckében () megvitattuk az osztályok fogalmát, és példaként egy autómotort használtunk. A sokféle motorral és kialakításukkal (természetesen belső égésű motorokról beszélünk) szinte mindegyik motor hasonló egymáshoz: mindegyiknek van hengere, dugattyúja, főtengelye, szelepe stb.

Természetesen egy tartályhajó hatalmas dízelmotorja nem hasonlítható össze egy repülőgépmodell apró alkoholmotorjával, de ezek (ha mondhatom) - bár távoli, de rokonok. Közös ősük van - valamiféle absztrakt motor, és maguk a motorok a leszármazottai (még akkor is, ha nagyon-nagyon távoliak).

A programozásban egy ilyen őst szoktak "szülő"-nek vagy "szuperosztálynak" nevezni, pl. osztály, amelyből más osztályok származnak. A szuperosztály neve közvetlenül az extens után jön. Így közönséges nyelvre lefordítva a fenti kódrészlet így olvasható: "class... kiterjeszti a JFrame osztályt", "class... örökli a JFrame osztályt", vagy "class... kölcsönzi a JFrame osztály tulajdonságait és viselkedését". a JFrame osztály". A JFrame osztály határozza meg a "standard" grafikus ablakok alapvető tulajdonságait és viselkedését. Maga a JFrame osztály a javax.swing.* csomagban van, és ezt importáltuk a program elején.

A JFrame a grafikus ablakok szülője (Java terminológiában szuperosztálya) (vannak más ablakok is, mint például a párbeszédablakok, de ezekről majd időben beszélünk). Ha a Java dokumentációt lapozgatja, azt találja, hogy a JFrame osztálynak több konstruktora, mezője és körülbelül két tucat metódusa van, amelyek meghatározzák néhány "szabványos" ablak viselkedését. Így a MoneyForNothing nevű osztályunk a JFrame osztály örököse (általában nem örökösökről beszélnek, hanem leszármazottakról vagy gyerekosztályokról).

Kérjük, vegye figyelembe, hogy maga a JFrame osztály több osztály leszármazottja (amelyek többsége a már ismert java.awt.* csomaghoz tartozik):

Hogy ne térjünk vissza erre a kérdésre, felhívjuk a figyelmet arra, hogy a Java öröklődési hierarchia tetején a java.lang.* csomag osztályai találhatók. Ez az egyetlen csomag a JDK-ból, amelyet nem kell kifejezetten importálni – mindig automatikusan importálódik. Ebből a "létrából" ítélve a JFrame osztály a java.lang.Object ük-ük-ükunokája (a fenti képet tudományosan osztályhierarchiának nevezik).

A grafikus felhasználói felület (rövidítve GUI, a Graphical User Interface szóból) minden olyan összetevőjét, amely, mint felidézzük, könnyű elem, a fő ablakon belül kell elhelyezni - a JFrame utódja. Jelenleg nincsenek komponenseink, de hamarosan megjelennek – ígérjük.

És most lássuk az utolsót forráskód, ami így néz ki:

// Konstruktor

nyilvános MoneyForNothing()(

setTitle("Üdvözöljük a Pénzt semmiért");

setSize(new Dimension(600, 400));

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

setDefaultCloseOperation(EXIT_ON_CLOSE);

setVissible(true);

Először is beállítjuk az ablak címét (a setTitle(...) metódus). Ezután beállítjuk az ablak vízszintes és függőleges méreteit (setSize(...) módszer). A monitor képernyőfelbontásának meghatározása után kiszámoljuk az ablakunk bal felső sarkának koordinátáit és az ablak megjelenik (method setLocation (...)) a képernyő megadott helyén.

Ezt követően meghatározzuk, hogy mit tegyünk az ablak bezárásakor a rendszermenüben; ebben az esetben egyértelmű, hogy az alkalmazásnak le kell állítania a munkáját (EXIT_ON_CLOSE). E rövid és egyszerű vonal mögött valójában az eseménykezelés meglepően érdekes és érdekfeszítő világa húzódik meg. Mondjuk rögtön: a Java eseménykezelési mechanizmusának megértése kulcsfontosságú momentum a grafikus alkalmazások fejlesztésében, és a következő leckétől kezdve ezt fogjuk tenni.

Végül az utolsó sor (method setVisible(true)) láthatóvá teszi az ablakot.

Természetesen nem hagytunk ki néhány részletet, de nem az a célunk, hogy mindent és mindent alaposan elmondjunk - ehhez vannak dokumentációk, segédkönyvek és oktatóanyagok. Célunk, hogy olyan általános irányt, kiindulópontot adjunk, ahonnan kiindulva (ha kívánja és kellő kitartással) képes lesz programjait a megfelelő irányba fejleszteni és a szükséges funkcionalitással feltölteni.

Ezzel a leckénk véget is ért. A legfontosabb dolog, amit le kell venni belőle, az az öröklés (kölcsönfelvétel) fogalma. Ez valóban alapvető fogalom. Enélkül a Java-ban lehetetlen bármilyen összetett és hasznos program, ezért szánjon időt a továbblépésre, de még egyszer alaposan tekintse át és fontolja meg mindazt, amit eddig tanultunk.

Sok sikert és hamarosan találkozunk!

Ebben a rövid cikkben az alkotás folyamatát szeretném leírni kis program támogatja a GUI nyelvet Jáva. Feltételezhető, hogy az olvasó ismeri a nyelv alapjait. Jáva.

Tehát milyen eszközökre van szükségünk:

  • Java virtuális gép (OpenJDK vagy Oracle JDK)
  • Intellij IDEA (vagy más Java IDE)

Telepítés után szükséges szoftver, nyisd ki IntelliJ ÖTLETés hozzon létre egy új projektet: Fájl -> Új projekt…

Elneveztem a projektet guiBase. Ahogy a képernyőképen is látható, a mappa src nem tartalmaz semmit, ezért létrehozzuk benne a függvényt tartalmazó főosztályunkat fő-.

Public class Main ( public static void main(String args) ( System.out.println("Helló, Govzalla!"); ) )

Lásd fent a főosztály tartalmát. Most már létrehozhatunk egy projektet ( építeni projektet ) és futtasd ( Fuss ). Lent a terminálodban IDEüzenetet fog látni Szia Govzalla!. De ahogy maga is megértette - nem támogatja a grafikus felhasználói felületet.

Tovább ezt a szakaszt már van egy működő programunk, de GUI támogatás nélkül. És most ugyanabban a mappában src teremt GUI űrlap: Új -> GUI űrlap

Nyissa meg a létrehozott GUI űrlapot, kattintson a gombra jPanelés állítsa be az azonosítóját a mezőbe mező neve, Megkérdeztem panel.

Ezután húzza át a jobb oldalon lévő űrlapra JTextField, JPasswordFieldÉs jButton:

Marad a kód hozzáadása és az űrlapunk hozzákapcsolása. Amikor hozzáadtuk az űrlapot főablak, az osztály automatikusan létrejött főablak, ez az osztály a generált űrlap osztálya, azaz. ez az osztály az adott formájú összes eseményt kiszolgálja.

Bár ablakosztályunk tartalmazza szükséges elemeket, de ennek még most sincs köze a grafikus felülethez, úgyhogy bővítsük vele jFrameés örökli a grafikus felhasználói felület összes alapvető és szükséges funkcióját .

BAN BEN Ebben a pillanatban megvan a forma főablakés osztály főablak-vel meghosszabbítva jFrame. Most minden hozzáadott GUI elemet osztálytartalomként kell meghatároznunk főablak this.getContentPane().add(panel); Ezt követően a MainWindow.java fájl tartalma a következőképpen módosul:

Javax.swing.* importálása; public class MainWindow kiterjeszti a JFrame-et ( privát JTextField textField1; private JPasswordField passwordField1; private JButton button1; private JPanel panel; public MainWindow() ( this.getContentPane().add(panel); ) )

Ha megpróbálja futtatni a kódot, ismét ugyanazt a „Hello, Govzalla!” üzenetet fogja látni. A helyzet az, hogy létrehoztunk egy osztályt és a hozzá tartozó űrlapot, de nem hoztuk létre ennek az osztálynak a példányát.

Itt az ideje megváltoztatni a Main.java fájlt, és hozzáadni a GUI létrehozásához szükséges kódot:

Java.awt.* importálása; public class Main ( public static void main(String args) ( // Hozzon létre egy példányt a MainWindow osztályból MainWindow mainWindow = new MainWindow(); // Csomagolja be az összes elemet a mainWindow.pack(); // Az ablak átméretezése mainWindow.setSize( new Dimension(200, 200)); // A létrehozott ablak megjelenítése mainWindow. setVisible(true); ) )

A kód futtatása

A Gombra kattintva észreveszi, hogy a program semmilyen módon nem reagál. A helyzet az, hogy még nem adtuk hozzá a hallgatót ( Hallgató) rendezvényekre ( Események) a Gombnál.

eseményfigyelő ( eseményhallgató) jButton adapter megvalósításnak kell lennie ActionListener, ezért adja hozzá a következő kódot az osztály törzséhez főablak:

A MyButtonListener privát osztály az ActionListenert valósítja meg ( @Override public void actionPerformed(ActionEvent actionEvent) ( ) )

Módszer action Performed() kezeli az összes button1 gomb eseményt, de először meg kell adni a button1-nek, hogy melyik osztályt fogja kezelni, ezért adja hozzá a következő kódot a MainWindow osztálykonstruktorhoz: this.button1.addActionListener(new MyButtonListener()); Hogy a kezelőnk ne legyen értelmetlen, adjuk hozzá a következő kódot a metódushoz action Performed():

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

Most a program megfelelően reagál az eseményekre, természetesen nem minden eseményre. Például, ha a programot a keresztre kattintva próbálja letiltani, akkor az ablak eltűnik, de a program továbbra is működik, mert. főablak eseménykezelője nincs hozzáadva.

Küldje el a jó munkát a tudásbázis egyszerű. Használja az alábbi űrlapot

Diákok, végzős hallgatók, fiatal tudósok, akik a tudásbázist tanulmányaikban és munkájukban használják, nagyon hálásak lesznek Önnek.

közzétett http://www.allbest.ru/

BEVEZETÉS

Az elmúlt néhány évben a fejlesztők sok erőfeszítést tettek annak érdekében, hogy grafikákat és animációkat integráljanak kisalkalmazásaikba és Java alkalmazásaikba. A java.awt és javax.swing API-k használatával a fejlesztők sokkal összetettebb grafikus alkalmazásokat valósíthatnak meg, beleértve a játékokat, képernyővédőket, képernyővédőket és 3D grafikákat. felhasználói felület.

A munka célja A számítási és grafikai munka a java.awt és a javax.swing könyvtárak grafikus felületét használó alkalmazások építésére irányul.

Relevancia A mai napig a grafika nem kis jelentőséggel bír a programozási nyelvek számára. Lehetővé teszi bármilyen program megjelenítését, amely fényességet és kényelmet biztosít bizonyos programok használatához. Lehetővé teszi világos és érdekes weboldalak létrehozását, kényelmes adatbázisok fejlesztéséhez, mobil és számítógépes játékok írásához.

1. A PROBLÉMA MEGFOGALMAZÁSA

A grafikus felhasználói felület (GUI) a végfelhasználók fő módja a Java-alkalmazásokkal való interakciónak. Alkalmazott fejlesztésére szoftver a Java nyelvben, vagy inkább az alkalmazások grafikus felületén az AWT és a Swing csomagokat használják általánosan.

Az AWT (a java.awt csomag letöltésre került a hozzáféréshez) olyan osztályokat tartalmaz, amelyek lehetővé teszik grafikus műveletek végrehajtását és ablakvezérlők létrehozását, hasonlóan a VBA-ban és a Delphiben;

A Swing (a javax.swing csomag betöltődik a hozzáféréshez) új osztályokat tartalmaz, amelyek többnyire az AWT-hez hasonlóak. J hozzáadódik az osztálynevekhez (JButton, JLabel stb.).

Jelenleg a vizuális interfészek építésének fő osztályait a Swing csomag tartalmazza. Az AWT csomagból az osztályok az üzenetek feldolgozására szolgálnak. Protozoa grafikus alkalmazás lent.

import javax. hinta.*;

nyilvános végső osztály HelloWorld megvalósítja a Runnable(

public static void main(String args) (

// A Swingnek saját küldőszála van,

//ami a fővel párhuzamosan fut (amelyben a main() lefut)

//folyam. Ha a fő szál futása befejeződik (a fő metódus véget ér),

//a Swing interfész működéséért felelős szál folytathatja munkáját.

//És még ha a felhasználó bezárt minden ablakot, a program folytatja a munkáját

//(amíg ez a szál él). A Java 6 óta, amikor minden

//az összetevők megsemmisültek, a vezérlés áramlása automatikusan leáll.

//Futtassa a vezérlőszálon futó összes kódot, még az inicializálást is:

SwingUtilities.invokeLater(new HelloWorld());

public void run() (

// Hozzon létre egy ablakot "Hello, World!"

Frame f = new JFrame("Hello, World!");

// A korábbi gyakorlat egy hallgató létrehozása és regisztrálása volt

// azon a főablak-példányon, amely a windowClosing() parancsra válaszolt

// kényszerleállás Virtuális gép a System.exit() meghívásával

// Most van egy "helyesebb" módja annak, hogy beállítsuk a reakciót az ablak bezárására.

// Ez a módszer megsemmisíti az aktuális ablakot, de nem állítja le az alkalmazást. Tem

// maga az alkalmazás az összes ablak bezárásáig fut.

f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

// de beállíthatod így is:

// f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// Nem szerkeszthető komponens hozzáadása szöveggel az ablakpanelhez.

// f.getContentPane().add (new JLabel("Hello, World!")); - régi stílus

f.add(new JLabel("Hello World"));

// pack() "becsomagolja" az ablakot az optimális méretre

// minden benne található komponens.

// Ablak megjelenítése

f.setVisible(true);

A Swing mechanizmusokat biztosít a prezentáció következő aspektusainak szabályozására:

Billentyűzet (a Swing lehetőséget biztosít a felhasználói bevitel lehallgatására)

Színek (A Swing lehetőséget biztosít a képernyőn látható színek megváltoztatására)

Szövegmező bevitelhez (A Swing szöveges összetevőket biztosít az összes napi feladat elvégzéséhez).

JComponent

A teljes Swing vizuális komponens könyvtár alaposztálya a JComponent. Más vizuális komponensek szuperosztálya. Ez egy absztrakt osztály, így nem igazán lehet JComponentet létrehozni, de több száz függvényt tartalmaz, amelyeket minden Swing komponens használhat az osztályhierarchia eredményeként. A JComponent osztály biztosítja az összes komponens színezési infrastruktúráját, tudja, hogyan kell kezelni az összes billentyűleütést a billentyűzeten, ezért alosztályainak csak bizonyos billentyűkre kell figyelniük. A JComponent osztály tartalmaz egy add() metódust is, amely lehetővé teszi a JComponent osztály egyéb objektumainak hozzáadását, így bármely Swing komponenst hozzáadhat bármely másikhoz, hogy beágyazott komponenseket hozzon létre (például egy JButtont tartalmazó JPanel vagy még szebb kombinációk). , például egy JButtont tartalmazó JMenu).

JLabel

A Swing könyvtár legegyszerűbb és egyben fő vizuális komponense a JLabel, vagy "címke". Ennek az osztálynak a módszerei közé tartozik a szöveg, a kép, az igazítás és a címke által leírt egyéb összetevők beállítása:

get/setText() - a címkében lévő szöveg lekérése/beállítása;

get/setIcon() - az ikon lekérése/beállítása a címkében;

get/setHorizontalAlignment - a szöveg vízszintes helyzetének lekérése/beállítása;

get/setDisplayedMnemonic() - a címke emlékeztetőjének (aláhúzott karakterének) lekérése/beállítása;

get/setLabelFor() - az összetevő lekérése/beállítása, amelyhez ez a címke kapcsolódik; Amikor a felhasználó megnyomja az Alt + mnemonikus billentyűkombinációt, a fókusz a megadott összetevőre kerül.

jButton

A Swing fő aktív összetevője a Jgomb.

A JButton tulajdonságainak megváltoztatására használt módszerek hasonlóak a JLabel tulajdonságaihoz (megláthatja, hogy a legtöbb Swing összetevő esetében ugyanaz). Szabályozzák a szöveget, a képeket és a tájolást:

get/setText() - a gomb szövegének lekérése/beállítása;

get/setIcon() - a kép lekérése/beállítása a gombban;

get/setHorizontalAlignment() - a szöveg vízszintes helyzetének lekérése/beállítása;

get/setVerticalAlignment() - a szöveg függőleges helyzetének lekérése/beállítása;

get/setDisplayedMnenomic() - az emlékeztető (aláhúzott karakter) lekérése/beállítása, amely az Alt gombbal kombinálva a gombra kattintást okoz.

jFrame

A JFrame osztály egy olyan konténer, amely lehetővé teszi további összetevők hozzáadását a rendszerhez és a felhasználó számára történő bemutatásához.

A JFrame hídként működik az operációs rendszertől független Swing részek és a tényleges operációs rendszer között, amelyen futnak. A JFrame ablakként van regisztrálva, és így megkapja az operációs rendszer ablakának számos tulajdonságát: kicsinyítés/maximalizálás, átméretezés és mozgás. Bár a megvalósítás laboratóriumi munka elegendő a JFrame-re úgy gondolni, mint arra a palettára, amelyre az összetevőket helyezi. Íme néhány módszer, amellyel a JFrame tulajdonságait megváltoztathatja:

get/setTitle() - megkapja/beállítja a keret címét;

get/setState() - get/set frame state (minimalizálás, maximalizálás stb.);

is/setVisible() - a keret láthatóságának lekérése/beállítása, más szóval a képernyőn való megjelenítés;

get/setLocation() - lekérni/beállítani azt a helyet az ablakban, ahol a keretnek meg kell jelennie;

get/setSize() - get/set frame size;

add() - komponensek hozzáadása a kerethez.

Sémák, modellek és események

Amikor vizuális alkalmazásokat készít Java nyelven, nem lehet véletlenszerűen elhelyezni őket a képernyőn, és elvárni, hogy azonnal működjenek. Az összetevőket meghatározott helyekre kell elhelyezni, reagálni kell a velük való interakciókra, frissíteni kell őket az interakció alapján, és fel kell tölteni adatokkal. Mert eredményes munka látványelemekkel az alábbi három Swing építészeti komponenst kell beépíteni.

Sémák (elrendezés). A Swing számos sémát tartalmaz, amelyek olyan osztályok, amelyek szabályozzák, hogy az összetevők hol helyezkedjenek el az alkalmazásban, és mi történjen velük, amikor az alkalmazás ablakát átméretezzük, vagy amikor komponenseket eltávolítunk vagy hozzáadunk.

Események A programnak reagálnia kell a billentyűleütésekre, az egérkattintásra és minden egyébre, amit a felhasználó tehet.

Modellek (modell). A fejlettebb komponensek (listák, táblázatok, fák) és még néhány egyszerűbb, például JComboBox esetében is a modellek a legjobbak. hatékony módszer adatokkal dolgozni. Eltávolítják az adatfeldolgozási munka nagy részét magáról az összetevőről (gondoljunk csak az MVC-re), és burkolóanyagot biztosítanak a gyakori adatobjektum-osztályok (például a Vector és az ArrayList) köré.

A dinamikus jelenetek vizuális komponenseken való megjelenítésének szükségessége miatt különös figyelmet kell fordítani a Graphics 2D osztályra.

Számítási és grafikai munka egyéni feladata: Rajzoljon az alkalmazás ablakába egy, a szegmens mentén mozgó pont köré a keretsíkban forgó szakaszt.

GUI java komponens

2. PROBLÉMA MEGVALÓSÍTÁSA MAGAS SZINTŰ NYELVENJÁVA

import java.awt.*;

import java.awt.geom.*;

import java.awt.image.BufferedImage;

* Feladat 4. ábrázolni V ablak alkalmazások (kisalkalmazás) vonalszakasz, forgó V

* repülőgép keret körül pontokat mozgó Által szegmens.

public class LB4 kiterjeszti a java.appletet. Az Applet megvalósítja a Runnable(

privát statikus döntő hosszú serialVersionUID= 1 liter;

privát int w, h;

privát BufferedImage bi;

privát Graphics2D nagy;

privát logikai stop = false;

private Thread timer = null;

privát Szín fonColor = Szín. FEHÉR;

private Color segmentColor = Szín. VILÁGOS SZÜRKE;

privát Color pointColor = Szín. ZÖLD;

privát szegmens;

// a kezdeti elhelyezkedés rajz

privát kettős hosszSzegmens;

// irány Elfogultság tengelyek forgás

privát kettős mozgáspont = -1;

privát kettős műszak = 0;

privát dupla sebességpont = 1;

// sebesség változtatások rendelkezések V hely

privát int speedRepaint = 30;

// sarok tovább melyik folyik változtatások rendelkezések szegmens

privát int grad = 15;

/** Ez módszer akarat hívott után letöltések kisalkalmazás */

public void init()(

// Mi alkotunk tárgyakatÉs telepítés a kezdeti értékeket.

Dimension dim = getSize();

// Mi alkotunk szegmens, kérve hossz

hosszszegmens = (dupla) Math. min(w, h) / 3;

szegmens = new Segment(hosszúságszakasz,hosszszegmens /2,grad,

segmentColor, pointColor, fonColor);

bi = (BufferedImage) createImage(w, h);

big = bi.createGraphics();

big.setRenderingHint(RenderingHints. KEY_ANTIALIASING,

RenderingHints. VALUE_ANTIALIAS_ON);

// Mi alkotunk folyam, melyik akarat időszakosan hívás módszer frissítés.

időzítő = new Thread(this);

) fogás (e kivétel) (

Rendszer. ki.println(e);

) // vége benne

// Ez módszer végez átrajzolás ablak kisalkalmazás

public void frissítés (G grafika) (

// Kapunk mutató tovább egy tárgy Graphics2D

Graphics2D g2 = (Graphics2D) g;

// Rajzolunk befejezett kép tovább képernyő

g2.drawImage(bi, 0, 0, this);

) fogás (Kivétel hiba) (

Rendszer. ki.println(error.getMessage());

privát void grawSegment() (

* //Tisztítás rajz big.setBackground(Szín.KÉK); big.clearRect(0, 0,

// Rajzolunk vonalszakasz

shift += movePoint * speedPoint;

ha (shift< -lengthSegment / 2) {

movePoint *= -1;

shift = -lengthSegment / 2;

) else if (shift > longSegment / 2) (

movePoint *= -1;

eltolás = hosszSzegmens / 2;

segment.setPos(shift, speedPoint);

segment.rotate();

big.drawImage(segment.getSegment(), null, 0, 0);

// Ez módszer teljesített V különálló folyam(időzítő).

// Ő okoz átrajzolás ablak kisalkalmazás minden adj egy percet.

public void run() (

cérna. aktuális szál();

cérna. alvás(speedRepaint);

) fogás (Kivétel hiba) (

// Ez módszer teljesített Ha felhasználó bal oldalon

// Val vel kisalkalmazás. Ő megáll folyam(időzítő) és illetőleg,

// átrajzolás ablak kisalkalmazás.

nyilvános üresjárat()(

// Ez a metódus akkor fut le, amikor a felhasználó az oldalon landol

// kisalkalmazással. Elindít egy párhuzamos szálat (időzítőt).

public void start() (

if (időzítő == null) (

időzítő = new Thread(this);

// Ez a metódus akkor kerül végrehajtásra, ha az appletet tartalmazó oldal be van zárva.

public void semmisít() (

szuper.destroy();

cérna. aktuális szál();

// Várja meg, amíg a párhuzamos menet (időzítő) befejeződik.

cérna. hozam();

) // vége elpusztítani

) // RotatingSegment nyilvános osztály befejezése

// szegmens létrehozása

privát statikus kettős x = 0;

végső kettős RAD = 10;

privát dupla hosszúság;

privát BufferedImage szegmens;

privát ColorsegmentColor;

privát Color pointColor;

privát Szín háttérGroundColor;

privát Rectangle2D.Double r;

privát Ellipse2D.Double p;

privát kettős forgástengely;

privát Point2D.Kettős központ;

privát kettős műszak;

// szög, amellyel a szakasz helyzete megváltozik

privát integráció;

Szegmens(dupla hosszúság, dupla posPointRotating, int grad,

SzínszegmensSzín, SzínpontSzín, Színes háttérTájszín)

throwsException(

// paraméterek ellenőrzése

ha (hossz<= 0 || posPointRotating < 0 || length < posPointRotating)

dobj új kivételt(

"Hiba: érvénytelen paraméter az osztályszegmensben");

this.grad = grad;

this.segmentColor = szegmensSzín;

this.pointColor = pontszín;

this.backGroundColor = backGroundColor;

this.length = hossz;

// rajz létrehozása

szegmens = new BufferedImage((int) hossz * 3, (int) hossz * 3,

BufferedImage. TYPE_INT_ARGB);

center = new Pont2D.Double(hossz, 3 * hossz / 2);

// szegmens létrehozása

rotationAxis = center.x + posPointRotating - RAD / 2;

p = new Ellipse2D.Double(forgástengely, középpont.y, RAD, RAD);

// állítsa be a szegmens színét

g2.setColor(szegmensszín);

// szegmens rajzolása

// beállított szín

g2.setColor(pontSzín);

// pontot húzunk

// eltolja a forgáspontot

public void setPos(double shiftX, double shiftY) (

// szegmens létrehozása

this.shift = shiftX;

center.y = center.y + shiftY * Math. bűn(Matek. a radiánokhoz(grad * x));

r = new Rectangle2D.Double(center.x, center.y, long, RAD);

p = new Ellipse2D.Double(forgástengely + eltolás, középpont.y, RAD, RAD);

// elforgatja a szegmenst

public void rotate()(

AffineTransform at = AffineTransform. getRotateInstance(

Math. a radiánokhoz(grad * (++ x)), rotationAxis + RAD / 2 + shift,

// grafikus kontextus lekérése

Graphics2D g2 = segment.createGraphics();

// mindent lefest a megadott színnel

g2.setBackground(backGroundColor);

g2.clearRect(0, 0, (int) (3 * hossz), (int) (3 * hossz));

g2.setTransform(at);

g2.setColor(szegmensszín);

// szegmens rajzolása

// beállított szín

g2.setColor(pontSzín);

// pontot húzunk

// Képet ad vissza

public BufferedImage getSegment() (

3. PÉLDA A PROGRAM MŰKÖDÉSÉRE

A program végrehajtásának eredménye:

1. ábra A program végrehajtásának eredménye

2. ábra A program végrehajtásának eredménye

3. ábra A program végrehajtásának eredménye

KÖVETKEZTETÉS

Ezzel befejeztük a Java grafikáról szóló vitánkat. Ebben a cikkben egy rövid áttekintést adtunk a Java 2D grafikus programozási eszközeiről. Bemutattunk egy alkalmazást, amely bemutatja a geometriai formák, textúrák használatát.

Megbeszéltük a Java néhány grafikus funkcióját. A grafika alapjainak rövid bemutatásával kezdtük, mint például a koordinátarendszerek és a grafikai összefüggések. Ezután megbeszéltük a Java 2D létesítményeket. Röviden kitértünk a grafikai effektusok használatára is.

A Java grafikus programozásába való bevezetőnk második fele. A java.awt és javax.swing könyvtárak grafikus felületének felhasználásával egy egyszerű grafikus szerkesztőt hoztunk létre, amely egy kétdimenziós objektumot forgat a tengelye körül.

BIBLIOGRÁFIA

1. H. M. Deitel, P.J. Deitel, S.I. Suntry – Java programozási technológiák, 1. könyv (grafika, JAVABEANS, felhasználói felület)

2. Judy Bishop – Hatékony Java munkavégzés

3. James Gosling, Bill Joy, Guy Steele, Gilad Bracha – A Java nyelvi specifikáció, második kiadás.

4. Tim Lindholm, Frank Yellin – A Java virtuális gép specifikációja, második kiadás.

5. Gosling J., Arnold K. - Java programozási nyelv

6. Információ a www.ibm.com webhelyről

7. Információ a www.mexmat.sgu.ru webhelyről

8. Információ a www.uic.rsu.ru webhelyről

Az Allbest.ru oldalon található

...

Hasonló dokumentumok

    GUI szervezeti felépítés, eseményfigyelők deklarálása és létrehozása anonim osztályok segítségével. A tábla adatábrázolása az AbstractTableModel osztály. Táblázatcellák megjelenítése. A Java I/O adatfolyamainak két fő típusa.

    előadás, hozzáadva 2014.01.05

    Grafikus szerkesztő fejlesztése kétdimenziós és háromdimenziós grafika rajzolásához Java programozási nyelv és Java 2D és Java 3D alkalmazásprogramozási felületek segítségével. Grafikus szerkesztő 3D Paint létrehozása. A Graphics osztály főbb metódusai.

    szakdolgozat, hozzáadva 2009.11.19

    Net Beans alkalmazási csomag leírása 8.1. Az applet felhasználói felületének fejlesztése. Keretes ablakok készítése a java.swing könyvtár keretei alapján. Módosítsa a szöveges adatok színét. Kisalkalmazás infológiai modelljének tervezése és elkészítése.

    ellenőrzési munka, hozzáadva 2016.11.07

    Programozási nyelvek hálózati lehetőségei. A Java kisalkalmazások használatának előnyei. A java.awt könyvtárban található osztályok. Felhasználói felület létrehozása. Socket csatlakozás a szerverhez. Grafika Java nyelven. A színösszetevők értékei.

    szakdolgozat, hozzáadva 2014.11.10

    Java Foundation osztályok, alapfogalmak. Az eredeti Abstract Window Toolkit osztályhierarchia. A felhasználói felület képviselői. Eseménykezelés JavaBeansben. Vezérlők, JText többsoros mező. A TextEditor program listázása.

    szakdolgozat, hozzáadva 2013.06.26

    Java program végrehajtása. JDK programok és osztályok készlete. Objektumorientált programozás Java nyelven. A grafikus felület felépítésének elvei. A grafikus rendszer alkatrésze és konténerje. A kisalkalmazások olyan programok, amelyek böngésző környezetben futnak.

    szakdolgozat, hozzáadva 2011.02.08

    A függvénytáblázatos konzol alkalmazási diagramja. A különbség a konzolalkalmazás és az alkalmazás és a grafikus felhasználói felület között. Osztálydiagram a JFrame és a JPanel számára. Egyszerű keret létrehozása Java nyelven. Az interfész elemeinek elrendezése egy kereten belül. Eseményhurok.

    előadás, hozzáadva 2014.01.05

    A PHP programozási nyelv fogalma és általános jellemzői, működési elvei és szakaszai, szintaxisa és a kapcsolódó tömbök. Kivételkezelés Java nyelven. Adatbázisokkal végzett munka JDBC használatával. Grafikus felület fejlesztésének megtanulása.

    bemutató, hozzáadva 2014.06.13

    Logikai séma kidolgozása egy autógyártó vállalat adatbázisához. Infológiai rendszermodellezés. Grafikus felhasználói felület készítése az adatbázishoz Java programozási nyelv használatával. Szoftver tesztelés.

    szakdolgozat, hozzáadva 2013.12.16

    Konzolalkalmazások létrehozása grafikus felhasználói felület segítségével. A C++ Builder program komponens palettájának tartalma. Az objektum-orientált programozás lehetőségeinek felhasználása, a kódszerkesztő szolgáltatásai és a C ++-ban lévő űrlapok.



Betöltés...
Top