On saanud tavaks alustada programmeerimiskeele tutvustamist rakenduse
(application) "Hello World!" abil. Kuna Java on tihedasti
seotud võrguga, siis nimetame seda "Hello Web!".
Kirjutage järgnev tekst faili HelloWeb.java
Selle kompileerimiseks andke käsk
Koostame nüüd HTML dokumendi, mis sisaldab viidet sellele
rakendile (applet). Kirjutage faili HelloWeb.html, mis asub binaarse
klassifailiga samas kataloogis, järgnev tekst:
public class HelloWeb extends java.applet.Applet {
public void paint( java.awt.Graphics gc ) {
gc.drawString("Hello Web!", 125, 95);
}
}
% javac HelloWeb.java
Selle tulemusel luuakse baitkoodis (byte-code) binaarne klassifail
HelloWeb.class.
<html>
<head></head>
<body>
<applet code=HelloWeb width=300 height=200></applet>
</body>
</html>
Nüüd on võimalik Javat toetava Webi lehitsejaga seda
dokumenti koos sealt viidetud rakendiga (applet) vaadata. Siin see HelloWeb.html on.
Nüüd asume seda meie poolt kirjutatud programmi lahti seletama.
Eelnevas näites defineeriti klass (class) nimega HelloWeb. Klass
on grupp andmeelemente (data items) koos funktsioonidega, mis
teostavad operatsioone nende andmetega. Klassi andmeelemente nimetatakse
väljadeks (fields) või muutujateks (variables),
funktsioone aga meetoditeks (methods).
Klass võib olla midagi konkreetset, nagu näiteks nupp ekraanil
või informatsioon tabelis,
või midagi abstraktsemat, nagu näiteks sorteerimisalgoritm.
Hüpoteetilises tabeli klassis võiksid näiteks olla
muutujad, mis esitavad väärtusi eri lahtrites ja meetodid, mis
teostavad operatsioone nende lahtritega, nagu näiteks "Puhastada
rida" või "Arvutada väärtused".
Meie HelloWeb klass on meie Java rakendi (applet) hoidja (container). See hoiab kahte üldist tüüpi muutujaid ja meetodeid: neid, mida me vajame konkreetse rakendi tööks ja teatud spetsiaalseid eelnevalt projekteerituid, mille abil me suhtleme välismaailmaga.
Environment -----------------
I HelloWeb I
"Time to redraw screen" -------->I paint() I
"Applet is visible" ------------>I start() I
"Applet no longer visible" ----->I stop() I
"The user did something" ------->I handleEvent() I
-----------------
Java käitusaegne (run-time) keskkond (environment) kutsub
perioodiliselt välja meetodeid HelloWeb-s. Meie HelloWeb klassis on
defineeritud ainult üks meetod paint(). Meetod paint() kutsutakse Java
poolt välja siis, kui on aeg rakendusel ennast ekraanile joonistada.
Hiljem näete, et klass HelloWeb pärib (derive) osa oma struktuurist klassist Applet.
Kui rakendus on aktiivne, võib antud klassist olla kasutusel mitu koopiat. Neid koopiaid nimetatakse klassi eksemplarideks (instances). Sama klassi eksemplarid võivad olla erinevates olekutes, kuid neil on alati samad meetodid. Klass on sabloon, mille järgi vormitakse eksemplare.
Objekt on väga üldine mõiste. Siin kasutatakse objekti aga eksemplari sünonüümina.
Meie näites genereeris Javat toetav WWW-lehitseja klassi HelloWeb eksemplari. Kui kirjutada applet lähtetekst kaks korda meie HTML-dokumenti, siis tehakse kaks klassi HelloWeb eksemplari.
Javas defineerib iga klass uue tüübi. Muutja võib olla seda tüüpi ja hoida selle klassi eksemplari. Samuti võib muutuja olla tüüpi integer või float. Seega võib klass kasutada juba olemasolevaid klasse oma tööriistadena. Näiteks võib muutuja olla tüüpi Button ja hoida klassi Button eksemplari. Sellist teiste klasside kasutamist mingi klassi sees nimetatakse kompositsiooniks (composition).
Näites HelloWeb oli ainult üks muutuja meetodis paint()
public void paint( java.awt.Graphics gc ) {.....}
Kui meetod paint() kutsutakse välja, siis võetakse argument gc
ja omistatakse sellele objekt tüüpi Graphics. Kui on tegu
muutujaga, mis hoiab kompleksset tüüpi objekti, siis see muutuja
ei sisalda mitte seda objekti, vaid viitab (references) sellele.
Kui viit-tüüpi (reference-type) muutuja alguses
defineeritakse, siis omistatakse talle vaikimisi väärtus null.
Kasutades viita väärtusega null antakse veateade. Küsimusele,
kuidas saada viit-tüpi muutujale väärtust, vastatakse hiljem
(operaator new).
Java klassid on järjestatud vanema-järeltulija hierarhiasse.
Vanem - ülemklass (superclass) ja järeltulijad -
alamklassid (subclass). Javas on igal klassil täpselt üks
ülemklass, kuid võib olla mitu alamklassi.
Võtmesõna extends näitab meie näites, et klass HelloWeb
on klassi Applet alamklass.
public class HelloWeb extends java.applet.Applet {.....}
Alamklass võib pärida mõned või kõik
ülemklassi muutujad ja meetodid. Pärimise kaudu saab alamklass
kasutada neid muutujaid ja meetodeid nii, nagu need oleksid temas endas
defineeritud. Alamklassis võib üle defineerida
(override) ülemklassi meetodite ja muutujate tähenduse.
Meie näites on klassis HelloWeb mitmeid päritud muutujaid ja meetodeid, mida me otse ei ole defineerinud.
Klass Applet loob raamistiku rakendite ehitamiseks. See klass sisaldab meetodeid, mis toetavad Java rakenduste baasfunktsionaalsust. Klassi Applet alamklassides me defineerime üle meetodid, et saavutada meie rakendi soovitud käitumist. Kui kirjutada HTML-lähteteksti
<applet code=java.applet.Applet width=300 height=200></applet>siis näete ekraanil ainult tühja piirkonda. Klass Applet loob raamistiku rakendite ehitamiseks.
Me võime osutada HelloWeb-ile kui Applet-ile, sest alamklasside
loomine tekitab nn "on" relatsiooni, milles alamklass on ülemklassi
liiki. HelloWeb on seega liiki Applet. Kui me viitame mingit liiki
objektile, siis me mõtleme kas vastava objektiklassi või selle
mingi alamklassi eksemplari. Java klassihierarhia üks osa:
Meie eelmises näites viidati klassile Applet tema täieliku nimega
java.applet.Applet:
Mõned klassid ei ole Javas kirjutatud, kuid on Java osad. Selliseid
klasse on 22. Uuele platvormile minekul tuleb ainult need klassid portida.
Need klassid teostavad suhtlemise operatsioonisüsteemiga.
Ülejäänud klassid on platvormist sõltumatud.
Klassis HelloWeb on kirjeldatud ainult üks meetod, paint(), mis
defineerib üle meetodi paint() klassist Applet:
Piiritlejad (modifiers) on võtmesõnad enne klasse,
muutujaid ja meetodeid ning mõjuvad nende juurdepääsule,
käitumisele, või semantikale. Kuna paint() on defineeritud
võtmesõna public abil, siis on talle juurdepääs ka
väljastpoolt klassi (Java keskkond kutsub seda välja). Kui
piiritlejaks on private, siis pääseb muutujale või
meetodile ligi ainult klassi seest.
Graphics objekt, klassi Graphics eksemplar, esitab graafilist
joonistuspiirkonda. See sisaldab meetodeid, mida rakend
ekraanile joonistamiseks välja kutsub.
Muutujale või meetodile juurdepääs toimub hierarhiliselt,
kasutades "." (punkti), nagu C++ -s. Meie näites kutsusime välja
meetodi drawString() Graphics objektist (sellele viitas muutuja gc):
Object
I
Component
I
-------------------------------
I I
Button Container
I
----------------
I I
Window Panel
I
Applet
I
HelloWeb
Applet on Panel liiki, mis omakorda on Container liiki, kõik
äsjamainitud klassid on aga ka Component liiki. Component on klassi
Object alamklass. Klass Object on Java klassihierarhia tipus. Iga teine
klass Java API standardis pärib oma käitumise klassilt Object,
milles on defineeritud mõned baasmeetodid.
public class HelloWeb extends java.applet.Applet {.....}
Eesliide klassi nimes näitab, et see kuulub paketti java.applet. Pakett
on grupp Java klasse, mis on seotud mingi eesmärgi või rakenduse
järgi. Sama paketi klassidel on spetsiaalsed juurdepääsu
privileegid teineteise suhtes ja nad võivad olla projekteeritud koos
töötama. Java pakettide nimed on hierarhilised, nagu URL-d WWW-s.
Pakette võidakse töö käigus dünaamiliselt üle
võrgu kohale tuua. Iga pakett, mis algab liitega java, on Java API
tuuma osa ja on kättesaadav igas Java platformis. Järgnev joonis
tutvustab Java pakettide tuuma, iga paketi kohta on ära toodud 1-2
klassi:
------------------------------------------------------------------------
I java I
I ---------- --------- ------------- ---------- ----------------- I
I I lang I I io I I applet I I net I I awt I I
I I I I I I I I I I I I
I I String I I File I I Applet I I URL I I Graphics I I
I I Thread I I .... I I AudioClip I I Socket I I Component I I
I I ...... I I I I ......... I I ...... I I ......... I I
I ---------- --------- ------------- ---------- I I I
I I ------------- I I
I I I image I I I
I I I I I I
I I IColorModel I I I
I I I.......... I I I
I I ------------- I I
I I -------- I I
I I I peer I I I
I I I I I I
I I I .... I I I
I I -------- I I
I ----------------- I
------------------------------------------------------------------------
java.lang koosneb klassidest, mis on Java enda jaoks vajalikud; java.awt
sisaldab Java Abstract Windowing Toolkit klassid; java.net koosneb
võrgunduse klassidest.
public void paint( java.awt.Graphics gc ) {
gc.drawString("Hello Web!", 125, 95);
}
Meetod paint() kutsutakse Java poolt välja siis, kui on aeg rakend
ekraanile joonistada. Selle ainukeseks argumendiks on Graphics
tüüpi objekt ja ta ei tagasta mingit väärtust selle
väljakutsujale (void).
gc.drawString("Hello Web!", 125, 95);
Teine näide