Programozás | Java, JSP » Oláh Lilla - Java programozás

http://www.doksihu JAVA programozás Készítette: Oláh Lilla Bevezetés A grafikus felhasználói felület (Graphical User Interface, GUI) programozására a Java kétféle osztálygyűjteményét (keretrendszert) ad, az AWT-t és a Swinget. Az AWT a régebbi rendszer, azt már nem fejlesztik tovább. A Java tervezői mindkettőben arra törekedtek, hogy a felhasználói interfész platform független legyen. A két osztálygyűjtemény jellemzői: • AWT (Abstract Window Toolkit, absztrakt ablakozó eszköztár): ez a korábban kifejlesztett osztálykönyvtár. Az AWT komponenseit úgy tervezték, hogy az operációs rendszer elemeihez hasonlóak legyenek. Használatuk kissé nehézkes, mivel az AWT osztályok közvetítő feladatot látnak el a felhasználó programja és az operációs rendszer között. • Swing: ez az újabb osztálykönyvtár, amely sokkal gazdagabb, mint az AWT, és az előbb említett korlátozás sem létezik. Természetesen a Swing osztály vezérlői

sokkal többet tudnak, felépítésük logikusabb. Összehasonlítva a két osztályt tulajdonságaik alapján: • az AWT osztályok használata kevésbé kényelmes, de a futási idejük kisebb, • a Swing összetevőket csak a legújabb böngészők támogatják, • az áttérés az AWT osztályokról a Swing osztályokra nem bonyolult. JFC (Java Foundation Classes) Ahogy a Swing az AWT komponenseit fejleszti tovább, úgy bővítik az AWT grafikus lehetőségeit a Java 2D osztályok. Az AWT, a Swing és a Java 2D osztályokat együtt Java Alaposztályoknak (Java Foundation Classes , JFC) szokták nevezni. A JFC osztályait különböző csomagok tárolják: dián Komponensek Egy Java alkalmazás grafikus felhasználói interfésze komponensekből áll. A komponensek téglalap alakú képernyőfelületek, amelyeknek meghatározott tulajdonságaik vannak, (elhelyezés, méret, szín, láthatóság, stb.), és előre megadott szabályok szerint reagálnak különböző eseményekre

(egér-, billentyűesemény stb.) Vannak olyan komponensek, amelyekre újabb komponensek tehetőek, ezeket konténer-komponenseknek nevezzük. http://www.doksihu AWT - és Swing – osztályhierarchia Nagyvonalakban láthatjuk, hogy milyen osztályokat használhatunk a felhasználói interfész elkészítésére. • java.awt: AWT - komponensek, rajzolás Láthatatlan objektumok osztályai • java.awtevent: az AWT – és Swing – komponenseken keletkező események kezelése • java.awtprint: nyomtatás • javax.swing: Swing – komponensek • javax.swingevent: a Swing – komponenseken keletkező további események kezelése • javax.swingborder: a komponenseknek szegélyt (keretet) adó osztályok • javax.swingfileChooser: állomány kiválasztása lemezről Vezérlőkomponensek • Component / JComponent: a képernyőn megjelenő AWT - / Swing – komponensek absztrakt őse. A Component osztályban deklaráltak többek között a következő adatok: - location (bal

felső sarok) - size (méret) - background (háttérszín) - foreground (előtérszín) - font (betű) - visible (láthatóság), stb. A JComponent – ben további adatok deklaráltak, például border (szegély). • JLabel (címke): információ megjelenítésére használatos komponens. Az ábrán két címke szerepel (egy a keretben, egy a dialógusablakban). • JButton (nyomógomb): a rajta való egérkattintás egy eseményt indíthat el. Az ábrán 3 nyomógomb van (egy a keretben, kettő a dialógusablakban). • JCheckBox (jelölőmező): ha a szövegre kattintunk, akkor az elem bejelölődik, s ha be volt jelölve, akkor a bejelölés megszűnik. A jelölőmezők négyzet alakúak • JRadioButton (rádiógomb): hasonló a jelölőmezőhöz, csak ez kör alakú. • JComboBox (kombinált lista): beviteli mező és lista kombinációja. A mező szélén egy lefelé mutató nyíl jelzi, hogy választani is lehet a felkínált szövegekből. • JTextComponent: a szöveges

komponensek közös őse. • JTextField (szövegmező): adatbeviteli mező; szöveget ehet vele átadni a programnak. • JTextArea (szövegterület): többsoros, szerkeszthető szövegterület. • JList (lista): a listából meg lehet tudni, hogy éppen mely elemei vannak kiválasztva. Nem szerkeszthető szövegsorok, az elemek kiválaszthatók (egyszerre egy vagy több). • JScrollBar (görgetősáv): a sáv két végén egy –egy nyíl, rajta pedig egy csúszka található. A csúszka pillanatnyi helyzete mutatja az értéktartomány aktuális értékét • JScrollPane (görgető panel): az erre helyezett komponenseknek görgetősávjuk lesz. • JMenuBar (menüsor): a menühierarchia tartóeleme. • JMenu (menü): a menühierarchia elemei. • JMenuItem: menütétel. • JRadioButtonMenuItem: rádió – menütétel. http://www.doksihu • JCheckBoxMenuItem: jelölő – menütétel. Ablakok, konténerek • Container: a konténerek őse. Egy konténerbe az add()

metódussal lehet komponenseket tenni, a remove() metódussal meg ki lehet venni őket. Egy konténernek van jellemző fontja, színei, stb. • JFrame: keret. Van címe ( title ) és menüje Az alkalmazás legfelső szintjén mindig keret áll. • JDialog: a dialógusablak hasonlít a kerethez, de van tulajdonosa. A dialógust a felhasználóval való párbeszédre találták ki. A dialógusablak általában nem méretezhető. • Window / JWindow (ablak): egyszerű, keret nélküli ablak ( egy téglalap a képernyőn). Az ablaknak nincs sem kerete, sem címe, sem menüje. A Window ablak osztály fontos metódusa a show()- előtérbe teszi az ablakot – és a pack() – munkára utasítja. • JPanel: komponensek összefogására használatos. • JColorChooser: szabványos színválasztó dialógusablak. • JOptionPane: szabványos dialógusablak – gyűjtemény üzenetek megjelenítésére, adatok bevitelére, stb. Nem látható komponensek • Color: minden komponenshez

tartozik egy háttérszín és egy előtérszín. Ez az osztály tárolja a szín kikeverését. • Font: minden komponenshez tartozik egy font (betű) objektum, ez határozza meg a komponensre írt szöveg típusát, stílusát és méretét. • Flowlayout, GridLayout, BorderLayout: elrendezés-menedzserek. Implementálják a LayoutManager interfészt. A LayoutManager interfész tartalmazza azokat az absztrakt deklarációkat, amelyeket egy elrendezés-menedzsernek implementálnia kell. A FlowLayout, a GridLayout és a BorderLayout osztály konkrét elrendezés-menedzser: sorfolytonos, rácsosan illetve határ mentén rendezik el a komponenseket. • Graphics: absztrakt osztály; ezen rajzolódik ki a komponens. • Image: absztrakt osztály. Leszármazottjai képet tároló platformfüggő objektumok • ImageIcon: rögzített méretű képet tároló osztály. Az Icon interfészt implementálja • Point, Dimension, Rectangle: a képernyőn nem láthatóak, a komponens

helyzetének és méretének megadásával használhatók. • Polygon: sokszög pontjait tárolja. • ButtonGroup (gombcsoport): nem komponens, a gombok összefogására szolgál; a rádiógombok közül mindig csak egy lehet benyomva. Swing mintaprogram http://www.doksihu Készítsük el az itt látható keretet! A keret bal felső sarka a képernyő (100,50) pozícióján legyen, mérete 300*100, címe: Frame-teszt. A kereten legyen, egy címke a Döntsd el: szöveggel, továbbá legyen két nyomógomb, OK és Nem OK felirattal! Három megoldást is lehetséges: 1.Megoldás – Keret összerakása kívülről 2.Megoldás – Keret összerakása belülről 3.Megoldás – A konténer komponenseit nem deklaráljuk, pakolunk 1.Megoldás – Keret összerakása kívülről import java.awt*; import javax.swing*; public class FrameTest1 { public static void main(String[] args) { //Komponensek deklarálása: JFrame fr; JLabel lbInfo; JButton btOk, btNemOk; //A csupasz keret

létrehozása: fr = new JFrame(); //Cím pozíció és méret megadása: fr.setTitle("Frame-teszt"); fr.setBounds(100,50,300,100); fr.setDefaultCloseOperation(JFrameEXIT ON CLOSE); //Tartalompanel kikérése: Container cp = fr.getContentPane(); http://www.doksihu //Tartalompanel elrendezés-menedzserének beállítása: cp.setLayout(new FlowLayout()); //Komponensek létrehozása: lbInfo = new JLabel("Döntsd el:"); btOk = new JButton("OK"); btNemOk = new JButton("Nem OK"); //Komponensek beillesztése a tartalompanelbe: cp.add(lbInfo); cp.add(btOk); cp.add(btNemOk); //A keret láthatóvá tétele: fr.setVisible(true); } } Először az osztálykönyvtár által kínált JFrame osztályból létrehozunk egy példányt, majd a keret tulajdonságait kívülről, üzenetekkel fogjuk beállítani, és az elemeket is kívülről fogjuk beledobálni. Ez egy „egyszer használatos” megoldás, nem követendő példa Nevezzük el a programban szereplő

objektumokat. A main metódust tartalmazó főosztály a FrameTest1, ő hozza létre az alkalmazás fő keretét: fr : JFrame. Ebbe a keretbe tesszük bele a tartalompanelen keresztül az lbInfo címkét, valamint a btOk és a bt nemOk gombot. A main metódus a következő üzeneteket küldi a keretobjektumnak: - JFrame(): létrehozza őt. - setTitle („Frame-teszt”): beállítja a keret címét. - setBounds (100,50,300,100): a keret bal felső sarkának koordinátája a képernyőn (100,50), a keret mérete pedig 300*100 pont lesz. - setDefaultCloseOperation (JFrame.EXIT ON CLOSE): ezzel a metódussal azt határozzuk meg, hogy mi történjen a keret becsukásakor. Az EXIT ON CLOSE azt jelenti, hogy a keret becsukásakor fejeződjön be a program futása. - cp = getContentPane(): elkéri a kerettől a tartalompanelt. Bár a tartalompanel JPanel osztályú,a metódus Container-ként adja át. - setVisible( true ): láthatóvá teszi a keretet. A keretnek van kész tartalompanelje, cp

arra mutat. A komponenseket a tartalompanelbe kell tenni. A tartalompanelnek küldött üzenetek: - setLayout ( new FlowLayout() ): sorfolytonos elrendezés-menedzsert rendel a tartalompanelhez. - add (lbInfo), add ( btOk ), add ( btNemOk ): ráteszi a tartalompanelre az előzőleg létrehozott lbInfo címkét, valamint a btOk és a btNemOk gombot. A panelen tehát három komponens lesz. http://www.doksihu 2.Megoldás – Keret összerakása belülről import javax.swing*; import java.awt*; class SpecFrame extends JFrame { //Komponensek deklarálása: JLabel lbInfo; JButton btOk, btNemOk; //Konstruktor: public SpecFrame() { //Cím, pozíció és méret megadása: setTitle(„Frame-teszt”); setBounds(100,50,300,100); setDefaultCloseOperation(EXIT ON CLOSE); //Tartalompanel kikérése: Container cp = getContentPane(); //Tartalompanel elrendezésmenedzserének beállítása: cp.setLayout(new FlowLayout()); //Komponensek létrehozása: lbInfo = new JLabel(”Döntsd el:”); btOk =

new JButton(”OK”); btNemOk = new JButton(”Nem OK”); //Komponensek beillesztése a tartalompanelbe: cp.add(lbInfo); cp.add(btOk); cp.add(btNemOk); //A keret láthatóvá tétele: setVisible(true); } } public class FrameTest2 { public static void main (String args[]) { http://www.doksihu //A komponensekkel tele keret létrehozása: new SpecFrame(); } } Ebben a megoldásban egy saját, SpecFrame keretosztályt definiálunk. A FrameTest2 osztály main metódusának mindössze annyi dolga lesz, hogy létrehozza a keretet. A keretet nem is kell deklarálnunk, hiszen azt a létrehozás után nem szólítjuk meg. Most az üzeneteket belső metódushívások váltják fel (az fr minősítés elmarad ). A main - ből most nem csupasz keretet, hanem egy komponensekkel teli keretet hozunk létre, az összerakást a SpecFrame konstruktora végzi el. 3.Megoldás – A konténer komponenseit nem deklaráljuk, pakolunk import javax.swing*; import java.awt*; class SpecFrame extends JFrame {

public SpecFrame() { setTitle(”Frame-teszt”); setBounds(100,50,300,100); Container cp = getContentPane(); cp.setLayout(new FlowLayout()); cp.add(new JLabel(”Döntsd el:”)); cp.add(new JButton(”OK”); cp.add(new JButton(”Nem OK”); pack(); show(); } } public class FrameTest3 { public static void main (String args[]) { new SpecFrame(); } } Ebben a megoldásban a komponenseket létrehozás után azonnal bedobjuk a konténerbe, így a deklarációk feleslegessé válnak. Csak azokat a komponenseket kell deklarálnunk, amelyekre később hivatkozni szeretnénk. A Window osztályban deklarált pack () metódus optimális méretűre alakítja az ablakot, és az elrendezés-menedzser szabályai szerint elrendezi az ablak komponenseit. A pack() felülbírálja a keret méretét, vagyis a setBonds metódus két paraméterét feleslegesen adtuk meg. A Component – ben deklarált setVisible ( true ) helyett http://www.doksihu most a Window osztály show() metódusával tesszük

láthatóvá a keretet. A show() előtérbe helyezi az ablakot. A végeredmény Point osztály Csomag: java.awt Deklaráció: public class Point Közvetlen ős: java.awtgeomPoint2D A Point osztály megjegyzi egy pont x és y koordinátáját. Konstruktorok, metódusok: • Point(int x, int y) //létrehozás • double getX() //x-koordináta • double getY() //y-koordináta • void setLocation(int x,int y) //új hely • void translate(int x,int y) //eltolás Dimension osztály Csomag: java.awt Deklaráció: public class Dimension Közvetlen ős: java.awtgeomDimension2D A Dimension osztály megjegyzi egy téglalap méretét (szélességét és magasságát.) Konstruktorok, metódusok: • Dimension(int width,int height) //létrehozás • double getWidth() //szélesség • double getHeight() //magasság • Dimension setSize() //méret http://www.doksihu • void setSize(double width, double height) //új méret Rectangle osztály Csomag: java.awt Deklaráció: public class

Rectangle Közvetlen ős: java.awtgeomRectangle2D A Rectangle osztály megjegyzi egy téglalap • helyzetét(location): bal felső sarkának x és y koordinátáját, és • méretét(dimension):szélességét(width) és magasságát(height). Konstruktorok,metódusok: • Rectangle(int x,int y,int width,int height) //létrehozás • Point getLocation() //bal felső sarok • void setLocation(int x,int y) //helyzetbeállítás • void setSize(int width,int height) //méretbeálltás • void grow(int h,int v) //méretnövelés Pontok, téglalapok - Feladat Adva van két téglalap: az egyik téglalap bal felső sarka a (100,100) pont, mérete 50*30; a másik téglalap bal felső sarka a (120,80) pont, mérete 20*60. - Határozzuk meg a téglalap közös részét! - Vizsgáljuk meg, hogy a (130,110) pont benne van-e a közös részben! - Határozzuk meg azt a legkisebb téglalapot, amely tartalmazza a téglalapokat és egy megadott pontsorozat összes pontját! import java.awt*;

public class PontTegla { public static void main(String[] args) { //r1 bal felső sarka (100,100), mérete 50x30: Rectangle r1 = new Rectangle (100,100,50,30); //r2 bal felső sarka (120,80), mérete 20x60: Rectangle r2 = new Rectangle (120,80,20,60); //r1 és r2 közös részének meghatározása: Rectangle kozos = r1.intersection(r2); System.outprintln("Közös: "+kozos); //A p pont koordinátái: (130,110): Point p = new Point (130,110); //Benne van a pont? if (kozos.contains(p)) System.outprintln(p+"benne van"); else http://www.doksihu System.outprintln(p+"nincs benne"); //Pontsorozat megadása: Point[] pontok = {new Point(50,80), new Point(15,70), new Point(30,95), new Point(120,200)}; //r1 és r2 téglalapok egyesítése, majd a pontok hozzáadása: Rectangle nagy = r1.union(r2); for (int i=0; i<pontok.length; i++) nagy.add(pontok[i]); System.outprintln("Nagy: "+nagy); System.outprintln("Nagy mérete: "+nagygetSize()); } } A

program futása Koordinátarendszer A képernyő bal felső sarka a (0,0) pont, x a vízszintes, y pedig a függőleges tengely. Ehhez az abszolút koordinátarendszerhez képest adjuk meg az ablakok bal felső sarkának koordinátáit. A konténerbe (ablakba, panelbe) tett komponensnek bal felső sarkának koordinátáit a konténer bal felső sarkához rögzített koordinátarendszerhez adjuk meg, vagyis ezek a szülőhöz képest megadott relatív koordináták. A futó programból lekérdezhető a képernyő mérete. http://www.doksihu Toolkit osztály Csomag: java.awt Deklaráció: public abstract class Toolkit Közvetlen ős: java.langObject A Toolkit osztály sok metódust tartalmaz a képernyő kezeléshez, nyomtatáshoz, stb; megmondja például a képernyő méretét és felbontását. Az aktuális Toolkit példányt a statikus getDefaultToolkit metódussal el kell kérni a rendszertől. Metódusok: • static Toolkit getDefaultToolkit() //alapértelmezett Tookit

elérése • Dimension getScreenSize() //képernyő mérete pontokban • int getScreenResolution() //képernyő felbontása(pont/inch) • Image createImage(String filename) //kép betöltése és létrehozása • void beep() //beépített hangszóró megszólal Színek A grafikus megjelenítés alapvető sajátossága a színek alkalmazása. A színeket komponensek, az ablak és a rajzolás színezésére használhatjuk. A komponens háttérszínét a setBackground(), az előtér színét a setForeground(), míg a rajzolás színét a setColor() metódussal állíthatjuk be. A színek kezelését a jawa.awt csomag Color osztálya segíti A színeket az RGB-modellnek megfelelően három (piros, zöld és kék) összetevőből álltjuk elő. Mindegyik összetevő értéke 0 és 255 között változhat. A (0,0,0) a fekete, míg a (255,255,255) a fehér színt jelölik Ha a három összetevő megegyezik, akkor a szürke valamelyik árnyalatát kapjuk. A színeket többféleképpen is

megadhatjuk • A Color osztály statikus osztálytagjaival az alábbi színeket érjük el: black – fekete blue – kék cyan – türkiz darkGrey – sötétszürke gray – szürke green – zöld magenta - lila lightGray – világosszürke orange – narancs pink – rózsaszín red – piros white – fehér yellow – sárga • A szín megadás másik módja az RGB-színösszetevők használata. szín R G B fehér 255 255 255 fekete 0 0 0 piros 255 0 0 zöld 0 255 0 kék 0 0 255 türkiz 0 255 255 sárga 255 255 0 lila 255 0 255 http://www.doksihu Példa Például állítsuk be a háttér színét türkizre! • Létrehozunk egy Color példányt, inicializálva az R,G és B értékekkel: setBackground (new Color (0,255,255)); • Vagy a Color osztály statikus színkonstansával: setBackground(Color.cyan); A tárolt színeknél lehetőség van sötétebb (darker()), illetve világosabb (brighter()) szín előállítására. Lehetőség van még az RGB-összetevők

lekérdezésére egyenként (getRed(), getGreen(), getBlue()), vagy együtt int értékbe getRGB(), illetve egy float típusú, háromelemű tömbbe getRGBColorComponents(). Betűtípusok A Font osztály egy objektuma valamilyen fontot (betűfajtát ) reprezentál. A Font tulajdonságai: - fontName: a font neve. Például: Arial, Times New Roman - style: a font stílusa. Lehetséges fontstílusok: PLAIN (szimpla), BOLD (kövér), ITALIC (dőlt), vagy BOLD+ITALIC (kövér dőlt). - size: a betű nagysága pontokban. Minden komponensnek van valamilyen fontja, s azt a setFont(Font) metódussal lehet beállítani. Ha egy komponensnek nem oldjuk meg külön a fontját, akkor az a szülőkomponens fontját „örökli”. Szín, Font – Feladat Tegyünk egy középszürke keretre egy „Szöveg” címkét 50 pontos, dőlt Dialog betűvel! A címke háttér – és szövegszíne legyen fehér! A címke mellé tegyünk egy szövetterületet; annak 40 pontos, egyenközű (monospaced) legyen a

betűje! import java.awt*; import javax.swing*; public class SzinFont extends javax.swingJFrame { Container cp = getContentPane(); public SzinFont() { initComponents(); setDefaultCloseOperation(EXIT ON CLOSE); // A keret bal felső sarka (100,50): setLocation(100,50); // A cp panel elrendezése sorfolytonos, színe középszürke: cp.setLayout(new FlowLayout()); cp.setBackground(new Color(180,180,180)); http://www.doksihu //Címke hozzáadása a tartalompanelhez: JLabel lb; cp.add(lb = new JLabel("Szöveg:")); lb.setFont( new Font("Dialog",FontITALIC,50)); lb.setBackground(SystemColorinfo); lb.setForeground(SystemColorinfoText); lb.setOpaque(true); //Szövegterület hozzáadása a tartalompanelhez: JTextArea ta; cp.add(ta = new JTextArea(5,20)); ta.setFont(new Font("Monospaced",FontPLAIN,40)); //Az ablak elrendezése és láthatóvá tétele: pack(); show(); } public static void main(String args[]) { java.awtEventQueueinvokeLater(new Runnable() { public

void run() { new SzinFont().setVisible(true); } }); } http://www.doksihu A végeredmény Az absztrakt JComponent osztály A JComponent absztrakt osztály, a képernyőn megjelenő Swing-komponensek közös őse. A JComponent-ben definiált jellemzők, metódusok tehát a felhasználói interfész bármely Swing-komponensére is értendők. Minden komponensnek van többek között helyzete(bal felső sarka), mérete, háttér- és előtérszíne, fontja, egérkurzora és eszköztippje. Jellemzők: a jellemzők a megfelelő set metódussal beállíthatók; a get metódusokkal lekérdezhetők. • Color background Color foreground A komponens háttérszíne és betűszíne. Alapértelmezésben a szülő színei • boolean opaque Átlátszatlan-e. Ha értéke true, akkor átlátszatlan, ha false, akkor átlátszó • Font font A komponens fontja. Alapértelmezésben a szülő fontja • Cursor cursor A komponens egérkurzora. Ez az objektum határozza meg azt, hogy milyen lesz az

egérkurzor, ha a komponens fölé visszük. • Border border http://www.doksihu • • • • • • A komponens szegélye. Minden komponensnek lehet külön szegélye, szegélyeket a javax.swingborder csomagban találhatunk, a BorderFactory osztály statikus metódusai pedig kész szegélyeket adnak. Dimension maximumSize Dimension minimumSize Dimension preferredSize Megadja a komponens maximális, minimális, illetve előnyös méretét. A komponens nem lehet nagyobb a maximális méretnél és kisebb a minimális méretnél. float alignment X float alignment Y A vízszintes, illetve függőleges igazítás mértéke az x, illetve az y tengely mentén, más komponensekhez viszonyítva. Ez egy 0 és 1 közötti szám: 0 a kezdőponthoz, 1 a végponthoz, 0.5 a középponthoz való igazítást jelenti String toolTipText Eszköztipp. Ha beállítjuk a komponens eszköztipp szövegét, akkor a komponens tippet adhat: ha a felhasználó egy kicsit elidőz az egérrel a

komponens felett, akkor a megjelenik az eszköztipp szövege. boolean visible Láthatóság. Ha az értéke true, akkor a komponens látható, feltéve, hogy a szülője is látható. Ha false az értéke, akkor a komponens létezik ugyan, de gyerekeivel együtt láthatatlan. boolean enabled Eseményfogadó képesség. Ha értéke true, akkor a komponens fogadhat eseményeket, egyébként érzéketlen a külső, felhasználó eseményekre. Alapértelmezésben true boolean requestFocusEnabled Ha értéke true, akkor a komponens fókuszba hozható, egyébként nem. Alapértelmezésben true. Láthatóság, érvényesség • boolean isDisplayable() Megmondja, hogy a komponens megjeleníthető-e. Egy komponens megjeleníthető, ha az eleme egy olyan tulajdonosi hierarchiának, amelyben megjeleníthető ablak a gyökérelem. Egy ablak megjeleníthető, ha arra alkalmazták a pack metódust vagy láthatóvá tették. Egy komponens megjeleníthetetlen lesz, ha kiveszik a tulajdonosi

hierarchiából vagy ( dispose metódussal ) felszabadították a gyökérablakot, s az emiatt megjeleníthetetlenné vált. • void validate() A komponens érvényesítése, szükség szerint újrarajzolása. Egy komponens érvénytelen, ha újrarajzolásra szorulna, de az még nem történt meg. Fókusz, eseményfogadás http://www.doksihu • boolean hasFocus() true, ha éppen ez a komponens van fókuszban. Az alkalmazásban legfeljebb egy komponens lehet fókuszban. A fókuszban levő komponens általában kiemelten látszik Csak a fókuszban levő komponens fogadhat billentyűeseményeket. • void requestFocus() Fókuszba helyezi a komponenseket. Csak akkor van hatása, ha a komponens látható • void transferFocus() Továbbadja a fókuszt a következő komponensnek. Csak akkor van hatása, ha a komponens látható. Szülő, állapot • Container getParent() Visszaadja a komponens tulajdonosát (szülőjét). Ha nincs szülője, akkor null az értéke. • String

toString() Visszaadja a komponens jellemzőit. • void list() Konzolra írja a komponens az összes gyerekének jellemzőit. Feladat – Komponensteszt Tegyünk egy 200x100-as keretbe egymás alá két szövegmezőt és egy nyomógombot! A fókusz a második szövegmezőn legyen! A nyomógomb nem fogadhat eseményt! Ha az egérkurzor az első szövegterület fölé kerül, változzon át kézkurzorrá! Listázzuk ki konzolra a tulajdonosi hierarchiát. import java.awt*; import javax.swing*; public class ComponentTest extends javax.swingJFrame { Container cp = getContentPane(); JTextField tf1, tf2; JButton bt; public ComponentTest() { initComponents(); setDefaultCloseOperation(EXIT ON CLOSE); setSize(200,100); cp.setLayout(new GridLayout (3,1)); //Rácsos elrendezés //1. szövegmező létrehozása, egérkurzorának beállítása: cp.add(tf1 = new JTextField("Ha fölém kerülsz, kézzé válsz")); tf1.setCursor(new Cursor(CursorHAND CURSOR)); //2.szövegmező létrehozása:

http://www.doksihu cp.add(tf2 = new JTextField("Kezdetben itt a fókusz")); //A nyomógomb létrehozása és érzéketlenné változtatása: cp.add(bt = new JButton("Hiába nyomsz!")); bt.setEnabled(false); show(); public static void main(String args[]) { java.awtEventQueueinvokeLater(new Runnable() { public void run() { new ComponentTest().setVisible(true); } }); } Az eredmény Container osztály A Container osztály a konténerkomponensek közös őse. A konténerbe gyerek – komponenseket lehet betenni, vezérlőket és újabb konténereket is. A gyerekkomponensek elrendezése a konténer elrendezés-menedzserének a feladata. Jellemzők: - LayoutManager layoutMgr A konténer elrendezés – menedzsere. Alapértelmezésben null http://www.doksihu Komponens hozzáadása, kivétele • Component add (Component comp) Component add (Component comp, int index) Komponens hozzáadása a konténerhez. Ha nem adunk meg indexet, akkor a komponens utolsóként

adódik a konténerhez. Ha indexet is megadunk, akkor a komponens a megadott indexű helyre szúródik be. Ha az index nagyobb, mint a legutolsó elem indexe, akkor Illegal ArgumentException kivétel keletkezik. • void remove (Component comp) void remove (int index) void removeAll() Komponens törlése a konténerből, Sorrendben: a megadott komponens törlése; az index sorszámú komponens törlése; az összes komponens törlése. Elrendezés • Dimension getMaximumSize() • Dimension getMinimumSize() • Dimension getPreferredSize() Megadja a konténer maximális, minimális, illetve előnyös méretét. A konténer nem lehet nagyobb a maximális méretnél és kisebb a minimális méretnél. java.awtWindow osztály A java.awtWindow osztály az összes AWT- és Swing ablakkomponens közös őse Belőle származnak például a következő osztályok: JFrame, JDialog, JWindow Metódusok • void pack() Elrendezi az ablakot a gyerekkomponensek előnyös méretei között. • void

show() boolean isShowing() A show láthatóvá teszi és előtérbe hozza a képernyőn az ablakot és annak gyerekeit. Az isShowing igaz, ha az ablak éppen előtérben van. • public void setLocationRelativeTo (Component c) A c komponenshez képest helyezi el az ablakot a képernyőn. Ha az ablak nem látható, akkor a képernyő középre teszi. • void toBack() void toFront() Háttérbe (előtérbe) küldi az ablakot. Ő lesz a tulajdonos legalsó (legfelső) ablaka, és ennek megfelelően átrendezi a többi látható ablakot. • void hide() Elrejti az ablakot az összes alkomponensével és a felügyelete alatt lévő ablakkal együtt. • void dispose() Felszabadítja az ablaknak és összes gyerekének natív képernyőforrását. • void addWindowListener (WindowListener 1) Ablakesemény – figyelő hozzáadása az ablakhoz. http://www.doksihu • Component getFocusOwner () Ha az ablak aktív, akkor visszaadja a fókuszban levő gyerekkomponenst. Ha az ablak nem

aktív, akkor null a visszaadott érték. • Window getOwner() Visszaadja az ablak tulajdonosát. • Window [] getOwnedWindows() Visszaadja az ablak által felügyelt ablakokat. JFrame osztály A keret (frame, osztály JFrame) olyan legfelső szintű ablak, amelynek nincsen tulajdonosa. A keretnek van kerete, ikonja, címe és menüsora. Szegélyénél fogva áthelyezhető, átméretezhető, mozgatható, ikonná tehető, stb. A keretet ikonná lehet változtatni, ekkor csak egy kis kép reprezentálja. A keretbe nem lehet közvetlenül komponenseket tenni; arra a tartalompanelje (content pane) szolgál, abba kell beletenni a komponenseket, A tartalompanel elrendezés – menedzsere alapértelmezés szerint határ menti (BorderLayout). Jellemzők: - String title A keret címe. - Image iconImage Az ikon a keret bal felső sarkában. - MenuBar menuBar A keret menüsora. - boolean resizable A keret méretezhető-e; ha true, akkor átméretezhető, egyébként nem. - int state A keret

állapota: normal (NORMAL) vagy ikonná változtatott (ICONIFIED). Alapértelmezésben: NORMAL. Metódusok • Container getContentPane() Visszaadja a keret tartalompaneljét. • void setDefaultCloseOperation ( int Operation ) Ezzel a metódussal azt adjuk meg, hogy mi történjen, ha a keretet megpróbálják becsukni. Lehetséges paraméterek: o DO NOTHING ON CLOSE: nem történik semmi. A keret tovább „él” és mutatkozik. o HIDE ON CLOSE: a keret tovább „él”, de láthatatlanná válik. o DISPOSE ON CLOSE: a keret „meghal”, de a program tovább fut. o EXIT ON CLOSE: a program futása befejeződik. • static Frame [] getFrames() Osztálymetódus; visszaadja a programban létrehozott összes keretet – a már meg nem jeleníthetőket is. A metódus a Frame osztályban van deklarálva, emiatt a visszaadott keretek Frame osztályúak. http://www.doksihu Feladat – Két keret Hozzunk létre két keretet: - az egyik mérete 500*200, legyen a képernyő közepén,

címe ”Első”, és nem méretezhető át; - a másik bal felső sarka a (0,0) pont, mérete 200*200, címe ”Második”, átméretezhető, és ikon állapotú! Írjuk ki konzolra az alkalmazásban szereplő keretek adatait! Futassuk le a programot! Próbáljuk átméterezni az első keretet! Nagyítsuk ki a második ikonná változott keretet! import javax.swingJFrame; import java.awtFrame; public class KetKeret { public static void main(String[] args) { JFrame fr = new JFrame("Első"); fr.setSize(500,200); //mérete 500*200 fr.setLocationRelativeTo(null); fr.setResizable(false); fr.show(); fr = new JFrame("Második"); fr.setBounds(0,0,200,200); fr.setState(JFrameICONIFIED); fr.show(); System.outprintln("Keretek az alkalmazásban"); Frame[] frames = Frame.getFrames(); for (int i=0; i<frames.length; i++); System.outprintln(frames[i]); } } A futtatás eredménye http://www.doksihu Frame osztály, az alkalmazás ablaka Az ablakhoz események

tartoznak, melyek kezeléséről több lépésben kell gondoskodnunk: - Implementálnunk kell a szükséges eseményfigyelő interfészt a java.awtevent csomagból, pl. a WindowListener - Az ablakosztályban kérnünk kell az ablak eseményeink figyelését, pl. az addWindowListener(this); hívással. - Végül ki kell dolgoznunk az interfészben előírt absztrakt metódusokat. Ha valamelyikre nincs szükségünk, akkor annak törzsét üresen hagyjuk. A fenti események kezelése esetén ez az osztály a WindowAdapter. WindowListener metódusai • windowOpened(WindowEvent e) { } • windowClosing(WindowEvent e) { System.exit(0); } //lezárása folyamatban • windowClosed(WindowEvent e) { } • windowIconified(WindowEvent e) { } • windowDeiconified(WindowEvent e) { } • windowActivated(WindowEvent e) { } • windowDeactived(WindowEvent e) { } //megnyitották //lezárták //ikonméretűvé tették //normálméretű lett //aktív lett //már nem aktív Feladat Készítsünk

alkalmazást, amely különböző RGB-színű téglalapokat jelenít meg! http://www.doksihu import java.awt*; import java.awtevent*; public class Szinek extends java.awtFrame { public Szinek() { super("Szinek példa"); setSize (320,200); setBackground (new Color (192,192,192)); addWindowListener(new WindowAdapter() { public void WindowClosing(WindowEvent e) { System.exit(0); } }); }; public void windowOpened(WindowEvent e){} public void windowClosed(WindowEvent e){} public void windowIconified(WindowEvent e){} public void windowDeiconified(WindowEvent e){} public void windowActivated(WindowEvent e){} public void windowDeactivated(WindowEvent e){} public void paint(Graphics g){ Rectangle r = getBounds (); g.setColor(new Color (255,255,255)); // fehér g.fillRect(20,40,50,50); g.setColor(new Color (0,0,0)); // fekete g.fillRect(100,40,50,50); g.setColor(new Color (255,0,0)); // piros g.fillRect(180,40,50,50); g.setColor(new Color (0,255,0)); // zöld g.fillRect

(260,40,50,50); g.setColor(new Color (0,0,255)); // kék g.fillRect (20,120,50,50); g.setColor (new Color (0,255,255)); // türkiz g.fillRect(100,120,50,50); g.setColor (new Color (255,255,0)); //sárga g.fillRect(180,120,50,50); g.setColor (new Color (255,0,255)); // lila g.fillRect(260,120,50,50); } public static void main(String args[]) { http://www.doksihu java.awtEventQueueinvokeLater(new Runnable() { public void run() { new Szinek().setVisible(true); } }); } } A program futtatása Rajzolás A Javában csak a rendszer által felkínált grafikus felületre, környezetre (graphics context), lehet leírni és rajzolni. A programozó nem húzhat mondjuk, vonalat a képernyőre tetszőleges két pontja között. A program minden komponenshez magától felkínál egy Graphics osztályú objektumot, s a programozó azt használja valaminek a megjelenítésére. Ebben a részben a Graphics osztály adta megjelenítési lehetőségekről lesz szó. A komponensekre, illetve azok

grafikus objektumaira szöveget fogok írni, egyeneseket, téglalapokat, sokszögeket rajzolok különböző színekkel, kitöltve vagy kitöltetlenül. java.awtGraphics absztrakt osztály Absztrakt osztály: örökítési célt szolgáló, rendszerint absztrakt metódust tartalmazó osztály. Példány nem hozható létre belőle. Absztrakt metódus: csak örökítési célra való üres metódus. http://www.doksihu Ez az osztály grafikus műveletekhez ad deklarációkat, s azokat külön – külön implementálták a használatos platformokra. Rajzoláskor a grafikus objektum ügyel arra, hogy a program ne írhasson rajta kívül eső területekre – az oda eső alakzatok egyszerűen nem rajzolódnak ki. A grafikus objektum továbbadható más metódusnak is, hogy az rajzoljon rá. A komponens gr : Graphics objektuma lefedi a komponens teljes felületét. A grafikus objektum bal felső sarkának két koordinátája a (0,0); a jobb alsó sarkának koordinátáit a komponens

mérete határozza meg. Minden koordináta pixelben értendő Ablak keretére nem lehet rajzolni. Hogyan férhetünk hozzá egy komponens Graphics objektumához? A Jcomponent osztály Graphics () metódusával elkérjük a komponenstől a grafikus felületét. Ez a metódus egy Graphics objektumot ad vissza, s arra rajzolunk. Ilyenkor a rajz csak egyszer jelenik meg, a komponens újrarajzolásakor egyszerűen eltűnik. Felülírjuk a JComponent osztály paintComponent (Graphics gr) metódusát. A metódus paraméterben kínálja fel a komponens grafikus objektumát, itt arra rajzolhatunk. Az alkalmazás olyan helyzetben hívja meg a paintComponent () metódust, mint amikor a célfelületet frissíteni kell, például a felhasználó elmozdít vagy átméterez egy komponenst. A rajzoláshoz szükséges fontosabb metódusok java.swing::JComponent getGraphics():Graphics paintComponent(gr: Graphics) repaint() setBackground(c: Color) getWidth(): int getHeight(): int java.awt::Graphics

setColor(drawColor:Color) setFont(f: Font) drawLine(x1,x2,y1,y2:int) drawString(s: String,x: int, y: int) drawPolygon(p: Polygon) fillPolygon(p: Polygon) AnyComponent paintComponent(gr: Graphics) A rajzoláshoz szükséges fontosabb metódusok Ez az ábra összefoglalja a rajzoláskor használt legfontosabb metódusokat, és azok helyét az osztályhierarchiában. Látható, hogy rajzolásra minden komponensnek van egy Graphics osztályú grafikus objektuma. A rajzoláshoz vagy felülírjuk a komponens paintComponent() metódusát vagy magát a grafikus objektumot kérjük el a getGraphics() metódussal. JComponent metódusok http://www.doksihu • Graphics getGraphics() Visszaadja a komponens grafikus felületét. Null értéket ad vissza, ha a komponens nem jeleníthető meg. • protected void paintComponent (Graphics gr) Ebben a metódusban szokás elhelyezni a rajzolóutasításokat. Annyiszor hívodik meg a metódus, ahányszor újra kell rajzolni a komponenst. Rajzolás

előtt meg kell hívni az előző paintComponent metódust (az őst), mert különben ott marad az előző kép. • void repaint() Újrarajzoltatás. Csak akkor kell hívni, ha az operációs rendszer nem veheti észre az újrarajzolás szükségét. Például, ha valamilyen adat megváltozott a programban, amit a komponens képének tükröznie kell. Mintaprogram A keret legyen zöld színű. Rajzoljunk a keretbe egy fekete ellipszist, s köréje egy fekete téglalapot! Írjuk az ellipszisbe a „Végre grafika!” szöveget fehér színű, vastag, 40 pontos, Arial betűvel! A szöveget húzzuk alá fehérrel. A keret aljára húzzunk egy vízszintes, vastag, narancsszínű vonalat! import java.awt*; import javax.swing*; class RajzPanel extends JPanel { protected void paintComponent (Graphics gr) { super.paintComponent(gr); setBackground (new Color (130,180,160)); gr.drawOval (40,80,320,100); gr.drawRect (40,80,320,100); gr.setColor (ColorWHITE); gr.setFont (new Font („Arial”,

FontBOLD,40)); gr.drawString („Végre grafika!”,60,140); gr.drawLine (60,140,340,140); gr.setColor (ColorORANGE); gr.fillRect (0,200,500,10); public class GraphTest extends JFrame { public GraphTest() { setBounds (500,200,400,280); setDefaultCloseOperation (JFrame.EXIT ON:CLOSE); getContentPane().add(new RajzPanel()); show(); } public static void main (String args[]) { new GraphTest(); http://www.doksihu } } A futtatás eredménye