Johdanto AWT: hen

Java-ohjelmointikielikurssikirjasto tarjoaa käyttöliittymän työkalupaketin nimeltä Abstract Windowing Toolkit tai AWT. AWT on sekä tehokas että joustava. Uudet tulokkaat huomaavat kuitenkin usein, että sen voima peitetään. Jaetusta dokumentaatiosta löytyvät luokka- ja menetelmäkuvaukset antavat vähän ohjeita uudelle ohjelmoijalle. Lisäksi käytettävissä olevat esimerkit jättävät usein vastaamatta moniin tärkeisiin kysymyksiin. Uusien tulokkaiden pitäisi tietysti odottaa vaikeuksia. Tehokkaat graafiset käyttöliittymät ovat luonnostaan ​​haastavia suunnitella ja toteuttaa, ja joskus monimutkaiset vuorovaikutukset AWT: n luokkien välillä vain tekevät tehtävästä monimutkaisemman. Asianmukaisella ohjauksella graafisen käyttöliittymän luominen AWT: tä käyttäen ei ole vain mahdollista, vaan suhteellisen yksinkertaista.

Tämä artikkeli kattaa osan AWT: n taustalla olevasta filosofiasta ja käsittelee käytännön huolenaiheita siitä, miten luoda yksinkertainen käyttöliittymä sovelmalle tai sovellukselle.

Mikä on käyttöliittymä

Käyttöliittymä on ohjelman osa, joka on vuorovaikutuksessa ohjelman käyttäjän kanssa. Käyttöliittymät ovat monenlaisia. Nämä muodot vaihtelevat monimutkaisuudesta yksinkertaisista komentoriviliitännöistä monien nykyaikaisten sovellusten tarjoamaan osoittamalla ja napsauttamalla graafiseen käyttöliittymään.

Alimmalla tasolla käyttöjärjestelmä lähettää tietoja hiirestä ja näppäimistöstä ohjelmalle syötteeksi ja tarjoaa pikseleitä ohjelman ulostulolle. AWT on suunniteltu siten, että ohjelmoijat eivät tarvitse huolehtia hiiren seurannan tai näppäimistön lukemisen yksityiskohdista eivätkä huolehtia näytölle kirjoittamisen yksityiskohdista. AWT tarjoaa hyvin suunnitellun olio-rajapinnan näille matalan tason palveluille ja resursseille.

Koska Java-ohjelmointikieli on alustasta riippumaton, myös AWT: n on oltava alustasta riippumaton. AWT on suunniteltu tarjoamaan yhteinen työkalusarja graafiselle käyttöliittymäsuunnittelulle, joka toimii useilla alustoilla. AWT: n tarjoamat käyttöliittymäelementit toteutetaan kunkin alustan natiivin GUI-työkalupaketin avulla, mikä säilyttää kunkin alustan ulkoasun. Tämä on yksi AWT: n vahvimmista puolista. Tällaisen lähestymistavan haittana on se, että yhdelle alustalle suunniteltu graafinen käyttöliittymä voi näyttää erilaiselta, kun se näytetään toisella alustalla.

Komponentit ja säiliöt

Graafinen käyttöliittymä on rakennettu graafisista elementeistä, joita kutsutaan komponenteiksi. Tyypillisiä komponentteja ovat painikkeet, vierityspalkit ja tekstikentät. Komponenttien avulla käyttäjä voi olla vuorovaikutuksessa ohjelman kanssa ja antaa käyttäjälle visuaalista palautetta ohjelman tilasta. AWT: ssä kaikki käyttöliittymäkomponentit ovat luokan Component tai jonkin sen alatyypin esiintymiä.

Komponentit eivät ole yksin, vaan ne löytyvät pikemminkin säiliöistä. Säiliöt sisältävät komponenttien asettelun ja hallitsevat sitä. Kontit ovat itse komponentteja, ja ne voidaan siten sijoittaa muiden astioiden sisään. AWT: ssä kaikki kontit ovat luokan Container tai jonkin sen alatyypin esiintymiä.

Alueellisesti komponenttien on mahtuttava kokonaan niitä sisältävään säiliöön. Tämä komponenttien (mukaan lukien kontit) pesiminen kontteihin luo elementtipuun, joka alkaa puun juuressa olevasta astiasta ja laajenee lehtiin, jotka ovat komponentteja, kuten napit.

Kuvan 1 kuva kuvaa yksinkertaisen graafisen käyttöliittymän sellaisena kuin se näyttäisi, kun se näytetään Windows 95 -käyttöjärjestelmässä. Kuvassa 2 on esitetty kuvan 1 liitäntäkomponentit puuna järjestettynä.

Komponenttien tyypit

Kuvio 3 esittää perintäsuhteen AWT: n tarjoamien käyttöliittymäkomponenttiluokkien välillä. Luokkakomponentti määrittää rajapinnan, johon kaikkien komponenttien on tartuttava.

AWT tarjoaa yhdeksän muuta kuin konttikomponenttikomponenttiluokkaa, joista käyttöliittymä voidaan rakentaa. (Uusia komponenttiluokkia voidaan tietysti johtaa mistä tahansa näistä tai itse luokan komponentista.) Nämä yhdeksän luokkaa ovat luokan painike, kangas, valintaruutu, valinta, otsikko, luettelo, vierityspalkki, TextArea ja TextField. Kuva 4 kuvaa kunkin luokan esiintymää.

Kuva 4.

Yhdeksän käyttöliittymäkomponenttia

Tämän näytön lähde löytyy täältä.

Konttien tyypit

AWT tarjoaa neljä konttiluokkaa. Ne ovat luokan Window ja sen kaksi alatyyppiä - luokan kehys ja luokan valintaikkuna - sekä Paneeli-luokka. AWT: n toimittamien säiliöiden lisäksi Applet-luokka on kontti - se on Panel-luokan alatyyppi ja voi siten pitää sisällään komponentteja. Alla on lyhyt kuvaus kustakin säiliöluokasta, jonka AWT tarjoaa.

Säilön luominen

Ennen käyttöliittymän muodostavien komponenttien lisäämistä ohjelmoijan on luotava säilö. Rakennettaessa sovellusta ohjelmoijan on ensin luotava luokka-ikkuna tai luokan kehys. Sovellusta rakennettaessa kehys (selainikkuna) on jo olemassa. Koska Applet-luokka on Panel-luokan alatyyppi, ohjelmoija voi lisätä komponentit itse Applet-luokan ilmentymään.

Listing 1: n koodi luo tyhjän kehyksen. Kehyksen otsikko ("Esimerkki 1") asetetaan kutsulle konstruktorille. Kehys on aluksi näkymätön, ja se on tehtävä näkyväksi kutsumalla sitä näytä() menetelmä.

tuo java.awt. *; 
public class Esimerkki1 {public static void main (String [] args) {Frame f = new Frame ("Esimerkki 1"); 
 f.näytä (); }} 

Listaus 1.

Tyhjä kehys

Listing 2: n koodi laajentaa koodia Listing 1: stä siten, että uusi luokka perii luokan Panel. vuonna main () -menetelmällä tämän uuden luokan ilmentymä luodaan ja lisätään Frame-objektiin kutsun avulla lisätä() menetelmä. Tulos näytetään sitten. Molempien esimerkkien tulosten tulisi näyttää identtisiltä (toisin sanoen niiden pitäisi näyttää melko mielenkiintoisilta).

tuo java.awt. *; 
public class Esimerkki 1a laajentaa paneelia {public static void main (String [] args) {Frame f = new Frame ("Esimerkki 1a"); 
 Esimerkki 1a ex = uusi esimerkki la (); 
 f.add ("Center", entinen); 
 f. pakkaus (); f.näytä (); }} 

Listaus 2.

Kehys, jossa on tyhjä paneeli

Johtamalla uusi luokka luokan Appletista Class Panelin sijaan tämä esimerkki voi nyt toimia joko erillisenä sovelluksena tai verkkosovelluksena upotettuna sovelmana. Tämän esimerkin koodi on luettelossa 3. Tuloksena oleva sovelma näkyy kuvassa 5 (ja on edelleen melko mielenkiintoinen).

tuo java.awt. *; 
public class Esimerkki 1b laajentaa java.applet.Applet {public static void main (String [] args) {Frame f = new Frame ("Esimerkki 1b"); 
 Esimerkki1b ex = uusi Esimerkki 1b (); 
 f.add ("Center", entinen); 
 f. pakkaus (); f.näytä (); }} 

Listaus 3.

Kehys, jossa on tyhjä sovelma

Kuva 5.

Tyhjä kehys

Huomaa: Ikkuna-objekti ja joissakin tapauksissa jopa Dialog-objekti voivat korvata Kehys-objektin. Ne ovat kaikki kelvollisia kontteja, ja komponentit lisätään kuhunkin samalla tavalla.

Komponenttien lisääminen astiaan

Jotta käyttöliittymä olisi hyödyllinen, sen on koostuttava enemmän kuin vain säilöstä - sen on sisällettävä komponentteja. Komponentit lisätään astioihin kontin kautta lisätä() menetelmä. Siellä on kolme perusmuotoa lisätä() menetelmä. Käytettävä menetelmä riippuu kontin asetteluhallinnasta (katso osio otsikolla Komponenttien asettelu).

Listing 4: n koodi lisää kahden painikkeen luomisen luettelossa 3 esitettyyn koodiin. Luonti suoritetaan sen sisällä() menetelmä, koska sitä kutsutaan automaattisesti sovelman alustamisen aikana. Siksi, riippumatta siitä, miten ohjelma käynnistetään, painikkeet luodaan, koska sen sisällä() kutsutaan joko selaimella tai main () menetelmä. Kuva 6 sisältää tuloksena olevan sovelman.

tuo java.awt. *; 
julkinen luokka Esimerkki 3 laajentaa java.applet.Applet {public void init () {add (new Button ("One")); lisää (uusi painike ("kaksi")); } 
 public Dimension preferencesSize () {return new Dimension (200, 100); palauta uusi ulottuvuus (200, 100); } 
 public static void main (String [] args) {Kehys f = uusi kehys ("Esimerkki 3"); 
 Esimerkki 3 ex = uusi esimerkki 3 (); 
 esim. init (); 
 f.add ("Center", entinen); 
 f. pakkaus (); f.näytä (); }} 

Listaus 4.

Appletti, jossa on kaksi painiketta

Kuva 6.

Appletti, jossa on kaksi painiketta

Komponenttien asettelu

Tähän asti ei ole sanottu mitään siitä, miten astiaan lisätyt komponentit asetetaan. Asettelua ei ohjaa säilö, vaan säilöön liittyvä ulkoasun hallinta. Asettelupäällikkö tekee kaikki komponenttien sijoituspäätökset. AWT: ssä kaikki asettelunhallintaluokat toteuttavat LayoutManager-käyttöliittymän.

AWT tarjoaa viisi ulkoasunhallintaohjelmaa. Ne vaihtelevat hyvin yksinkertaisista erittäin monimutkaisiin. Tämä artikkeli kattaa vain kaksi taittojen hallinnan luokkaa, joita tässä esimerkit käyttävät: FlowLayout-luokka ja BorderLayout-luokka.

FlowLayout-luokka sijoittaa komponentit säiliöön vasemmalta oikealle. Kun yhden rivin tila on käytetty, toinen rivi aloitetaan. Kontin yhden argumentin versio lisätä() menetelmää käytetään komponenttien lisäämiseen.

BorderLayout-luokassa on viisi vyöhykettä kuvan 7 mukaisesti. Vyöhykkeiden nimet ovat "Pohjoinen", "Etelä", "Itä", "Länsi" ja "Keskusta". Yksi komponentti voidaan sijoittaa kuhunkin näistä viidestä vyöhykkeestä. Kun ympäröivän säiliön kokoa muutetaan, jokaisen rajavyöhykkeen kokoa muutetaan vain niin paljon, että se pitää sisällään komponentin. Ylimääräinen tila annetaan keskialueelle. Kahden argumentin versio kontista lisätä() menetelmää käytetään komponenttien lisäämiseen. Ensimmäinen argumentti on String-objekti, joka nimeää alueen, johon komponentti sijoitetaan.

Jokaisella säilöluokalla on oletusasettelun hallinta. Kehys- ja Dialog-luokan oletusasettelun hallinta on BorderLayout-hallinta. Panel-luokan (ja Applet-luokan) oletusasettelun hallinta on FlowLayout-hallinta.

Listauksen 5 koodi käyttää molempia asettelunhallintaohjelmia ja sisältää vielä muutamia käyttöliittymäkomponentteja. Tulos näkyy kuvassa 8.

tuo java.awt. *; 
julkinen luokka Esimerkki4 laajentaa java.applet.Applet {public void init () {Paneeli p; 
 setLayout (uusi BorderLayout ()); 
 p = uusi paneeli (); 
 p.add (uusi TextArea ()); 
 lisää ("Center", p); 
 p = uusi paneeli (); 
 p.add (uusi painike ("yksi")); p.add (uusi painike ("kaksi")); 
 Vaihtoehto c = uusi valinta (); 
 c.addItem ("yksi"); c.addItem ("kaksi"); c.addItem ("kolme"); 
 p.ad (c); 
 add ("etelä", p); } 
 public static void main (String [] args) {Kehys f = uusi kehys ("Esimerkki 4"); 
 Esimerkki4 ex = uusi esimerkki4 (); 
 esim. alku (); 
 f.add ("Center", entinen); 
 f. pakkaus (); f.näytä (); }} 

Listaus 5.

Monimutkaisempi esimerkki

Kuva 8.

Monimutkaisempi esimerkki

Tapahtumien käsittely

Yllä olevat esimerkit eivät sisällä muuta kuin inertin käyttöliittymän näyttämistä. On tietysti erittäin tärkeää, että käyttöliittymä ryhtyy toimiin käyttäjän syötteen seurauksena. Tämä artikkeli on kuitenkin sen alueen ulottumattomissa, että kaivetaan syvällisesti tapahtumien käsittelyn mysteereihin. Sen on odotettava tulevaan artikkeliin. Täydellisyyden vuoksi luettelon 6 esimerkkikoodi näyttää kuitenkin, kuinka käsitellä yhden tyyppisiä tapahtumia, joita ohjelma voi vastaanottaa. Uusi luokka ohittaa toiminta() Component-luokan tarjoama menetelmä. toiminta() method reagoi toimintatapahtumiin, jotka syntyvät esimerkiksi valitsemalla kohde ponnahdusvalikosta. toiminta() menetelmä edellyttää, että toimitetaan kaksi parametria, Tapahtuma- ja Objekti-ilmentymä. Tapahtuma-ilmentymä sisältää tietoja tapahtumasta, mukaan lukien tapahtuman kohde (tapahtuman ensimmäisenä vastaanottanut komponentti), tapahtuman x- ja y-koordinaatit sekä ajankohdan, jolloin tapahtuma tapahtui. Objekti-ilmentymä sisältää tapahtumakohtaisen datan. Painikeobjektien kohdalla se sisältää tekstin painikkeen otsikossa.

tuo java.awt. *; 
julkinen luokka Esimerkki 5 laajentaa java.applet.Applet {TextArea ta = null; 
 public void init () {Paneeli p; 
 setLayout (uusi BorderLayout ()); 
 p = uusi paneeli (); 
 ta = uusi tekstialue (); 
 p. add (ta); 
 lisää ("Center", p); 
 p = uusi paneeli (); 
 p.add (uusi painike ("yksi")); p.add (uusi painike ("kaksi")); 
 Vaihtoehto c = uusi valinta (); 
 c.addItem ("yksi"); c.addItem ("kaksi"); c.addItem ("kolme"); 
 p.ad (c); 
 add ("etelä", p); } 
 julkinen looginen toiminto (Tapahtuma e, Objekti o) {String str = (String) o; 
 ta.appendText (str + "\ n"); 
 return false; } 
 public static void main (String [] args) {Kehys f = uusi kehys ("Esimerkki 5"); 
 Esimerkki 5 ex = uusi esimerkki 5 (); 
 esim. alku (); 
 f.add ("Center", entinen); 
 f. pakkaus (); f.näytä (); }} 

Listaus 6.

Esimerkki tapahtumien käsittelystä