Learn java by Alex 2011.pdf

8/17/2019 Learn java by Alex 2011.pdf

1/39

Java algajatele(v1.0 2011a) See on juhend kiireks Java õppimiseks, esialgsete teadmiste omandamiseks. Näited teen

eclipse’iga. Koostanud Alex. Email: [email protected]. Tänud Roelile, kes leidis kirja- ja

muid näpuvigasid ning tegi huvitavaid soovitusi manuaali redigeerimiseks/täiendamiseks!

I. Valmistumine programmi kirjutamiseks.

Alustame kõige lihtsamast asjast ehk põhimõttest. Programm koosneb pakettidest. Pakett

koosneb klassidest, millest üks alati on main class, mis jooksutab teisi klasse. Main klassi all

mõtlen ma seda, et meil on üks suvalise nimega klass, mis hoiab endas staatilist main

nimega funktsiooni (sellest veidi hiljem). Klassid on selleks, et hoida erinevaid programmi osi

eraldi. Näitena võib tuua maja. Maja puhul on klassideks näiteks sein, aken, uks, katus,

vundament jne. Maja elamiskõlblikuks muutumiseks on vaja Main klassi. Klassid koosnevad

funktsioonidest.

Java programm koosneb pakettidest, pakid aga klassidest. Maja näite puhul on pakiks maa-

ala, millel maja asetseb.

Programm kasutab erinevate tüüpidega muutujaid, ühed hoiavad endas numbreid, teised

sõnu (stringe), kolmandad jah või ei väärtust (boolean) jne.

Alustame projekti tegemisest. Teeme uue projekti.

Anname sellele nime. Otsime selle kataloogi puust üles ja leiame source’i (src). Lisame sinna

uue paketi ja paketi sisse ühe uue klassi. Nõnda loome aluse lihtsa ühe klassiga programmi

kirjutamiseks. Paketile ja klassile tuleb anda nimi. Anname paketile nimeks näiteks „paki“ ja

klassile „Program“.

mailto:[email protected]:[email protected]:[email protected]:[email protected]


2/39

Paketi loomine:

Klassi loomine:

Nüüd, kui klass pole veel avanenud, teeme kataloogipuus sellele topelt klõpsu, meile avaneb

selline pilt:


3/39

Et meie ühe klassiga programm töötaks, peame me tegema sellest klassist Main klassi, sest

nagu eelnevalt öeldud, iga programm peab sisaldama Main klassi. Kirjutame main juurde

järgneva funktsiooni. Funktsioonidest konkreetsemalt teeme juttu pärast poole. Seega näeb

asi peale muutmist välja nii:


4/39

II. Lihtsa programmi kirjutamine, muutujad.1. Nagu igas teiseski keeles, on programmi lahutamatu osa informatsiooni väljastamine.

Javas, kui me tahame midagi väljastada, on olemas lause System.out.println(), kus

sulgudesse läheb informatsioon, mida tahame väljastada konsoolile. Konsool avaneb

programmi käivitamisel (Näites on see vasakul üleval olev roheline nupuke). Konsool ei

pruugi avaneda paremal, nagu näites, aga seda saab liigutada soovitud kohta.

2. Iga koodirida lõpeb semikooloniga, et käskudel vahet teha.

Käsud täidetakse alati järjekorras. Väljastame tervituse konsoolile.

3. Õppime kasutama muutujaid. Alustame kõige enam kasutatavatest muutujatest.

Deklareerime muutuja ja anname talle algse väärtuse. Väljastame muutujad konsoolile.

Kuidas deklareerida? See käib üldise reegli järgi:

Tüüp nimi = algväärtus;

Peame meelde jätma, et:

a) teksti kirjutame alati jutumärkidesse!

b) Numbri kirjutame jutumärkidesse vaid siis, kui tahame, et see oleks tekstilise

tähendusega. Üldjuhul on see ilma jutumärkideta.

c) Jah-ei väärtuse korral kirjutame algväärtuseks kas true(jah, tõde) või false(ei, vale), muid

variante pole.

d) kommentaari ette paneme alati kaks kaldkriipsu, seda lauset programm ei loe.

DEKLARATSIOON:

String tekst = “Tere hommikust!“; - tüüpi String deklareerime ALATI suure S tähega, kuid

see on ainuke muutuja tüüp, mis suure tähega algab. Nimi võib olla enda vabalt valitud ja see

võib sisaldada ka numbrit.

int number1= 10; - Me ei pane numbrit jutumärkidesse, kui me tahame seda kasutada

numbrilises mõttes (näiteks erinevad tehted). Algväärtuseks paneme 10.


5/39

Boolean b = true; - jah-ei tüüp, algväärtus true ehk jah.

Vaatame näidet. Demonstreerin muutujate väljastamist konsoolile.

Numbritega saab teha tehteid. Stringe saab kokku liita.

Stringe liidetakse kokku märgi abil. Näiteks ’’laste’’’’aed’’ annab tulemuseks ’’lasteaed’’,aga ’’laste ’’’’aed’’ annab tulemuseks ’’laste aed’’. Vahe on selles tühikus. Tühik on samuti

teksti üks osa. Väljastame muutujad konsoolile. Näites on tehtud int-idega ka tehteid ja

Stringe liidetud. Samuti väljastatud jah-ei väärtusega muutujad.

AGA MILLEKS MUUTUJAD? Selleks, et muutujate väärtust saaks alati muuta.

Algväärtus on vaid see väärtus, mis on antud talle algul. Vaadakem järgmist näidet!

Muutuja väärtuse muutmisel enam tüüpi ette ei anta. Konsoolile trükitakse viimane väärtus,

sest programm täidab käsud järjekorras. Enne, kui info väljastatakse konsoolile, muutubmuutuja „suvalinetekst“ väärtus.


6/39

Juhul, kui System.out.println(suvalinetekst); oleks olnud järjekorras teine, mis oleks juhtunud

siis? – konsoolile oleks trükitud esimene väärtus, sest väärtus muutub alles pärast muutuja

konsoolile väljastamist.

---------------------------------------------------------------------------------------------------------------------------

Vaatame järgmist näidet. Vaatame int-ide tehteid ja Stringide liitmist. Nagu näha, saamemuutujate väärtuseks omistada teisi muutujaid või tehteid nendega. Samuti pöörakem

tähelepanu reale cba=cbaabc. Me näeme, et saame, kasutada muutujat ennast väärtuse

muutmisel.

AGA!: Tasub meeles pidada, et int, String ja boolean pole ainsad muutujate tüübid. Neid onveel, näiteks char, mis on ainult ühe tähe deklareerimiseks. PS! Tähe deklareerimisel

kasutatakse ülakomasid, nt char a = ’b’!

DEKLARATSIOON 2:

Jagame muutujad kahte gruppi: Ühed on funktsiooniSISESED ja teised funktsiooniVÄLISED.

Funktsioonideni jõuame natukene hiljem, ent teadmiseks:

public static void main(String args[]){

//kood

}

See on main’i funktsioon!

FunktsiooniSISESED: Kirjutatakse funktsiooni sisse ja neid saab kasutada AINULT funktsiooni

sees.

FunktsiooniVÄLISED (globaalsed): Kirjutatakse funktsioonist välja poole, tavaliselt enne

funktsiooni. Neid muutujaid saab kasutada igas funktsioonis.


7/39

Siin veel üks AGA!:

Funktsioonivälistel muutujatel on olemas ka ÕIGUSED!

See tähendab, et on olemas privaatsed ja avalikud funktsioonivälised muutujad.

Privaatsed: Näiteks private int a = 10; Privaatne õigus lubab kasutada seda int-i ainult sellesklassis, kus ta on deklareeritud.

Avalik: Näiteks public String b = “koer“; Avalik õigus lubab kasutada seda Stringi ka teistes

klassides, samuti saab teisest klassist selle Stringi väärtust muuta.

Piltlik näide:

Nagu näites näha, saab samasuguse nimega deklareerida funktsioonisisese ja –välise muutuja.

Selle väljastamisel konsooli prinditakse meile funktsioonisisene muutuja, sest printimine toimub

funktsioonis ja selles kasutatakse funktsioonisisest muutujat. Ka funktsioonivälist muutujat saab

printida asendades funktsoonis muutuja nime “this.lalala“-ks, ent seda ei saa teha selles staatilisest

main funktsioonis.

Lühidalt: Kui on olemas funktsiooni sisene ja –väline muutuja, mis on sama nimega, siis funktsioonis

kutsutakse välja sisene muutuja, sest sellel on esmaõigus. Ainult välise muutuja olemasolul

prinditakse just see väline konsoolile.

LISAKS! Muutuja võib olla ka staatiline ehk näiteks static int a = 1; See on funktsiooniväline

deklareerimine ja lubab eranditult kõigist klassidest saada see int kätte ja muuta seda, mistõttu

muutuvad ka teiste funktsioonide tulemused, mis kasutavad seda muutujat.

LISAKS! Muutuja võib olla ka finaalne ehk näiteks final int b = 2; See tähendab, et muutuja omandab

lõpliku väärtuse ja seda pärast enam muuta ei saa. Võib nii mõnigi kord kasuks tulla!


8/39

III. Funktsioonid ja mitu klassi

Õpime erinevaid funktsioonide tüüpe. Selleks loome uue klassi meie olemasolevasse paketti.

Nimetame seda „klass1“-ks. Klassi sisse kirjutatakse funktsioonid. Jagame siinkohal funktsioonid

kahte suurde rühma: Sisendiga ja sisendita funktsioonid. Mõlemad rühmad jagame omakorda veel

kaheks väiksemaks: tagastusega ja tagastuseta funktsioonid. Piltlikult öeldes:

Funktsiooni üldine kuju:

*avalik või privaatne+ *tagastamise tüüp+ *nimi] [sulgudes sisendid] {

//kood

[tagastus, kui on]

}

Näide:

Public void funktsiooni_nimi(){

Int a=0;

}

PEAME MEELES!

Kui tagastamise tüüp on void, siis funktsioonil tagastus puudub!!!

Kui tagastamise tüüp on String, siis tagastatakse ka String,

Kui tagastamise tüüp on int, siis tagastatakse ka int,

Üldine reegel on, et tagastame selle, mis tagastamise tüübiks määrasime.

Vaatame järgmist näidet ja loeme hoolikalt ka kommentaare (rohelises tekstis)


9/39

Need on sisendita funktsioonid:

Näites on näha, et kui näiteks String on tagastustüüp, siis me tagastame ka Stringi nimega lol.

Samamoodi on ka teiste tagastustüüpide puhul.

-----------------------------------------------------------------------------------------------------------------------------------

Nüüd vaatame sisendiga funktsioone. Sisendid kirjutakse sulgudesse, mis tagastuseta funktsiooni

puhul pannakse samuti lõppu.


10/39

Sisendi määramisel deklareerime sulgudes muutuja ilma algväärtust andmata. See on see muutuja,

mida me hakkame oma funktsioonis kasutama.

Vaatame juhtu:

public String fn(String sona, String lol, int a, int b, int c){

String xyx;

xyx=sona+lol;

c=a+b;

return xyx;

}

Oletame, et funktsiooni tuleb sisse kaks sõna ja kolm numbrit.

Seda saame teha funktsiooni välja kutsudes nii – fn(“tere“, “ hommikust“, 1, 2, 3);

rida 1. Deklareerime Stringi nimega xyx, aga me ei pea andma talle algväärtust.

rida 2. String xyx saab omale väärtuseks “tere“ “hommikust“;rida 3. Int c saab väärtuseks ab, aga pane tähele, me ei deklareeri siin ühtegi olemas olevat

int-i, sest see on juba kõik sisendite ette andmisel tehtud.

rida 4. Tagastame xyx-i, sest tagastustüübiks on määratus String. Kui me oleksime tahtnud

tagastada näiteks int a-d või hoopis int c-d, siis oleks pidanud funktsioon olema

public int fn(String sona, String lol, int a, int b, int c).

Teadmiseks!

Kui deklareerime:

String a; siis see on sama, mis String a = null; see tähendab, et väärtust ei ole.

Kui muutuja ei oma väärtust ja sellega tehakse mingeid operatsioone, saame programmikäivitamisel vea!

FUNKTSIOONIDE VÄLJAKUTSUMINE:

Kaks võimalust:

1) Me kutsume funktsiooni välja samas klassis, kus see on tehtud. Selleks piisab nimest ja

sisenditest.

Näiteks, kui meie klassis on olemas

public void fn(){

System.out.println(“Tere“);

}

Siis kutsume ta välja nimepidi - fn();

Kui tal on sulgudes sisendid:

public void fn(String a, int b){

System.out.println(“Tere“);

}

Siis anname need talle kaasa: fn(“hei“, 5);


11/39

2) Kui kutsume välja teisest klassist välja selle funktsiooni, siis on vaja teha funktsiooni

sisaldavast klassist nii öelda koopia.

Selleks on reegel: [Klassinimi] [koopia nimi] = new [Klassinimi]();

Ehk, kui funktsioon asub klassis nimega “Limbo“ ja meie tahame välja kutsuda selle

funktsiooni oma Main klassis, siis kirjutame Maini:

Limbo a = new Limbo();

Nõnda teeme koopia, anname sellele nime a, ja kutsume välja nii:

a.fn() või a.fn(“heipsa“, 9);, olenevalt sellest, kas ja mis tüüpi sisendeid see funktsioon tahab

saada.

TEADMISEKS! Kui funktsioon tagastab mingi väärtuse, siis võime me selle väärtuse omistada

mingile muutujale või kasutada vastava funktsiooni väljakutsumist justkui muutujana.

Näiteks, kui meil klassis Auto selline funktsioon:

public String autosoidab(){String a = “Auto sõidab!“;

return a;

}

Siis Mainist välja kutsumisel on igati õige ja veatu kirjutada selline rida:

Auto b = new Auto();

String auto = b.autosoidab();

System.out.println(auto); või System.out.println(b.autosoidab());

String auto saab väärtuseks “Auto sõidab!“ ja System.out.println() funktsioon prindib sellevälja.

Näide funktsiooni väljakutsumisest samas klassis (See näide ei tööta, sest Main peaklass ei

kutsu ühtegi funktsiooni neist välja, küll aga Mainis funktsiooni Tervita() väljakutsumisel

prinditakse meile välja ka funktsiooni prindiTervitus() tegevus.):


12/39

Näide Mainist: ühe funktsiooni välja kutsumine:

Üks hea progamm koosnebki mitmetest klassidest, mis käivitatakse järjekorras mainist.

IV. Tsüklid Tegutseme näidete lihtsuse mõttes jälle ainult mainis.

Tsüklid on selleks, et korrata mingit tegevust või funktsiooni osa.

On olemas kahte sorti tsüklid, mida nimetatakse While ja For tsükliteks.

For-tsükli puhul teame me täpselt, kui kaua tahame mingit tegevust korrata.

While tsükkel sobib pigem pikemateks kordamisteks, kus otsitakse kindlat tingimust.

1) For tsükli kuju: for(int i=0; i


13/39

Saame tingimusi muuta endale meelepäraseks, näiteks:

Kui me kirjutame x=10, siis see tähendab „väiksem või võrdne kui...“ või „suurem või

võrdne kui...“-d

2) While tsükli kuju: while(tingimus)

Int x=0;

While(x


14/39

Peame meeles! Tsükli enneaegseks väljumiseks kasutame käsku break;

V.

IF-lausedIF-lauseid kasutame millegi võrdlemiseks, mingi funktsiooni osa käivitamiseks jne.

IF-lause kuju: if(tingimus){}

Näide:

Konsoolile trükitakse ainult „tere!“, sest x on 0.

Peame meeles, et numbrite võrdlemisel kasutatakse kahte võrdusmärki, SEST ühte

võrdusmärki kasutatakse muutuja väärtustamisel. Antud juhul me EI SEA muutuja x

väärtuseks 0 vaid VÕRDLEME x-i ja 0-i omavahel.


15/39

Võrdlemiseks võime kasutada ka võrdlemismärke

STRINGI PUHUL ON TEISED LOOD!

Stringe ei saa me kahe võrdusmärgiga võrrelda...Tingimus töötab nõnda ebakorrektselt!!!

Stringide võrdlemiseks kasutatakse java sisse-ehitatud funktsiooni, millest räägin hiljem

stringitöötlemise peatükis. Hetkel olgu vaid nii palju teada, et võrdlemiseks kasutame

equals() sisseehitatud funktsiooni.

Näide:


16/39

ELSE võimalus Peale if-lauset võib järgneda else if või else lause, kuhu programm pöördub siis, kui if -lause

tingimus ei vasta tõele. Else if puhul saab lisada uue tingimuse, else puhul minnakse sinna alati, kui

if-lauset ei käivitata mitte tõese tingimuse tõttu.

Else näide:

Else if näide:

EITAMINE! – Me saame küsida kas kaks numbrit on omavahel võrdsed. SAMUTI saame küsidaka seda, kas numbrid EI OLE omavahel võrdsed.

Selleks – kasutame eitusmärki, milleks on hüüumärk - !Kahe numbri võrdlemisel number1 != number2 tähendab seda, et number1 ei ole number2-ga

võrdne.

Stringide puhul – !tekst1.equals(tekst2), tähendab seda, et tekst1 ei ole sama, mis tekst2.


17/39

Näide:

IF-lause sobib suurepäraselt põgenemaks tsüklist, kui tingimus on täidetud. IF-lauset saab kirjutada

teise IF-lause sisse, samuti saab korraga anda mitu tingimust.

Mitme tingimuse andmiseks kasutame sidesõna „ ja“ asemel - && (kaks and-märki) ning „või“

asemel - || (kaks püstkriipsu).

Näide:

Juhul, kui sidesõnu on palju, võib kasutada sulge. Sulgudes olevad tingimused kontrollitakse

esmajärjekorras.


18/39

VI. Massiivid, arraylistidMassiive kasutame, et ühesuguse nime all hoida ühest rohkem erinevaid väärtusi.

Deklareerimise kuju: muutujatüüp nimi*+ = new*suurus+;

Näiteks int arvud*+ = new int*10+;

arvud[0]=4 - see on massiivi nullinda koha väärtustamine

arvud[1]=62 – see on massiivi esimese koha väärtustamine

jne 10-ni.

Kõiki massiive loetakse alati nullist alates. Esimene koht on alati muujujanimi[0];

Samamoodi saab neid konsoolile printida. Näiteks System.out.println(a[1]);

Kõik väärtused on parem printida tsükli abil. Veenduda, et vahepeal ei ole väärtustamata

massiivi kohti.

Massiivi tüüpideks sobivad kõik javas olemasolevad muutujatüübid.

Massiivi on hea kasutada, kui ütleme näiteks autol oleks neli erineva suurusega ratast.

Siis: int rattad[] = new int[4];

a[0]=15a[1]=16

a[2]=17

a[3]=14

Parem on jätta alati üks massiivi koht üle. Selleks on siis a*4+, mis jääb tühjaks.

Me võime teha ka mitmemõõtmelisi massiive.


19/39

Näide:

ARRAYLISTID:

On selleks, et hoida andmeid nimekirjas. Nimekirjas saab hoida nii ainult ühte tüüpi muutujaid kui

ka erinevat tüüpi muutujaid.

Saab printida nii tervet nimekirja kui ka üksikelementi.

ArrayListiga on hea hoida näiteks erinevaid nimesid jne.

Näide:

Andmete lisamine käib java add() sisseehitatud funktsiooni abil.

PEA MEELES! Vajalik on ArrayListist nii öelda koopia teha ja anda koopiale nimi. Seejärel saab

seda kasutada. KINDLASTI on vaja teha ka import, mis lubab ArrayListi kasutada. Seda tehakse

lausega import java.util.ArrayList; ning see pannakse enne klassi algust.


20/39

VII. Stringide töötlemine Tihti on vaja töödelda stringe. Me oskame juba Stringe liita, neid võrrelda. Kindlasti kuluks

ära ka teadmised, kuidas leida mingit osa Stringist. Veenduda, kas mingi osa on Stringis

olemas. Kuidas asendada mingeid märke/tähti Stringis jne.

1) Alustame Stringi lõikamisest. Selleks on java sisemine funktsioon substring(x, y);

Kus x on esimese tähe numbriline koht ja y viimase tähe numbriline koht, mis

Stringist välja lõigatakse. y-i mitte kirjutamisel lõigatakse välja string esimesest

etteantud tähemärgist sõna lõpuni.

Näide:

2) Mõnikord me ei tea, mis koha peal mingi täht asub. Selleks on olemas java sisemine

funktsioon indexOf(täht);

Näide:

Pöörame ühtlasi tähelepanu k printimislausele:

System.out.println("k1 väärtus: "+k1 + "\nk2 väärtus: "+k2);


21/39

Teksis olev \n annab käsu teha uue rea.

Sama lugu on ka System.out.println() ja System.out.print() –ga, kus println puhul

tehakse uus rida ja print puhul mitte.

Samuti tuletame meelde ja jätame veel paremini meelde, et funktsioone saab

kasutada teiste funktsioonide sees!

3) Kuidas leida kogu sõna pikkus? – sõna.length() funktsiooniga.

Näide:

4) Kordame üle ka Stringi liitmised.

Näide:

a= “ae“; liidab stringile a paremalt poolt juurde teksti “ae“.

5)

Asendamine toimub funktsioonigasõna.replace(vana, uus); või sõna.replaceAll(vana, uus);

Näide:


22/39

6) Kontroll, kas mingi osa on olemas stringis. If-lause ja contains(sõna osa) meetodiga.

Meetod on sama mis funktsioon.

Näide:

7) Neid meetodeid on veel ja veel ja veel. Kui eclipse plugin võimaldab seda, siis pärast

muutujat punkti pannes kuvab see palju erinevaid võimalusi. Kui ei kuva, siis

googeldada saab ka alati. Programmeerija ei pea kõike peast teadma. Autodki

pannakse skeemi järgi kokku, mitte peast (need mis käsitsi kokku pannakse).

Plugina näide:


23/39

VIII. Errorite püüdmine, nende töötlemine Iga programmeerija puutub kokku veateatega. Juba kasvõi siis saame veateate, kui üritame

ühte jagada nulliga.

Neid erroreid saab kinni püüda, et mitte takistada programmi tööd.

Selleks on olemas nii nimetatud try-catch block.

Põhimõtteliselt me algul üritame teha arvutust – try – ja vea ilmnemisel püüame selle kinni – catch.

Üldkuju:

try{

//kood, nt tehe vms

}

catch(Exception e){

System.out.println(e.getMessage());

}

Kui me kood tekitab vea, liigub seesama viga catch bloki, kus antakse põhimõtteliselt sellele

nimi, et sellega saaks teha soovitud toiminguid. Antud juhul nimetame Exceptioni ehk erandi

(=vea) e-ks ja väljastame java meetodiga probleemi.


24/39

1/0 näide try catch blokiga:

Nagu näeme, väljastati meile koleda ja pika punase teksti asemel teade, et üritatakse jagada

nulliga.

Eelneva näite puhul püütakse catch(Exception e) abil kinni kõikvõimalikud vead, mis võiksid

tekkida. AGA! Mõnikord on vaja kinni püüda just ühte kindlat probleemi, et mitte kasutajat

eksitada vale informatsiooniga.

Selleks püüame mitte Exceptionit, vaid üle-eelmise näite puhul näiteks

ArithmeticExceptionit. Vea ilmnemisel saab hõlpsasti seda nime lihtsalt kopeerida.

Näide:


25/39

Nüüd saime kätte kindla errori. Esialgu tundub, et vahet nagu ei olekski. AGA on! Me saame

püüda nõnda erinevaid Exceptioneid ja lõpuks tasub kindlasti mainida, et püütaks kinni ka

kõik ülejäänud, mille peale ei ole programmeerija võimeline tulema. Samuti võime me

teated kinni keerata ja teha just seda, mis meeldib. Kasutaja ei peagi aru saama, et viga

juhtus.Näide:

Püüame kinni kõik aritmeetilised erandid ja ka ülejäänud, mis tekkida võiksid.

LISATARKUS: THREADidMõnikord võib juhtuda, et on vaja panna tööle mingid programmid paralleelselt. Teadagi

täidab programm koodi üldiselt järjekorras. Selleks on threadi võimalus.

Oletame, et me ehitame üles projekti MAJA. See on jagatud klassideks. Klassideks on sein,

vundament, katus, aken, uks

Lihtsuse mõttes unustame ära aknad ja uksed. Hakkame siis maja ehitama 1) vundament 2) sein 3) sein 4)sein 5)sein 6)katus

Selle asemel, et järjest ehitada valmis ühte seina, siis teist, kolmandat, neljandat, võiks

ehitada nad üles kõik korraga. Selleks tulevadki appi meile Threadid.

Oletame nüüd selle sama näite põhjal, et thread on töömees. Kõik mis meil on vaja teha, on

deklareerida mitu threadi ehk tellida mitu töömeest ja panna nad tööle. Seda me teemegi!

Teeme ühe klassi töömees ja extendime ta Threadiks, see tähendab, et me laiendame ta java

olemasolevaks klassiks, et saaks kasutada tolle kõiki omadusi. Teeme funktsiooni run, mis on

Threadi tegude käivitaja ja paneme sinna alla, mida me tahaksime, et töömees teeks.

Klass Toomees on selline:


26/39

Teeme ka klassi ehitamine, mis käivitab ehitamise:

Thread.sleep(500); paneb programmi 0,5 sekundiks seisma.

Ja programmist deklareerime töömehed ja paneme nad tööle!


27/39

Nagu konsoolil näha, teevad threadid vaheldumisi tööd. Mitte ei tee algul Thread-0 oma töö

ära, seejärel Thread-1 ja Thread-2. Kõik nad teevad korraga tööd! Kui teed näited järgi, tee

lisaks ehitamise klassi alla veel üks meetod nimega palgaSaamine() ja lase igal töömehel

saada iga ehitamise järel palka.

Lisaülesanne: Tee väike lihtle taimer kasutades While tsüklit ja Thread.sleep()-i. Prindi iga

uus sekund konsoolile.

Vihje: 4 rida koodi, saab kokku pressida ka ühele reale.

LISATARKUS: GRAAFILINE LIIDESPõhimõte: Teeme klassi mis extendib JFrame-i, sest Jframe on see, kuhu peale nupukesi,

erinevaid paneele jms lisatakse. Me võime lisada ka paneelide peale soovitud nuppe, aga

piisab ka täiesti JFramest. Me peame valima sobiva layout-i. Neid on olemas mitmeid, kuid siin juhendis pakun välja

proovimiseks kahte erinevat: null-layout ja BorderLayout.

Lisaks võite ise uurida FlowLayouti, GridLayouti, BoxLayouti, GridbagLayouti jne.

Vahe:

a) Null-layouti puhul saame lisada ükskõik mida ükskõik kuhu ükskõik kui suurelt.

Siiski loetakse null layouti kasutamist halvaks ideeks (akna suuruse muutmisel

lisatud komponendid ei muuda suurust koos aknaga , tuleb midagi välja mõelda),

ent see sobib esmakordseks graafilise liidese tegemiseks kõige paremini.

b)

BorderLayouti puhul saame valida NORTH, CENTER, SOUTH, EAST, WESTsuundade vahel ja komponendid lisatakse sinna suunda, mida me valime. On

erinevaid reegleid, mille abil on võimalik lisatud komponentide soovitud asukohti

seadistada. Komponendid suurenevad ka akna suuruse muutmisel automaatselt.

1) Teeme uue klassi ja extendime selle Jframeks VÕI teeme eraldi meetodi ja lisame

JFrame-i instantsina (koopiana). (importida javax.swing.JFrame)

2) Lisame erinevad komponendid, seal hulgas layouti.

3) Konfigureerime komponendid

4)

Teeme akna nähtavaks. 5) Kutsume meetodi või klassi välja Mainis.


28/39

I. NULL-LAYOUT

Näide null-layoutist: Teeme uue klassi, nimeks paneme näiteks „window“.

NING KINDLASTI, KUI ARVUTI SEDA ISE EI TEINUD VÕI NEID VÕIMALUSI EI PAKKUNUD,

TULEB TEHA KA VASTAVAD IMPORDID:

KUTSUME MEETODI VÄLJA MAINIS!


29/39

TULEMUS ON SELLINE:

TEADMISEKS! Koordinaadid algavad ülevalt vasakust

nurgast.


30/39

Piltlikult öeldes:

Nüüd teeme sama asja konstruktorina. Konstruktor tähendab, et terve klass ongi nagu

meetod ehk funktsioon. Klassist instantsi tegemisel

käivitub see automaatselt ja ei ole vaja välja kutsuda

selle klassi all olevat meetodit. Vaadake näidet ja

samuti pöörake tähelepanu sellele, kuidas on


31/39

konstruktor tehtud, sest konstruktorit saab kasutada

ükskõik kus, mitte ei ole see mõeldud vaid graafilise

liidese tegemiseks!Näide:

Tulemus on täpselt sama, mis eespool pildina välja

toodud.

Nii tehakse konstruktor!


32/39

II. BorderLayout

BorderLayoutiga on võimalik asju paigutada nõnda:

Teeme näite konstruktoriga (importida java.awt.BorderLayout):


33/39

Ning tulemus on selline:


34/39

setSize() ja setLocation() meetodid komponentide peal

Borderlayoutiga ei tööta!

Ometigi me ei taha võib-olla nii laie või kõrgeid nuppe. Siin aitavad

hädast välja paneelid, mida sai ka null-layouti näites juba

demonstreeritud.

IDEE seisneb selles, et me lisame paneeli näiteks põhja ja paneelile

omakorda nupud.

Näide:


35/39

Ja tulemus on selline:

Akna venitamisel venitatakse ka nuppe.

ACTIONLISTENERID:

Neid nii öelda kuulajaid on vaja selleks, et nupule vajutades midagi ka

juhtuks. Nende kasutamisvõimalusi täpsemalt leiab googeldades,

kuid näitan ära nupu kuulamist ja ka teksti sisestamist konsoolile

textfieldi ja nupu abil.


36/39

Nupu actionlistener:

mpordid:


37/39

a vajutades nupule on tulemuseks väljatrükk konsoolil:

Kirjutame veelkord üles nupu actionlisteneri:

JButton jb = new JButton("kliki siia!"); //teeme uue nupu jb

jb.addActionListener(new ActionListener() { //lisame actionlisteneri public void actionPerformed(ActionEvent e) {//kui me vajutame nupule...

//lisame siia koodi, mis juhtub, kui nupule vajutada

}

});

S! Jälgige kõiki sulge, loogilisi sulge, semikoolonit.


38/39

Textfield + nupp:

mport:

TULEMUS (textfieldi kirjutades ja nupule vajutades):


39/39

TEADMISEKS!

Kui setDefaultCloseOperation(Jframe.EXIT_ON_CLOSE) jääbkirjutamata, aken X-i vajutades ei sulgu, vaid läheb peitu. Programm

jääb samuti tööle. Terminatides programmi sulgub lõplikult ka aken.

Kui setDefaultCloseOperation(Jframe.EXIT_ON_CLOSE) on

kirjutatud, siis X-i vajutades teminatetakse terve programm.

Loodan, et sellest manuaalist oli kasu. Kui ei, siis lootusetu juhtum......

see veel siiski ei ole. Tuleb veel veidi rohkem süveneda ja mitte

omandada kogu materjal korraga, vaid peatükkide kaupa.

Date post:	06-Jul-2018
Category:	Documents
Upload:	anonymous-m2iwcy
View:	227 times
Download:	0 times

Learn java by Alex 2011.pdf

Documents