2. Java programavimo pagrindai
Java kalba labai sparčiai populiarėja programuotojų pasaulyje. Perskaitę šį skyrelį galėsite parašyti savo pirmąją programėlę Java kalba. Kad parašyti Java programą teks trumpai susipažinti su programos struktūra, jos kompiliavimu ir paleidimu vykdyti. Kad būtų lengviau įsisavinti šią informaciją labai pageidautinos analogiškos žinios kita aukšto lygio programavimo kalba, pvz. Paskalio ar (dar geriau) C ar C++.
Pirma susipažinsime kaip instaliuoti Java praginos (runtime) ir įrankių rinkinį (development kit environment) Jei dirbsite fakulteto kompiuteriu, šios žinios nebūtinos, nes šį darba už jus atliko kompiuterius aptarnaujantis personalas. Skyrelio pabaigoje išmoksime parašyti parasčiausia įskiepį, kurį patalpinsime Interneto puslapyje.
Taigi kaip instaliuoti kompiuteryje Java kompiliatorių ir programas, reikalingas paleisti šia kalba parašytas programas. Visos reikalingos priemonės yra taip vadiname Java įrankių rinkinyje Java Developers Kit (JDK), kurį galima laisvai nusisiurbti iš Sun Microsystems. Vėliausią JDK versija parsisiųskite iš http://java.sun.com. Instaliavimo detalų aprašyma rasite tinklapyje.
Rekomenduotina PATH sisteminį kintamąjį papildyti "c:\java\bin" eilute arba ta eilute, kur jūs patalpinsite Java.
Dabar galima pradėti programuoti. Savaime aišku reikia pasirinkti redaktorių. Java programą reikia surinkti su tekstiniu redaktoriumi ir failą įrašyti su galūne .java. Langų aplinkoje galima naudoti Notepad redaktorių, tačiau jokiu būdu ne Microsoft Word 7.0, nes jis nėra tekstinis redaktorius.
Jei instaliavote Java, laikas išmėginti ar jūsų kompiuteris pilnai pasiruošęs kurti ir vykdyti Java programas. Geriausias būdas parašyti Java programėlę (pirmą kartą galite ją tiesiog nukopijuoti iš šio ar kito puslapio), ją sutransliuoti ir paleisti vykdyti.
Makintošo vartotojai (vargu ar daug tokių atsiras) šią dalį praleiskite ir
pereikite tiesiai prie įskiepių aprašymo.
Pvz. 2-1: Paprasta java programa - OurPrimaryClass.java.
import java.util.*; public class OurPrimaryClass { public final static void main(String S[]) { System.out.println("Sveika, Java!"); Date d=new Date(); System.out.println("Data: "+d.toString()); } }
Jei surinkote ar nusikopijavote šios programos tekstą, išsaugokite
failą vardu OurPrimaryClass.java.
Java kalba reikalauja, kad public class (vieša klasė) būtų
išsaugojama faile su tuo pačiu klasės pavadinimu.
Musų pavyzdyje - public OurPrimaryClass klasė turi būti užrašyta
OurPrimaryClass.java faile.
Toliau reika programą sukompiliuoti. Tam naudojama javac programa.
UNIX ir Windows vartotojai tai darysite taip:
javac OurPrimaryClass.java
Makintošo vartotojai turi iškviesti Java kompiliavimo ikoną ir atidaryti OurPrimaryClass.java failą kompiliavimui.
Jei kompiliavimo metu gavote pranešimą apie kompiliavimo klaidas, ieškokite programos spausdinimo klaidų. Jei spausdinimo klaidų nėra, patikrinkite:
Anksčiau ar vėliau pasieksite, kad transliavimo metu nebus pranešimo apie klaidas. Tuomet tame pačiame kataloge kur yra OurPrimaryClass.java failas atsiras sukompiliuotas failas OurPrimaryClass.class. Kad paleisti programą praginai (vykdymui) UNIX ir Windows vartotojai komandinėje eilutėje surinkite:
java OurPrimaryClass
Java praginos aplinka iškviečia OurPrimaryClass ir pradeda programos vykdymą nuo main metodo. Rezultatas turėtų būti toks:
Sveika, Java!
Kitoje eiluteje turetų pasirodyti "Data:" standartiniu formatu. Galima praginos klaida - OurPrimaryClass.class nerastas. Tuomet CLASSPATH sisteminį kintamąjį papildykite einamuoju katalogu.
Makintošo vartotojai turi šią programa paleisti kaip įskiepį (applet).
Parametrų perdavimas komandine eilute
Ne Makintošo vartotojai komandine eilute galite perduoti programai skirtus parametrus. Čia ir pasitarnauja mistinė String S[]. Kiek perrašykime musų Java programėlę:
Pvz. 2-2: Naudojantis komandine eilute perduodamus parametrus main metodas.
public class PrintCommandLineParameters { public final static void main(String S[] ) { System.out.println("Sveika, Java!"); System.out.println("Komandine eilute buvo perduoti tokie parametrai:"); for(int i=0;i<S.length;i++) System.out.println(S[i]); } }
Dabar musų programa spausdins visus komandine eilute perduodamus parametrus. Nauja programą reikės iškviesti praginai taip:
java PrintCommandLineParameters parametrasl parametras2 parametras3 parametras4
Rezultatas turėtų atrodyti taip:
Sveika, Java! Komandine eilute buvo perduoti tokie parametrai: parametrasl parametras2 parametras3 parametras4
Pastaba. main metodas analogiškas main funkcijai naudojamai C
ir C++ kalbose.
Tikriausiai supratote, kad System.out.println yra esminis programos elementas, skirtas spausdinti ekrane tekstą. Paprastoms Java programoms System.out.println pilnai pakanka. Tačiau Java įskiepiai išveda informaciją į grafinį ekraną ir tuo tikslu System.out.println panaudoti negalima. Kiek pasiaiškinkime System.out.println darbą.
Kaip pastebėjote System.out.println spausdina tarp kabučių surinktą tekstą. Šis tekstas spausdinamas vienoje eilutėje; kita System.out.println pradės spausdinti tekstą naujoje eilutėje. Taip pat galima spausdinti ir kintamujų reikšmes kartu su tekstu arba vien kintamujų reikšmes.
Pvz. 2-3: System.out.println panaudojimas.
public class PrintlnExample { public static void main(String ARGV[]) { System.out.println("Cia demonstruojame"); System.out.println("System.out.println naudojima"); System.out.println("\nGalime spausdinti ir kintamuju reiksmes,"); System.out.println("pvz. sveiku kintamuju:\n"); int i=4; System.out.println("kintamasis i="+i); System.out.println(i); myOut("arba naudoti pervardinta\n System.out.println\n"); myOut("Naujas vardas\n myOut\n zymiai trumpesnis"); } public static void myOut(String S) { System.out.println(S); } }
Lietuviško teksto spausdinimas
Dabar pamėginsime atspausdinti lietuvišką tekstą.
Problema kyla spausdinant "ąčęėįšųūž" ir "ĄČĘĖĮŠŲŪŽ" simbolius.
Kiekvienas pavienis simbolis mūsų kompiuteryje užima 1-baitą.
Java programos turi būti rašomos char unicode 16 bitų simboliais.
Todėl Java kompiliatorius mūsų programos 1-baitinį tekstą pats konvertuoja
į unicode 16 bitų simbolių tekstą. Aišku, kad 8 bitų simbolį į 16 bitų
galima atvaizduoti 256 skirtingais būdais. Kaip konkrečiai
Java kompiliatorius tai daro kompiliatoriaus prasme nėra labai svarbu.
Jam reikia tik skirtingus 8 bitų simbolius atvaizduoti į skirtingus
16 bitų simbolius ir to pakanka, kad būtų galima toliau kompiliuoti
programą. Kaip konkrečiai pereiti nuo 8 bitų prie 16? Paprasčiausias
būdas būtų prie visų simbolių baito pridėti nulinį baitą 00.
Tačiau Java naudoja unicode
standartą (žr. http://www.unicode.org),
kuris suteikia skirtingiems skirtingų kalbų
simboliams unikalius numerius. Specifiniai Lietuvių kalbos simboliai
turi tokius numerius (numeriai užrašyti šešioliktaine sistema):
Lietuviškų simbolių kodai Unicode standarte
Kodas 104 10c 118 116 12e 160 172 16a 17d 105 10d 119 117 12f 161 173 16b 17e
Simbolis Ą Č Ę Ė Į Š Ų Ū Ž ą č ę ė į š ų ū ž
Plačiau apie tai galite paskaityti lietuviškame Unicode konsorciumo puslapyje.
Naivu tikėtis, kad Java kompiliatorius atspės kokią lietuviškų simbolių koduotės lentelę jūs naudojote renkant failą, nes tik tuomet galima teisingai pervesti 8-ių bitų lietuvišką tekstą į 16 bitų unicode standartą. Tarkime jūs failą rinkote Windows aplinkoje naudodami Windows 1257 koduotės lentelę. Ji specifiniems lietuviškiems simboliams priskiria tokius numerius:
Lietuviškų simbolių kodai Windows 1257
Kodas c0 c8 c6 cb c1 d0 d8 db de e0 e8 e6 eb e1 f0 f8 fb fe
Simbolis Ą Č Ę Ė Į Š Ų Ū Ž ą č ę ė į š ų ū ž
Tie patys simboliai DOS PC Baltic (IBM775) koduotėje turės tokius numerius:
Lietuviškų simbolių kodai DOS PC Baltic (IBM775) koduotėje
Kodas b5 b6 b7 b8 bd be c6 c7 cf d0 d1 d2 d3 d4 d5 d6 d7 d8
Simbolis Ą Č Ę Ė Į Š Ų Ū Ž ą č ę ė į š ų ū ž
Parašykime Java klasę, kuri konvertuotų Windows 1257 koduote surinktą tekstą į PC Baltic koduotę.
Pvz. 2-3aLT: Windows 1257 koduotės teksto konvertavimas į PC Baltic koduotės tekstą.
public class lt{ //Windows 1257 kodų lentele renkami lietuviški simboliai static char[] win=new char[]{'ą','č','ę','ė','į','š','ų','ū','ž','Ą','Č','Ę','Ė','Į','Š','Ų','Ū','Ž'}; //DOS PC Baltic (IBM775) kodų lentele renkami lietuviÕki simboliai static char[] dos=new char[]{'Š','Ń','Ņ','Ó','Ō','Õ','Ö','×','Ų','µ','¶','·','ø','½','¾','Ę','Ē','Ļ'}; // Pagalbiniai masyvai konvertuoti koduotėms static int[] w2d=new int[256]; static int N=win.length; static int[] w=new int[N], d=new int[N]; // Testavimui galite paleisti java lt, // kad patikrinti ar teisingai matosi ekrane abėcėlė public static final void main(String S[]){ String test="aąbcčdeęėfghiįyjklmnoprsštuųūvzž"; println(test); println(test.toUpperCase()); } // Kai bus kreipiamasi pirmą kartą init parodys, // kad reikia užpildyti perkodavimui reikalingus pagalbinius masyvus static boolean init=false; public static void init(){ for (int i=0; i<N; i++) {w[i]=(int)win[i];d[i]=(int)dos[i];} for (int i=0; i<256; i++) w2d[i]=i; for (int i=0; i<N; i++) {w2d[w[i]]=d[i]; w2d[d[i]]=w[i];} for (int i=0; i<N; i++) if (w2d[w[i]]!=d[i]) w2d[w[i]]=d[i]; init=true; } // Windows kodų lentele surinktą tekstą perkoduojame DOS kodų lentele public static String win2dos(String s){ if (!init) init(); byte[] S=s.getBytes(); int M=S.length; for (int i=0; i<M; i++) if (S[i]<0) S[i]=(byte)w2d[S[i]+256]; return new String(S); } // Naudingi metodai spausdinti lietuviškam tekstui // Spaudinant lietuvišką tekstą vietoje // System.out.println("Lietuviškas tekstas") arba // System.out.print("Lietuviškas tekstas") // galėsite rašyti // lt.println("Lietuviškas tekstas") arba // lt.print("Lietuviškas tekstas") public static void println(String S) { System.out.println(win2dos(S));} public static void print(String S) { System.out.print(win2dos(S));} } //lt
Sukompiliuokite šią programą ir jos tinkamumą savo kompiuteriui patikrinti komanda
java lt
Jei lietuviški simboliai spausdinami blogai, surinkite iš naujo win arba dos masyvus, kad jie atitiktų jūsų kompiuteryje naudojamą koduotę ir išmėginkite dar kartą lt spausdinimą. Jei testas ekrane atrodo teisingai, galite pasinaudoti lt spausdinimo klase bet kokioje kitoje Java programoje. Iliustracijai perrašysime paprasto teksto spausdinimo klasės PrintlnExample lietuviškąjį analogą.
Pvz. 2-3bLT: Lietuviškojo lt.println panaudojimas.
public class lt_printlnPavyzdys { public static void main(String ARGV[]) { lt.println("Čia demonstruojame"); lt.println("lt.println naudojimą"); lt.println("\nGalime spausdinti ir kintamųjų reikšmes,"); lt.println("pvz. sveikų kintamųjų:\n"); int i=4; lt.println("kintamasis i="+i); lt.println(""+i); } }
Mes parašėme keletą paprastų Java programėlių. Pasižiūrėkime kas iš tikrųjų yra atliekama. Tuo tikslu pakaks paanalizuoti vieną primaryClass programą, nes visose kitose naudojami tie patys privalomi pagrindiniai Java programos elementai.
Deja, negaliu pažadėti, kad po kelių puslapių viskas bus aišku, tačiau su kiekvienu nauju skyreliu programos dalių paskirtis vis labiau bus suprantama.
Visos Java programos sudarytos iš keturių pagrindinių elementų: klasių, metodų, kintamųjų ir paketų. Visiems labiausiai pažįstami turėtų būti metodai, kurie atitinka paprogrames ir funkcijas, bei kintamieji, kuriuose yra saugojami duomenys. Klasės yra akcentuoja, kad Java yra objektiškai orientuota. Pradžiai pilnai pakaks suprasti, kad klasė yra programos elementas, kuriame naudojami kintamieji ir yra apibrėžiami metodai. Paketas sudarytas iš klasių ir naudojamas nurodyti kompiliatoriui kur jas ieškoti. Kitame skyriuje susipažinsime, kad paketai naudojami apibrėžti tam tikrą hierarchiją tarp kintamųjų. Trumpai - paketas yra klasių rinkinys.
Tam tikrus elementus naudoja visos Java programos. Lenteleje pateiksime informaciją apie tai kas ir kokiuose skyriuose bus aprašyta.
| Elementas | Paskirtis | Kur aprašyta |
|---|---|---|
| Interfeisai (Interfaces | Realizuoti "polimorfizmą." | Polimorfizmai ir interfeisai aprašyti 3 skyriuje |
| Išimtys (Exceptions) | Palengvinti klaidų apdorojimą | 4 skyrius. |
| Gijos (Threads) | Naudojamos vykdyti greta skirtingas programos dalis. | Įžanga 5 skyriuje; 10-ame - detaliau. |
2-1 lentelė. Kituose skyriuose aprašomi Java elementai.
Java programoje gali būti kiek nori klasių, bet viena praginos prasme yra išskirtinė. Ji visuomet yra pirma, nuo kurios pradeda dirbti praginos programa. 2-1 pavyzdyje ši klasė vadinosi OurPrimaryClass. Šioje klasėje turi buti vienas ar keli metodai atliekantys juose aprašytus veiksmus.
Kai paleidžiame programą iš komandinės eilutės, būtina apibrėžti metodą main. Kiek vėliau parašysime įskiepio programėlę. Įskiepiams main metodas nebūtinas, tačiau reikalingi kiti metodai; apie tai vėliau.
Dabar kiek plačiau apie kintamuosius, metodus, klases ir paketus.
Neabejoju, kad kintamuosius jau naudojote ir kitose programavimo kalbose. Kintamieji tai dėžutės į kurias galima sudėti ir saugoti duomenis. Kintamojo tipas nurodo kokios rūšies duomenis galima saugoti kintamajame. Pvz. int tipo kintamajame saugojami sveikieji skaičiai. Pasižiūrėkime į int tipo kintamojo panaudojimo pavyzdį: 2-4 pvz. Kintamojo panaudojimas.
public class UsesInt { public static void main(String S[]) { int i=4; System.out.println("Kintamojo i reiksme: i="+i); } }
Čia buvo panaudotas priskyrimo operatorius "=" , kuris i priskyrė reikšmę 4. Šią reikšmę atspausdinome su System.out.println. int kintamųjų tipas priklauso vienai iš dviejų pagrindinių grupių, vadinamai Java pirminiais tipais (primitive types). Kita pagrindinė kintamūjų grupė vadinama nuorodomis. Šiai grupei priklauso programoje apibrėžti tipai, masyvai. Pirminių tipų kintamieji naudojami saugoti skaičius, pavienias raides, loginias (ture/false) reikšmes. Nuorodos skiriasi tuo, kad jos yra dinaminės. Pagrindiniai skirtumai tarp šių kintamųjų tipų grupių nurodyti pateikiamoje lenteleje.
| Charakteristika | Pirminis tipas | Nuorodos tipas |
|---|---|---|
| Ar apibrįžtas Java kalboje? | Taip | Ne |
| Ar iš anksto žinomas reikalingas atminties kiekis? | Taip | Ne |
| Ar atmintis išskiriama kintamajam praginos metu | Ne | Taip |
2-2 lentelė. Pirminių ir nuorodų tipų palyginimas.
Pirminiai ir nuorodų kintamieji taip pat skiriasi ir jų reikšmių
perdavimo metodų parametrams būdu.
Pirminių perduodama reikšmė, o nuorodų - nuoroda,
t.y. pirminių kintamųjų yra padaromos kopijos ir metodo viduje yra naudojama
kopija, o nuoroda naudojama tiesiogiai ir todėl metodo viduje
keičiamas nuorodos kintamojo turinys keičiasi ir išorėje. Smulkiau
apie tai aprašysime "Metodų" skyrelyje.
2-2 lentelėje pažymima, kad pirminiams kintamiesiems atmintis išskiriama iš karto praginos metu. Nuorodoms pirma reikia nurodyti, kiek jiems išskirti atminties ir tik po to išskirtos atminties rėmuose galima jais naudotis. Pasižiūrėkime pavyzdį: // ženklas žymi komentarų pradžia.
2-5 pavyzdys. Pirminiai ir nuorodų kintamieji.
public class Variables { public static void main(String ARGV[]) { int myPrimitive; //pirminio tipo kintamasis int myReference[]; //nuorodos tipo kintamasis myPrimitive=1; //primityviam galime iš karto kažką priskirti myReference=new int[3]; //o nuorodai pirma reikia išskirti atminties, kad vėliau ką nors priskirti myReference[0]=0; myReference[1]=1; myReference[2]=2; } }
Pirminių kintamųjų atveju praginos terpė žino kiek tiksliai reikia iškirti kintamajam atminties, pvz. sveikajam skaičiui myPrimitive reikia 4 baitų. Tačiau sveikųjų skaičių masyvui iš anksto neaišku kiek reikia išskirti atminties ir todėl myReference kintamajam reikia papildomos komandos new int[3], kuri nurodo, kad šiuo atveju mums reikės masyvo iš 3-ų sveikųjų skaičių. Taigi nuorodų kintamiesiems atmintis taip pat išskiriama praginos metu, tik skirtumas tas, kad reikiamos atminties kiekis iš anksto nežinomas ir tam naudojamas new operatorius.
Pažymėsime, kad nuorodų kintamieji tik nurodo atminties vietą, kurioje talpinami kintamieji (pvz. masyvo elementai), o pirminiai kintamieji naudoja fiksuoto dydžio atminties fragmentus. Nuorodos primena C/C++ rodykles, tačiau tarp šių sąvokų yra ir skirtumų. Nuorodos nenaudoja atminties adresų aritmetikos ir negalima sužinoti koks tiksliai fizinis adresas išskirtas nuorodai. Tai padaryta vardan Java programų naudojimo saugumo.
Pirminiai tipai
Su vienu pirminio tipo kintamuoju mes jau susipažinome, tai int tipas. Java kalboje viso yra 8 pirminiai tipai; jie išvardinti 2-3 lentelėje.
| Tipas | Dydis | Kitimo ribos | Reikšmių pavyzdžiai |
|---|---|---|---|
| int | 4 baitai | nuo -2147483648 iki 2147483648 | 2003, -2003 |
| short | 2 baitai | nuo -32768 iki 32767 | 1999, -1999 |
| byte | 1 baitas | nuo -128 iki 127 | 100,-100 |
| long | 8 baitai | nuo -922372036854775808 iki 922372036854775807 | 1000000000, -1000000000 |
| float | 4 baitai | priklauso nuo tikslumo | 3.142 |
| double | 8 baitai | priklauso nuo tikslumo | 3.141592654 |
| boolean | 1 bitas | true, false | true, false |
| char | 2 baitai | visi unicode simboliai | |
2-3 lentelė. Java kalbos pirminiai tipai.
Pirmi šeši pirminiai tipai skirti skaitinėms reikšmėms. Su šiais kintamaisiais galite atlikti aritmetines operacijas: +, -, * ir /, t.y. du pirminių tipų kintamuosius galima sudėti, atimti, padauginti ir padalinti. 4 skyriuje aiškinsimės šių operacijų detales, pvz. kas atsitinkas, kai sudėsime du skirtingų tipų pirminius skaičius. Žinantiems nesunku pastebėti, kad naudojami žymėjimai sutampa su C kalbos analogiškais aritmetinių operacijų žymėjimais. Tačiau boolean (loginio) tipo kintamasis kiek skiriasi nuo C kalbos analogo. Java kalboje loginiam kintamajam reikšmės priskiriamos taip:
2-6 pavyzdys. Reikšmių priskyrimas boolean tipo kintamajam.
boolean truth=true; System.out.println(truth); boolean fallacy=false; System.out.println(fallacy); truth=(1==1); fallacy=(1==0); System.out.println(truth); System.out.println(fallacy);
Patalpinę šį kodą į 2-1 pavyzdį, kompiuterio ekrane gausime tokį rezultatą:
true false true false
Taigi boolean kintamajam galima priskirti skaičių palyginimų reikšmes. Čia vėl !, != ir == operatoriai žymi tas pačias logines operacijas kaip ir C kalboje. Kitas detales pasiaiškinsime 4 skyriuje.
Panaudotame 2-1 pavyzdyje mes pateikėme tik Java programos kodo
fragmentą. Taip dažnai darysime ir toliau, nes smulkūs fragmentai
pasimestų tarp java kalbos standarto reikalaujamų elementų ir
todėl metodiniais tikslais kartais geriau parašyti tik esminį programos
fragmentą, skirtą iliustruoti aptariamam Java kalbos elementui.
Nuorodų tipas
Kaip jau buvo sakyta nuorodų tipo kintamieji skiriasi nuo pirminių tipų kintamųjų. Pvz. atminties atžvilgiu visi pirminiai kintamieji užima iš anksto žinomą fiksuotos apimties dalį (pvz. int 4 baitus), o nuorodos gali pareikalauti įvairios apimties atminties. Masyvai yra standartinis nuorodos tipo kintamųjų pavyzdys. Masyvo elementais gali būti visų Java kalboje vartojamų tipų kintamieji. Sakydami "visų" turime omeny visus aštuonis pirminius tipus ir iš anksto nežinomo kiekio vartotojo sukurtus tipus.
Aprašant nuorodas mums reikės naujo termino. Kai nuorodos tipo kintamajam su new operatoriumi išskiriame vietos atmintyje, sakome, kad turime nuorodos tipo kintamojo ekzempliorių arba objektą. Jei tam pačiam nuorodos tipo kintamajam panaudosime dar kartą new operatorių, gausime jo naują ekzempliorių.
Koks skirtumas tarp nuorodos kintamojo, sakykime, myReference užrašyto
int[] myReference;
ir vėliau toje pačioje programoje apibrėžiamo myReference ekzemplioriaus
myReference = new int[3];
Pirmu atveju programa tik paskelbė, kad bus naudojamas myReference nuorodos į sveikųjų skaičių masyvą kintamasis, bet jo elementams nieko negalima priskirti, nes Java praginos terpė nežino kiek konkrečiai bus masyvo elementų ir todėl jiems iš viso kol kas neišskyrė atminties. Kai myReference tampa ekzemplioriumi, t.y. jam buvo iškirtas su new operatoriumi prašomas atminties kiekis, myReference elementams galima priskirti reikšmes, galima su jais atlikti aritmetines operacijas ir t.t.
Atėjo laikas susipažinti su programuotojo apibrėžiamais tipais.
Programuotojo apibrėžiami tipai.
C kalboje tipai apibrėžiami struct konstrukcija, Paskalyje - su records. Java kalboje nauji tipai apibrėžiami su class arba interface. Su pastaruoju susipažinsime kitame skyriuje, o dabar aprašysime class tipo nuorodas.
Class primena jau minėtas struct ir record, kuriose galima saugoti duomenų grupes. Tačiau klasėms priklauso ir jose aprašomi metodai. Sakykime galime apibrėžti "MyType" klasę, kuri bus paskelbta public. Šis modifikatorius pažymi, kad naujai paskelbtas tipas MyType yra viešas, t.y. prieinamas kitom klasėm. Kiek vėliau apie klasės galimus modifikatorius pakalbėsime plačiau.
2-7a pavyzdys. Tipo apibrėžimas.
class MyType { public int myDataMember=4; public void myMethodMember() { System.out.println("As esu svarbus narys!"); System.out.println("myData="+myDataMember);} }
Iš pateikto pavyzdžio matyti, kad tipo aprašymas praktiškai sutampa su Java programa. Taip ir yra, tipo aprašymas ir yra Java programa, tik joje nebūtina realizuoti main ar init metodų, nuo kurių pradedama vykdyti komandine eilute arba naršykle paleidžiamos Java programos ar įskiepiai.
Klasių tipo inicijuoti kintamieji vadinami objektais arba ekzemplioriais. Kaip ir masyvų atveju, klasės kintamasis tampa ekzemplioriumi, kai jam išskiriama vieta atmintyje naudojant new operatorių. Klasės elementai žymimi per tašką "."
2-7b pvz. Objekto inicijacija (instantination).
public class RunMe { public static void main(String ARGII[]) { MyType Mine=new MyType(); int i=Mine.myDataMember; Mine.myMethodMember(); } }
2-7 pavyzdys iliustruoja tris darbo su myType klase elementus, t.y. sukūrimą, pasinaudojimą ekzemplioriaus kintamaisiais ir ekzemplioriaus metodais. myMethodMember metodas atspausdins:
As esu svarbus narys! myData=4
Kadangi myDataType yra nuorodos tipo, reikia naudoti new operatorių, kuris išskiria ekzemplioriui vietą atmintyje. Po new yra nurodomas klasės konstruktoriaus pavadinimas, kuris turi sutapti su klasės pavadinimu. Konstruktorius gali atlikti kokius nori veiksmus; pateiksime myType konstruktoriaus pavyzdį, kuris praneša apie savo sukūrimą.
2-8a pavyzdys. Apie inicijavimą pranešantis konstruktorius.
Aišku konstruktorius gali priskirti klasės kintamiesiems reikšmes.public class MyType { int myDataMember=0; public MyType() { System.out.println("Esu inicijuojamas!");} }
2-8b pavyzdys. Konstruktorius kuris priskiria klasės kintamiesiems reikšmes.
public MyType(int val) { System.out.println("Priskiriu myDataMember="+val); myDataMember=val;}
Tarkime programoje yra realizuoti abu konstruktoriai ir jais pasinaudokime.
2-8c pavyzdys. Programa naudojanti abu konstruktorius.
public class RunMe { public static void main(String ARGV[]) { MyType instancel=new MyType(); MyType instance2=new MyType(100); } }
Rezultatas turėtų būti:
Esu inicijuojamas!! As esu svarbus narys! myDataType=4 Priskiriu myDataType=100 As esu svarbus narys! myDataType=100
String tipas
Mes aptarėme Java kalbos pirminius ir programuotojo apibrėžiamus tipus. Java kalboje yra dar vienas tipas - String, kuris turi abiejų tipų bruožus. String tipą galima laikyti programuotojo apibrėžtu, nes jis aprašomas String klase ir jame yra kintamieji ir metodai. Tačiau eilutės (String) tipo kintamajam reikšmių priskyrimas nenaudoja new operatoriaus:
String myString="Sveikas!";
"Na ir kas čia tokio?" - galima savęs paklausti, juk tai pats natūraliausias būdas priskirti eilutės kintamajam tekstinę reikšmę. String tipo kintamuosius, kaip ir pirminius, galima sudėti, tačiau atimti, dauginti ir dalinti negalima.
int myInt=4; String anotherString=myString+"myInt yra "+myInt;
anotherString reikšmė bus "Sveikas! myInt yra 4". Tačiau kadangi anotherString yra objektas, jo elemntais galime manipuliuoti naudodami String clasės metodus. Pavyzdžiui išskirsime pirmuosius aštuonis simbolius:
String helloString=anotherString.substring(8);
Taigi String atveju Java kalbos kanonai pažeidžiami, nes inicijavimas atliekamas nenaudojant new operatoriaus. Tai padaryta sąmoningai, nes eilutės yra vienas dažniausiai naudojamų bet kokioje programavimo kalboje elementų ir norisi, kad darbas su eilutėmis būtų kuo paprastesnis. Tačiau antra vertu programuotojo atžvilgiu kiek nekorektiška keisti žaidimo taisykles leidžiant klasei String inicijavimo metu nenaudoti new operatoriaus.
Array (masyvo) tipai
Array tipai apibrėžia sutvarkytą vienatipių elementų masyvą. Masyvo elementais gali būti visi pirminiai tipai ir visi programuotojo apibrėžti tipai. Galima apibrėžti masyvą masyvų, masyvą masyvų masyvą ir taip toliau. 4 skyriuje "Sintaksė ir Semantika" apie tai pakalbėsime plačiau. Pakanka atsiimnti bendrą taisyklę - jei galime sukurti kokį nors tipą, tai galime sukurti ir masyvą su to tipo elementais. Neturėtų būti keista, kad paskelbiant naują masyvo ekzempliorių Java kalboje reikia naudoti new operatorių, nors daugelyje kitų programavimo kalbų new su masyvais yra nenaudojamas.
2-9a pavyzdys. Atminties išskyrimas masyvams.
int myIntArray[]; myIntArray=new int[3]; myType myObjectArray[]; myObjectArray=new myType[3];
New operatorius praginai nurodo, kad reikia masyvo kintamajam išskirti tam tikrą kiekį atminties. Pastebėkime, kad masyvo tipo kintamojo paskelbimo metu nebūtina nurodyti kiek bus masyvo elementų. Tačiau yra nedraudžiama paskelbti naują masyvo kintamąjį ir iš karto pratęsti kintamojo aprašymą nurodant su new operatoriumi kokio dydžio masyvas reikalingas. Sukūrus masyvo ekzempliorių toliau jo naudojimas sutampa su C ir Paskalio kalbose naudojama sintakse.
2-9b pavyzdys. Reikšmių priskyrimas masyvo elementams
myIntArray[0]=0; myIntArray[1]=1; myIntArray[2]=2; myObjectArray[0]=new myType(); myObjectArray[1]=new myType(); myObjectArray[2]=new myType(); myObjectArray[0].myDataMember=0; myObjectArray[1].myDataMember=1; myObjectArray[2].myDataMember=2;
Java masyvai lyginant su kitų kalbų masyvais turi privalumų. Masyvo kintamųjų paskelbimo metu nebūtina nurodyti jų dydžio. Java masyvas yra visuomet kintamasis ir todėl jį galima perduoti parametru ir gauti jo grįžtamąją reikšmę. Ir pagaliau nesunku sužinoti masyvo dydį, t.y. kiek elementų yra masyve:
2-9cpavyzdys. Masyvo dydžio sužinojimas.
int len=myIntArray.length; System.out.println("myIntArray dydis (ilgis) yra "+len);
Metodai iš esmės yra C ir Paskalio kalbų paprogramių analogai. Metodai gali grąžinti kokio nors tipo kintamąjį ir naudoti visų tipų kintamuosius parametrais.
Iliustracijos paprastumui visus metodus apibrėšime statiniais. Statiniai metodai yra nekintantys metodai ir jų panaudojimas yra kiek paprastesnis, plačiau apie tai vėliau.
Susipažinkime su metodo apibrėžimo sintakse. Pirma rašomas metodo modifikatorius (dinaminis modifikatorius yra nutylimasis ir yra praleidžiamas, t.y. static reikia rašyti, o dinamic - niekada nerašoma). Toliau užrašomas grįžties tipas, metodo pavadinimas ir parametrų sąrašas. Metodo kamienas (body) rašomas tarp riestinių skliaustų.
<metodo_modifikatorius> grįžties_tipas metodo_vardas (<parameters>) { metodo kamienas }
Metodo kamiene apibrėžiami kintamieji, užrašomi operatoriai. Skirtingai nuo C kalbos, kintamieji apibrėžiami bet kurioje kamieno dalyje (aišku, anksčiau, nei pirmasis kintamojo panaudojimas).
Pirma susipažinsime su metodo grįžties tipu, toliau pakalbėsime apie parametrus ir apie metodo perkrovą, leidžiančią naudoti tą patį vardą su skirtingais parametrų sąrašais.
Grįžties tipas
Visi metodai privalo nurodyti grįžties tipą. Jei nereikia grąžinti nieko, privalote nurodyti void grįžties tipą. void tipo metodai analogiški Paskalio procedūroms. Jei metodas nėra void tipo, jame turi būti return operatorius, nurodantis kokį kintamąjį grąžinti. Pateiksime ir vienos ir kitos metodų rūšies pavyzdžių.
2-10 pavyzdys. Metodų iškvietimas.
public class MethodExamples{ static void voidMethod() { System.out.println("As esu nieko negrazinantis metodas :("); } static int returnInt() { int i=4; System.out.println("returning 4"); return i;} static public final void main(String S[]) { System.out.println("Sveiki, metodai!"); System.out.println("Kvieciu void tipo metoda"); voidMethod(); int ans=returnInt(); System.out.print("Metodas sako -"); System.out.println(ans); } }
Metodų iškvietimas mažai skiriasi nuo procedūrų ir funkcijų panaudojimo ne objektiškai orientuotose programavimo kalbose. Taip yra, kai statinis metodas kamiene naudoja kitus statinius metodus arba, kai dinaminis metodas naudoja kitus tos pačios klasės dinaminius metodus. Reikalas susikomplikuoja, kai dinaminis metodas kviečia statinį ir atvirkščiai.
Dabar pakalbėkime apie parametrų perdavimą.
Parametrų perdavimas
Parametrais gali būti visų tipų kintamieji, tame tarpe apibrėžti klasėse ir masyvai. Tačiau pirminių tipų ir nuorodų tipų parametrai perduodami skirtingai. pradėsime nuo paprastesnių - pirminių tipų parametrų perdavimo.
Visi pirminiai kintamieji perduodami savo reikšme. Tai reiškia, kad prieš darant perdavimą, yra pasidaroma kintamojo kopija ir perduodama kopijos reikšmė. Tai reiškia jog jei metodo viduje yra keičiama parametro reikšmė, tai po grįžties parametro reikšmė nepakinta, nes metodo viduje yra manipuliuojama su kintamojo kopija. Iliustruokime tai pavyzdžiu.
2-11 pavyzdys. Pirminių kintamųjų panaudojimas parametrais.
class ParameterExample { static int addFour(int i) { i=i+4; System.out.println("Vietine kopija: i="+i); return i;} public final static void main(String S[]) { System.out.println("Sveikas, parametru siuntejau!"); int i=10; System.out.print("Pradinė reiksme: i="+i); int j=addFour(i); System.out.println("Tarpine reiksme: j="+j); System.out.println("Einamoji reiksme: i="+i); } }
Po praginos gausime tokį rezultatą:
Sveikas, parametru siuntejau! Pradinė reiksme: i=10 Tarpine reiksme: j=14 Einamoji reiksme: i=10
Taigi i reikšmė nepakito, nors addFour metode prie jos buvo pridėta 4. Tu tarpu nuorodų reikšmės, jei jos tik buvo keičiamos metodo viduje, po grįžties pakinta. Pasižiūrėkime pavyzdį su sveikųjų skaičių masyvu.
2-12 pavyzdys. Nuorodų panaudojimas parametrais.
public class ReferenceParameterExample { static void changeArray(int referencellariable[]) { referencellariable[2]=100;} public static void main(String ARGV[]){ int anArray[]=new int[3]; anArray[2]=10; System.out.println("anArray[2]="+anArray[2]); changeArray(anArray); System.out.println("anArray[2]="+anArray[2]); }
Programos darbo rezultatas bus toks:
anArray[2]=10 anArray[2]=100
Rezultatas turėtų būti suprantamas, nes parametru perduodame nuorodą ir metodo viduje atliekami pakeitimai tiesiogiai atsiliepia nuoroda pažymėtiems kintamiesiems. Trumpai tariant, kadangi yra nedaromos nuorodos ir ja nurodytos atminties dalies kopijos, tai metodas dirba su ta pačia atminties dalimi ir visi pakeitimai atsispindi grįžtyje.
Metodų perkrova
Ar jums kada nors teko rašyti paprogrames, kurios iš esmės atlieka tuos pačius veiksmus, tik skiriasi pradinių parametrų forma. Java leidžia naudoti tą patį metodo pavadinimą, kai metodai skiriasi naudojamų parametrų sąrašu. Tarkime turime metodą, kuris palygina du sveikuosius skaičius.
2-13a pavyzdys. Dviejų skaičių palyginimas.
public static String compareNums(int i, int j) { if (i==j) { return "Skaiciai "+i+" ir "+j+" sutampa";} if (i>j) { return "Skaicius "+i+" didesnis uz "+j;} return "Skaicius "+j+" didesnis uz "+i; }
Dabar tarkime užsimanėme palyginti tris skaičius. Būtų nelogiška naudoti naują metodo pavadinimą, nes jo esmė išlieka ta pati - palyginti skaičius ir užrašyti teksto forma rezultatą į grąžinamą eilutę. Taigi naudokimės Java objektinio teikiamu privalumu klasės paveldėti anksčiau parašytos klasės kintamuosius ir metodus.
2-13b pavyzdys. Metodų perkrova naudojant skirtingus parametrų sąrašus.
public static String compareNums(int i, int j, int k){ String S=compareNums(i,j); S=S+"\n", S=S+compareNums(i,k); return S;}
Jei parametrų sąrašas skiriasi, leidžiama metodą perkrauti kiek tik norima kartų. Aišku, jei parametrų kiekis dviejuose sąrašuose skirtingas, tai tokie sąrašai laikomi skirtingais. Sąrašai laikomi taip pat skirtingais, jei jų kiekis sutampa, tačiau lyginant eilės tvarka skiriasi bent vienoje pozicijoje parametrų tipai. Pailiustruokime tai pavyzdžiu.
2-13c pavyzdys. Metodo perkrova su skirtingų tipų parametrais.
public static String compareNums(double i, double j) { if (i==j) { return "Skaiciai "+i+" ir "+j+" sutampa";} if (i>j) { return "Skaicius "+i+" didesnis uz "+j;} return "Skaicius "+j+" didesnis uz "+i; }
Metodo perkrovos privalumas pasireiškia jų naudojime. Žymiai paprasčiau prisiminti vieną logišką metodo pavadinimą ir jį naudoti su skirtingų tipų parametrais, nei aibei skirtingų tipų rinkinių sugalvoti skirtingus metodo pavadinimus ir vėliau kankintis prisimenant tuos pavadinimus. Aišku perkrova kiek apsunkina kompiliatoriaus darbą, bet kompiliatoriaus pagrindinė paskirtis ir yra atlikti juodą darbą lengvinant programuotojo gyvenimą.
2-13d pavyzdys. Perkrovos metodo iškvietimas.
public static void main(String ARGV[]) { int a=3; int b=4; int c=5; double d=3.3; double e=4.4; String S=compareNums(a,b); System.out.println(S); S=compareNums(a,b,c); System.out.println(S); S=compareNums(d,e,f); System.out.println(S); }
Pagaliau galime grąžinti skolą aptariant anksčiau skūpiai išaiškintas klasių apibrėžimo detales. Anksčiau mes sakėme, kad klasėje yra talpinami kintamieji ir metodai. Tai yra tiesa, tačiau klasė yra Java objektinės orientacijos pagrindas ir pamėginkime sudėti reikiamus akcentus, pabrėžiančius klasės objektinę orientaciją.
Statinių ir dinaminių narių palyginimas.
Taigi ką pažymi statinis modifikatorius. Kol kas mes jį naudojome metodų kontekste, todėl nuo jų ir pradėsime. Statiniais gali būti paskelbti ir klasės kintamieji; apie tai pakalbėsime kiek vėliau.
Daugeliu atvejų apibrėždami metodus mes nevartojome modifikatoriaus static. Šiuo atveju metodas interpretuojamas dinaminiu. Dinaminis yra nutylimoji reikšmė ir jokio modifikatoriaus nereikia rašyti, nes Java kalboje raktinis žodis "dynamic" nevartojamas. Dinaminiai metodai ir kintamieji vizualiai aiškiai skiriasi nuo savo statinių analogų panaudojimo sintakse. Statiniai metodai ir kintamieji kviečiami tiesiog rašant pastovų klasės pavadinimą, kurioje yra apibrėžtas kviečiamas metodas ar kintamasis. Dinaminis metodas ir kintamasis kviečiamas naudojant klasės ekzemplioriaus pavadinimą. Kadangi ta pati klasė gali turėti daug ekzempliorių skirtingais pavadinimais, tai ir to paties metodo ar kintamojo kvietimai atrodys skirtingai. Lentelėje 2-4 pateikiamas platesnis statinio ir dinaminio modifikatoriaus palyginimas.
| Metodo tipas | Modifikatorius | Sintaksė |
|---|---|---|
| Dinaminis | Nerašomas (nutylimas dinaminis) | <objektas>.<metodo_vardas> (<parametrų sąrašas>) |
| Statinis | static | <clasės_vardas>.<metodo_vardas> (<parametrų_sąrašas>) |
2-4 lentelė. Dinaminių ir statinių metodų sintaksės palyginimas.
Pailiustruo tai pavyzdžiu.
2-14a pavyzdys. Statinių ir dinaminių metodų palyginimas.
public class StaticVsDynamic { int i=0; public static void staticMethod(int j) { System.out.println("Statinis metodas"); System.out.println("j="+j); } //dinaminis metodas public void setInt(int k) { i=k; System.out.println("Priskiriame i reiksme "+k); } public int returnInt() { return i;} }
Pavyzdžio klasėje apibrėžiamas ir statinis ir dinaminis metodai. Statinis metodas "nežino" apie setInt, returnInt ir i reikšmes. Pasižiūrėkime kaip atrodo dinaminio ir statinio metodo panaudojimas.
2-14b pavyzdys. Dinaminio ir statinio metodo iškvietimas.
public class RunMe { public static void main(String S[]) { int i=0; StaticVsDynamic.staticMethod(10); //nereikia naudoti konstruktoriaus iškviečiant statinį metodą StaticVsDynamic A=new StaticVsDynamic(); //prieš kviečiant dinaminį metodą pirma jį reikia inicijuoti A.setInt(20); System.out.println("A.i = "+A.returnInt()); } }
Statinis modifikatorius naudojamas ir klasės kintamiesiems. Statinių kintamųjų iškvietimo sintaksė analogiška statinių metodų iškvietimui.
<klasės_vardas>.<kintamojo_vardas>
Kadangi visi kintamieji ir metodai turi būti apibrėžti klasėje, statinis modifikatorius pažymi tuos metodus ir kintamuosius, kurie nepriklauso nuo ekzemplioriaus. Todėl kuriant naują ekzempliorių neišskiriama nauja vieta statiniams klasės metodams ir kintamiesiems ir jie visi prieinami pagal fiksuotą klasės pavadinimą. Statiniai kintamieji analogiški kitose kalbose naudojamiems global kintamiesiems, skirtumas tik tas, kad jie prieinami tik žinant ir panaudojant klasės pavadinimą. Tai yra Java kalbos privalumas, nes nereikia jaudintis, kad kažkokioje programoje koks nors global kintamojo vardas jau buvo panaudotas ir skirtingos esmės kelių kintamųjų pavadinimas vienu vardu iškels sunkiai aptinkamos programavimo klaidos problemą.
Klasės narių panaudojimas
Java kalboje galima kontroliuoti klasės narių panaudojimą. Kol kas visi nariai buvo vieši (public). Šis modifikatorius pažymi, kad klasės metodas ar kintamasis yra "demokratiškas" ir juo gali naudotis toje pačioje ir kitose klasėse laisvai. 2-5 lentelė aprašo kitas public alternatyvas.
| Modifikatorius | Aprašymas |
|---|---|
| Private | Narys pasiekiamas tik klasės viduje. |
| (Nutylimas) | Narys pasiekiamas toms paketo klasėms, kurios nepraplečia šią klasę. |
| Protected | Narys pasiekiamas paketo klasėms. |
| Public | Narys pasiekiamas kitoms klasėms. |
2-5 lentelė. Panaudojimo modifikatorius.
Lentelėje modifikatoriai išvardinti apribojimų mažėjimo tvarka. Java versijoje 1.02 buvo pasirodęs penktas private protected modifikatorius, tačiau jo dėl dviprasmybių Java kūrėjai vėlesnėse versijose atsisakė. Panaudojimo modifikatorius leidžia programuotojui apsaugoti savo klasę nuo vartotojo neapgalvotų veiksmų. Gerai apgalvoti modifikatorių reikšmes naudinga ir pačiam programuotojui, nes grįžus po ilgesnės pertraukos prie klasės redagavimo užsimiršta detalės ir galima padaryti sunkiai aptinkamą klaidą neatsargiai pakeitus kokio nors kintamojo reikšmę. Antra vertus private modifikatoriumi neverta piktnaudžiauti, nes jis mažina jūsų klasės panaudojimo lankstumą.
Tokia metodų ir kintamųjų panaudojimo valdymo konsepcija vadinama "duomenų maskavimu" ( angl. data hiding). Iliustruokime duomenų panaudojimo valdymą paprastu pavyzdžiu. Tarkime klasė skirta aprašyti kiek parduotuvė surinko pinigų ir kiek buvo atėję klientų. Aišku šie kintamieji saugumo prasme yra gana svarbūs ir juos aprašydami išnaudokime Java kalbos teikiamas "duomenų maskavimo" galimybes.
2-15 pavyzdys. Privatūs ir viešieji klasių nariai.
public class SaleProcessor { private int Revenue=0; private int numSales=0; public void recordSale(int newRevenue){ Revenue=Revenue+newRevenue; numSales=numSales+1;} public int getRevenue() { return Revenue;} public int getNumSales() { return numSales;} }
Kiekvieno pirkimo metu bus iškviestas ringUpCustomer metodas, kuris padidins nurodytu kiekiu surinktų pinigų sumą ir padidins vienetu parduotuvės klientų skaitiklį. Revenue ir numSales kintamųjų private modifikatorius apsaugoja nuo nesankcionuoto šių kintamųjų pakeitimo.
Klasių paveldėjimas Inheritance
Kintamų panaudojimo valdymas suvaržo jūsų klasės panaudojimą. Objektiniame programavime plačiai naudojamas paveldimumas inheritance, kuris yra vienas pagrindinių šios pragramavimo paradigmos privalumų. Pažymėti, kad naujai rašoma klasė turi paveldėti visus anksčiau parašytos klasės kintamuosius ir metodus, rašomas Java kalbos raktinis žodis extends ir praplečiamos klasės pavadinimas.
Grįžkime prie saleProcessor klasės, kurią apibrėžėme 2-15 pavyzdyje. Tarkime šefui jūsų programa labai patiko, tačiau jis užsimanė, kad būtų atskirai skaičiuojami 1, 5 ir 10 vertės banknotais surinkti pinigai. Sunku pasakyti, kodėl jam nešovė į galvą skaičiuoti 100 ar 500 banknotus, tikriausiai dėl to jis ir yra šefas, o jūs - programuotojas. Kiek pamąstę suprasite, kad neverta programą perrašinėti nuo pradžios; gal būt greitai ateis naujas šefas, kuris pasakys - "man neįdomūs 1, 5 ir 10 banknotai, bet noriu žinoti kiek surinkote 100 ir 500 banknotais". Todėl praplėskime jau parašytą klasę, o atėjus naujam šefui tą pačią pradinę praplėsime dar viena klase.
2-16 pavyzdys. Paveldimumas.
class CashRegister extends SaleProcessor{ private int Ones=0; private int Fives=0; private int Tens=0; CashRegister(int startOnes, int startFives, int startTens) { Ones=startOnes; Fives=startFives; Tens=startTens;} public void sellToCustomer(int newOnes, int newFives, int newTens) { int thisSum=0; Ones=Ones+newOnes; thisSum=newOnes; Fives=Fives+newFives; thisSum=thisSum+(newFives*5); Tens=Tens+newTens; thisSum=thisSum+(newTens*10); recordSale(thisSum); } public int numOnes() {return Ones;} public int numFives() {return Fives;} public int numTens() {return Tens;} }
Kadangi mes praplėtėme saleProcessor klasę, mums nereikėjo perrašinėti jos iš naujo ir pasinaudojome jau aprašytais metodais ir kintamaisiais. Tai yra vienas pagrindinių objektinio programavimo privalumų.
Su Java programavimo pradmenimis jau susipažinome. Dabar aišku, kad klasės yra Java programavimo pagrindinis elementas. Java klases galima apjungti į vieną grupę, vadinamą paketu. Paketo sąvoka jau buvo iškilusi kalbant apie metodų ir kintamųjų panaudojimo valdymą. Protected modifikatorius pasidaro prasmingas tuomet, kai klasė įtraukiama į kokį nors paketą. Tuomet protected paskelbti kintamieji ir metodai tampa public tipo pakete apjungtoms klasėms. Aišku, kad į vieną paketą tikslinga įtraukti giminingos paskirties programas.
Paketai labai praverčia kompiliatoriui. Kaip kompiliatorius suranda kokių klasių kodus reikia įtraukti jūsų klasę kompiliavimo metu? Pavyzdžiui, mes ne kartą naudojome System.out.println metodą. System yra klasė patalpinta java.lang pakete. java.lang paketas yra išskirtinis ta prasme, kad kompiliatoriui jo nurodyti nereikia, nes laikoma, kad šis paketas yra tiek svarbus, kad jį pagal nutylėjimą naudoja visos programuotojų rašomos klasės. Pirmojoje Java programoje naudojome Date klasę. Kad kompiliatorius rastų šią klasę, savo programos pradžioje parašėme
import java.util.*;
Dabar nesunku suprasti, kad Date klasė yra patalpinta java.util pakete. Žvaigždutė pažymi, kad reikia importuoti visas java.util paketo klases. plačiau apie šį ir kitus paketus kalbėsime 6 skyriuje: "Programavimo interfeiso suvokimas". Java kompiliatorius pats sugrupuoja visas einamajame kompiliuojamos klasės kataloge esančias programas į vieną paketą ir importuoja jį. Rašant klases tai patogu, nes kuriant bent kiek sudėtingesnę programą kyla noras ją išskaidyti į atskiras dalis, kurias natūralu laikyti viename kataloge. Nėra jokios problemos nurodyti tiksliai, kokią mums klasę reikia importuoti, jei tik žinome paketo vardą, kuriame patalpinta importuojama klasė.
2-17 pavyzdys. Paketo pavyzdys.
package simplePackage; class SimpleClass1 { public void pubMethod() { System.out.println("Cia viesas (public) metodas");} protected void protectedMethod() { System.out.println("Cia apsaugats (protected) metodas");} }
Mūsų klasė simpleClassl yra patalpinama simplePackage pakete. Galime ir kitas klases patalpinti į šį paketą pradėdadi klasę operatoriumi "package simplePackage;". Kitos simplePackage klasės galės naudotis protectedMethod metodu, tačiau ne simplePackage paketo klasės to negalės daryti.
Artėja laikas susipažinti su Java kalbos perlu - įskiepiais (Applets). Tačiau pirma kiek pasigilinkime į Java praginos terpės (runtime environment) savybes. Java programos atliekamos virtualiojoje mašinoje. Rašydami Java programas jūs rašote jas Java virtualiajai mašinai. Tai yra vienas iš esminių Java kalbos bruožų skiriantis ją nuo kitų programavimo kalbų. Virtualiosios mašinos konsepcija realizuoja Java nepriklausomumą nuo kompiuterio platformos. Kadangi Java virtualioji mašina yra viena ir ta pati visiems programuotojams, tai ir Java programas visi rašo nepriklausomai nuo kompiuterių ir jų programinės įrangos ypatybių. Java praginos terpė nutiesia tiltą tarp virtualiosios Java mašinos ir konkrečios platformos. Todėl pravartu kiek plačiau susipažinti su praginos ypatybėmis.
Java yra pusiau kompiluojama. Skirtingai nuo kompiliuotų kitų programavimo kalbų failų, Java kompiliuotas failas negali būti tiesiogiai vykdomas kompiuteriu. Java sukompiliuotas failas yra vykdomas praginos terpėje. Iš čia išplaukia svarbi išvada: Java sukompiliuotą failą galite pernešti iš vienos platformos kompiuterio į kitos platformos kompiuterį; ir viename ir kitame kompiuteryje tą pačią Java sukompiliuotą programą Java praginos terpė galės sėkmingai vykdyti.
*.class faile yra taip vadinamas baitinis kodas (bytecodes). Baitiniame kode užrašytos komandos, kurias vykdo Java virtualioji mašina. Taigi baitinis kodas analogiškas mašininiam kodui gaunanam transliuojant pavyzdžiui C kalba parašytą programą. Tačiau kadangi virtualioji mašina fiziškai neegzistuoja (yra planų, kad tokia mašina ateityje bus sukurta), pragina priversta transliuoti (interpretuoti) baitinį kodą į mašininį. Kiekvieno kreipimosi papildomos atminties ar informacijos išvedimo į ekraną metu programa kreipiasi ne tiesiogiai į kompiuterį, bet užsako praginos terpei išskirti reikiamus resursus. Taigi Java programa neturi tiesioginio priėjimo prie mašinos operatyviosios atminties, disko ir kitų tipų resursų. Todėl Java virtualioji mašina atsistoja tarp kompiuterio ir programos ir saugo kompiuterį nuo programinių bandymų pažeisti sistemą. Tai ypač svarbu įskiepių atveju, nes įskiepiai naudojami Internete ir todėl iškyla žymiai didesni saugumo reikalavimai. Įsivaizduokite, kad Internete suradote programą ir paleidote ją vykdyti, o ji ištrynė jūsų diską! Jei parsisiųstas failas yra .exe ar .com tipo, tai visai ymanomas dalykas. Java atveju nuo tokios nelaimės jus apsaugos virtualioji mašina, kuriai gali būti uždrausta atlikti bet kokią rašymo į vartotojo diską operaciją.
Jums gali kilti klausimas ar Java, panašiai kaip Perl ir BASIC, yra transliuojamosios (interpretuojamosios) kalbos. Iš esmės taip, Java yra transliuojama, bet *.class baitinis kodas yra artimas mašininiam ir todėl Java kodas atliekamas žymiai greičiau. Atlikite paprastą eksperimentą: palyginkite BASIC ar Perl kalba parašytos programos kodą su Java baitiniu kodu. Nesunkiai matyti, kad pirmieji du lengvai suprantami žmogui, o Java baitinį kodą sunku atskirti nuo mašininio kodo. Iš čia gauname išvadą, kad Java *.class failai yra nepalyginamai greičiau transliuojami lyginant su BASIC ir Perl kalbomis parašytomis programomis.
Taigi .class failas yra kompaktiška .java failo versija, kurią Java praginos terpė sugeba greitai transliuoti. Antra vertus .class failai nėra idealiai kompaktiški. Dalykas tas, kad šiuose failuose yra papildoma (ekstra) informacija, kuri padeda praginos metu apsisaugoti nuo Java .class failų imitacijų, kurios mėgintų pakenkti jūsų kompiuteriui.
Kokiu būdu galima būtų mėginti įsibrauti į kompiuterį? Vienas būdų būtų mėginti pakeisti praginos kodą kenkėjiškos programos kodo fragmentais. Java compiliatorius niekada neleidžia to daryti, tačiau .class imitacija gali mėginti tai padaryti. Viena ekstra .class failo informacijos paskirčių yra eleminuoti tokią galimybę. Be šios savybės yra ir daugiau Java kompiliavimo ir vykdymo savybių, skirtų apsaugoti vartotoją nuo galimo pasikėsinimo į kompiuterio resursus.
Betarpinis (JIT) kompiliavimas
Nepaisant ekstra informacijos sąnaudų Java baitiniai kodai vykdomi žymiai greičiau nei analogiškos Perl ar BASIC programos. Antra vertus C ir C++ greitis nėra pasiekiamas. Tačiau betarpinis kompiliavimas (Just In Time (JIT) compilation) leidžia tiesiogiai kompiliuoti į mašininį kodą. Tai atsitinka tuomet, kai kodas vieną kartą būna įvykdytas. Todėl pakartotinas programos atlikimas gali būti taip pat greitai vykdomas kaip ir kompiliuotas į mašininę kalbą kodas. Taigi pirmą kartą leidžiant programą vykdyti greitis bus toks pat kaip vykdant baitinį kodą, tačiau pakartotinai paleidus programą ji bus atliekama taip pat greitai kaip vykdoma konkrečiai platformai sutransliuota programa.
Kartais jūs norėsite išjungti JIT kompiliavimą.
Tarkime tai naudinga, kai norite palyginti JIT praginos
laiką su ne JIT variantu. JIT pateikia supaprastintą
praginos klaidų sekimo protokolą, todėl programos derinimo metu irgi
naudinga atjungti JIT kompiliaciją.
Tuo tikslu programas parašytas JDK 1.1.5 ir ankstesnėm versijom
langų aplinkoje java komandine eilute paleiskite su -nojit
parametru.
Pavyzdys: java -nojit manoKlase.java
Programas parašytas JDK 1.1.6 ir vėlesnėm versijom
paleiskite apibrėžę JAVA_COMPILER sisteminį kintamąjį
taip, kad jis nurodytų į neegzistuojantį JIT kompiliatorių, pvz. "nojit".
Kad tai atlikti DOS aplinkoje surinkite
set JAVA_COMPILER=nojit.
Jei įskiepius peržiūrite su Microsoft Internet Explorer 4.x (Windows)
ir vėlesnėmis naršyklėmis, atjunkite
"Java JIT compiler enabled" parametrą nurodytą
"Java VM" skyriuje skirtame "Internet Explorer preferences" parametrams.
Juos rasite surasite:
Tools -> Internet Options -> Advanced
skyriuje.
Dėl JIT kompiliavimo jums papildomų rūpesčių neatsiranda. JIT servisą suteikia praginos terpė ir todėl Java programos rašymas nei kiek nepasikeičia; JIT įsijungia praginos metu ir pagreitina pakartotinį Java programos vykdymą.
Šiukšlių surinkimas Garbage Collection
Supratimas apie Java praginą reikalingas daugiau bendrojo išprusimo nei praktinio programavimo prasme. Pragina atlieka savo darbą ir visai nesikiša į jūsų programą; Java programa yra rašoma Java virtualiajai mašinai, kuriai jokios ytakos pragina tiesiogiai neturi. Taigi rašykite Java programas ir nesirūpinkite ar jos yra transliuojamos/interpretuojamos, pusiau transliuojamos ar tiesiogiai kompiliuojamos į mašininį kodą.
Tačiau yra vienas praginos vykdymo momentas - šiukšlių surinkimas Garbage Collection, kuris tiesiogiai įtakoja Java programos rašymą. Šis praginos servisas labai palengvina programuotojo darbą. Paraižiui verčiama Garbage Collection skambės "šiukšlių kolekcija". Ją sudaro visi programos kintamieji, kurie programos vykdymo duotu momentu jei daugiau nereikalingi.
Ar turėjote kada nors problemų su atminties stygiu? Atminties užsakymas ir jos negrąžinimas, kai ji daugiau nebebus naudojama yra tipinė tačiau sunkiai lokalizuojama programavimo klaida. Pritrūkus atminties jūsų programa užstringa arba laikinai išveda iš rikiuotės visą kompiuterio sistemą.
Kad surasti kur programoje klaidingai išskiriama ar negrąžinama atmintis, jums teks peržiūrėti visas darbo su atminties išskyrimo vietas; o tokių yra labai daug (Java atveju kiekvienas masyvo kintamojo paskelbimas ir objekto inicijavimas, kuriuose naudojami new, bus vertas dėmesio). Ką daryti, jei programos ilgis skaičiuojamas tūkstančiais eilučių?
Laimei programuojant Java dėl šios bėdos nereikia jaudintis. Java programoje naudojamas tik new operatorius išskirti atmintį. Jei kokiam nors lokaliam kintamajam buvo išskirta atmintis ir išėjome iš lokalaus kintamojo apibrėžimo galiojimo zonos, praginos šiukšlių surinkėjas analizuoja situaciją ir nusprendžia ar galima atlaisvinti anksčiau užsisakytą atmintį. Šiukšlių surinkimo mechanizmas taip pat apsaugo nuo pakartotinio atminties atlaisvinimo, nes toks atlaisvinimas iššauktų programos vykdymo klaidą.
Programos praginos metu, kai objektui ar masyvui yra išskiriama vietos, išskirtas atminties blokas yra pažymimas. Jei objektas ar masyvas pasidarė nereikalingas (pvz. baigė dirbti metodas su lokaliai naudojamais objektų ir masyvų kintamaisiais), šis atminties blokas įtraukiamas į "šiukšles". Tačiau jei lokaliai apibrėžtas kintamasis yra grąžinamas jį kvietusiam metodui, tai ta atminties dalis neįtraukiama į šiukšles.
Pažiūrėkime C kalbos programėlę, kurioje yra sunkiai aptinkama atminties išskyrimo ir atlaisvinimo klaida.
public char * thisWontWork() { char localArray[8]; strcpy(localArray,"Sveikas"); return localArray;}
Programuotojas tikisi, kad funkcija išskirs atminties ir grąžins "Sveikas" simbolių masyvą. Tačiau taip nebus. Išėjus iš funkcijos lokaliems kintamiesiems išskirta atmintis yra atlaisvinama ir grąžintas localArray tampa neapibrėžtu. Liūdniausia, kad tik grįžus iš funkcijos gana tikėtina, kad ten dar bus užsilikęs tekstas "Sveikas" ir spausdinimo metu gausite jį neiškraipytą, tačiau vėlesni bandymai panaudoti localArray duos neprognozuojamus rezultatus. Vargu ar jums greitai ateis į galvą kur reikia ieškoti klaidos tokiu atveju.
Java analogišku atveju "šiukšlių surinkimą" atliks inteligentiškai ir programa veiks korektiškai.
public char[] thisWillWork(){ char localArray[8]; localArray=('S','v','e','i','k','a','s'); return localArray;}
Praginos šiukšlių surinkėjas pastebės, kad localArray yra grąžinamas ir todėl yra reikalingas, todėl masyvo užimama atminties vieta nebus atlaisvinta. Tiesa localArray kintamojo jau nebus, tačiau tai nebėda, nes naudojant funkciją bus rašomas priskyrimo operatorius naujam kintamajam.
Java įskiepių (applets) rašymas
Pagaliau perėjome prie įskiepių aprašymo!
Kadangi įskiepiai yra talpinami Internetui skirtuose puslapiuose, jie kiek skiriasi nuo yprastų Java programų. Tačiau dabar daug nesigilinsime į naujai atsiradusių elementų prasmę ir atidėsime jų detalų aiškinimąsi vėlesniam laikui; tiksliau 5 skyriuje bus aprašyta "Kaip veikia įskiepiai" ir jūs tapsite pilnateisiais įskiepių Interneto puslapiams rašymo armijos kariais.
Pasirinkite savo mėgstamą tekstinį redaktorių ir surinkite (nukopijuokite) žemiau parašytą programėlę.
2-18a pavyzdys. Mano pirmasis įskiepis.
import java.applet.*; import java.awt.*; public class FirstApplet extends Applet { public void paint(Graphics g) { g.drawString("Sveikas, iskiepi!",50,50);} }
Atkreipkite dėmesį, kad ši programėlė gana stipriai skiriasi nuo anksčiau rašytų. Nesinervuokime dėl to ir ženkime toliau, kad paleisti ją vykdyti. Tuo tikslu reikia atlikti tokius veiksmus:
2-18b pavyzdys. Interneto puslapis skirtas patalpinti mano pirmajam įskiepiui.
<APPLET CODE=FirstApplet.class WIDTH=200 height=200> Jūsų naršyklė nepalaiko Java įskiepių. </APPLET>
Failą galite išsaugoti bet kuriuo vardu, svarbu tik kad failo galūnė būtų .html arba .htm. Tekstas tarp <APPLET...> ir </APPLET> žymių bus atspausdintas, jei vartotojo naršyklė nesugeba realizuoti Java virtualiosios mašinos.
Paspausk, kad gauti 2-18a įskiepiu sukuriamą vaizdelį
2-1 paveiklėlis. Mano pirmasis įskiepis.
Atpreipiame dėmesį, kad nei Netscape Navigator nei Internet Explorer naršyklės nesirūpina, kad pasiketė jūsų naujai sukompiliuotas .class failas. Todėl įskiepio derinimo metu patartina naudoti appletviewer komandą. Be to ši programėlė žymiai greičiau parodys rezultatą, tačiau derinimo pabaigoje būtina išmėginti įskiepį iškviesti su java palaikančia naršykle, kad gauti realų vaizdą kokį matys jūsų puslapio vartotojai.
Paanalizuokime jūsų pirmojo įskiepio programėlę. Anksčiau mums reikėjo tik vieno metodo "main". Dabar naudojame du metodus, vėliau sužinosime, kad įskiepis turi ir daugiau standartiškai paleidžiamų vykdyti metodų.
Pasižiūrėkime į skirtumus.
Jei anksčiau praginos metu būdavo kviečiamas "main" metodas, tai naršyklės praginos terpė pirma paleidžia init metodą. O kaip iškviečiamas paint metodas? Kiekvieną kartą kai ekraną reikia perpiešti paleidžiamas paint metodas. Pradžioje paint sulaukia init darbo pabaigos ir pirmą kartą atlieka savo darbą, o vėliau pagal aplinkybes, pvz. jei įskiepio langą uždengėte kitu langu ir vėl jį atidengėte, bus paleistas įskiepio metodas, kad atnaujinti įskiepiui išskirtą langą.
Įskiepio klasė turi didelį skaičių metodų, kurie reaguoja į įvairius vartotojo veiksmus. Tokių veiksmų pavyzdžiai yra pelės pajudinimas, klavišo ar pelės mygtuko nuspaudimas ir pan. 5 skyriuje apie tai kalbėsime plačiau. Dabar pademonstruosime mouseDown metodą, kuris iškviečiamas kiekvieną kartą, kai paspaudžiamas pelės klavišas. Mes sieksime pelės žymeklio vietoje tuo momentu užrašyti tekstą "Hello, Applet!"
2-19 pavyzdys. Įskiepis reaguojantis į pelę.
import java.applet.*; import java.awt.*; public class SecondApplet extends Applet { int curX=50; int curY=50; public boolean mouseDown(Event e, int x, int y) { curX=x; curY=y; repaint(); return true;} public void paint(Graphics g) { g.drawString("Hello, Applet!",curX,curY);} }
Pažymėsime, kad dabar vartojame repaint metodą mouseDown viduje. repaint metodas nurodo praginai atnaujinti ekraną. Tai atliekama perduodant ekraną Graphics objekto forma mūsų paint metodui. Išmėginkite naują įskiepį.
Paspausk, kad gauti 2-19 pavyzdžio įskiepio sukuriamą vaizdelį
2-2 paveikslėlis. Interaktyvus įskiepis.
Jei nekreipsime dėmesį į standartiškai kviečiamus įskiepio metodus, tai Java įskiepis niekuo nesiskiria nuo paprastos Java programos. Mes galime kurti naujus metodus įskiepio viduje ir jais naudotis.
Įskiepių patalpinimas Interneto vartotojams
Kol kas mes naudojome appletviewer komandą, kad pasižiūrėti į įskiepio darbo rezultatą. Dabar atėjo metas išsiaiškinti ką reikia padaryti, kad jūsų įskiepis būtų prieinamas visiems Interneto vartotojams.
Svarbiausias dalykas yra turėti resursų Interneto serveryje. VU Matematikos ir Informatikos fakulteto visi studentai tokius serverio resursus turi. Atsidarykite jums fakulteto serveryje išskirtame kataloge www pakatalogį ir perkelkite ten .html ir .class failus. Tarp kitko appletviewer komanda galima iškviesti įskiepį ne tik iš jūsų kompiuterio, bet ir iš Interneto, jei nurodysite teisingą URL adresą.
Mūsų .class failas SecondApplet.clas turi būti tame pačiame kataloge kaip ir secondApplet.html failas. Jei norite, galite .class failą patalpinti ir kitame kataloge, bet tuomet reikia panaudoti CODEBASE savybę, kad ji nurodytų kelią į įskiepį. Pateiksime CODEBASE panaudojimo pavyzdį.
2-20 pavyzdys. CODEBASE savybės panaudojimas.
<APPLET CODE=ProgramRunnerApplet.class CODEBASE="class.dir" WIDTH=300 HEIGHT=150> Jūsų naršyklė nepalaiko Java. </APPLET>
Šiuo atveju SecondApplet.class klasė turi būti pakatalogyje class.dir, t.y. atžvilgiu .html failo katalogo turi būti ./class.dir kataloge. CODEBASE reikšmė gali būti ir absoliuti. Lentelėje 2-6 pateiksime ir kitus APPLET žymės savybes (atributus).
| Savybė | Prasmė | Ar būtina? |
|---|---|---|
| CODE | Sukompiluotas įskiepis turi būti .class tipo failas | Taip |
| WIDTH | Storis taškeliais kiek bus išskirta įskiepiui vietos Interneto puslapyje | Taip |
| HEIGHT | Aukštis taškeliais kiek bus išskirta įskiepiui vietos Interneto puslapyje | Taip |
| CODEBASE | Katalogas kuriame patalpintas .class failas nurodytas CODE savybe | Ne |
| ALT | Alternatyvus tekstas, kuris rodomas jei įskiepis supranta APPLET žymę, bet nepalaiko Javos. | Ne |
| NAME | Įskiepio vardas, kurį gali naudoti kiti puslapio įskiepiai. | Ne |
| ALIGN | Įskiepio patalpinimo puslapyje būdas. | Ne |
| VSPACE | Nurodo taškelių skaičių, kuris gaubs įskiepį iš viršaus ir apačios. | Ne |
| HSPACE | Nurodo taškelių skaičių, kuris gaubs įskiepį iš kairės ir dešinės. | Ne |
2-6 lentelė. APPLET žymės savybės.
Be šių savybių galima naudoti <PARAM...> žymes, skirtas perduoti įskiepiui parametrus. Visi <PARAM...> turi būti patalpinti tarp <APPLET...> ir </APPLET> žymių. PARAM žymėje galite naudoti NAME ir VALUE savybes. Įskiepis sugeba praginos metu pasiimti <PARAM...> žyme perduodamas reikšmes. Pateiksime pavyzdį, kuriame bus panaudotas parametrų perdavimas.
2-27 pavyzdys. PARAM žymės panaudojimas.
<APPLET CODE="AnimatedCursorApplet.class" HEIGHT=250 WIDTH=250> <PARAM NAME="CURSORFILEO" VALUE="images/anim0.gif"> <PARAM NAME="CURSORFILE1" VALUE="images/animl.gif"> <PARAM NAME="CURSORFILE2" VALUE="images/anim2.gif"> <PARAM NAME="CURSORFILE3" VALUE="images/anim3.gif"> <PARAM NAME="CURSORFILE4" VALUE="images/anim4.gif"> <PARAM NAME="CURSORFILE5" VALUE="images/anim5.gif"> </APPLET>
Naujas įskiepis naudoja name ir value porose apibrėžtus paveikslėlių pavadinimus. Ką daryti su nuskaitytomis parametrų reikšmėmis yra įskiepio kompetencijoje.
Automatinis kodo dokumentavimas
Dokumentuoti programos kodą visuomet svarbu. Java įrankių rinkinyje (JDK) yra javadoc programa skirta sukurti Internetinį jūsų programos kodo dokumentacijos puslapį. Šiam puslapiui sukurti naudojami specialūs kodo komentarai. Pailiustruosime tai pavyzdžiu.
2-22 pavyzdys. Automatinė dokumentacija.
/** As parasiau klasę ir ją dokumantavau! * Dokumentaciją gavau naudodamas javadoc komandą. */ class documentedClass { /** Dabar aprasysiu shy kintamaji * Tai yra svekas skaicius int! * Man patinka dokumentuoti! */ public int documentedVariable; /** Dabar dokumentuosime metoda! * Shis metodas naudoja viena String tipo parametra. * Jis nieko nedaro, ji panaudojau tik dokumentavimo iliustracijai. * Jei jis butu kam nors naudojamas, ash jums butinai ji aprasychiau!*/ public void documentedMethod(String x) ({ System.out.println("Dokumentuotas metodas");} }
javadoc paleidžiama komandine eilute taip:
javadoc -d <API katalogas> documentedClass.java
Čia <API katalogas> kuriame patalpinta likusi Application Programming Interface dokumentacija.
Javadoc generuos documentClass.html failą. 2-2 paveikslėlyje 2-2 patalpinome nuorodą į šį puslapį.
Figure 2-3: Dokumentavimas su javadoc.
Mūsų komentarus rasite interneto puslapyje. Atkreipkite dėmesį, kad String parameteras yra su nuoroda į String klasės dokumentacijos failą. Visi klasės parametrai yra su nuorodomis į juos aprašančius puslapius; prasidedantys /** simboliu komentarai užrašomi į Interneto puslapį. Jei norite generuoti nuorodą į kokią nors klasę, panaudokite @see žymę ir nurodykite klasės pavadinimą. Taip pat komentarų srityje galite naudoti ir įprastas HTML žymes.
Dabar jūs jau turite susidarę bendrą vaizdą apie Java ir jos praginos terpę. Sužinojome, kaip rašyti paprastas Java programas ir įskiepius, skirtus talpinti Ineterneto puslapiuose; išmokome Java programas kompiliuoti bei talpinti įskiepius Interneto puslapiuose. Pakalbėjome apie Java virtualiąją mašiną, kurios konsepcija yra būdinga tik šiai kalbai ir kuri yra Java kalbos saugumo ir nepriklausomumo nuo kompiuterio platformos pagrindas. Mums dar aiškiai trūksta žinių apie Java programavimo pagrindus. 3-iame skyriuje pagvildensime Java objektinio programavimo elemetus.
Šiai užduočiai bus naudinga klasė java.util.Date klasė ir jos metodas getTime().
