Java algajatele (5)

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 on alati 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". Paketi loomine:
Klassi loomine:
Nüüd, kui klass pole veel avanenud, teeme kataloogipuus sellele topelt klõpsu, meile avaneb selline pilt: 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: 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. 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, muutub muutuja ,,suvalinetekst" väärtus. 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, saame muutujate väärtuseks omistada teisi muutujaid või tehteid nendega. Samuti pöörakem tähelepanu reale cba=cba+abc. 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 on veel, 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. 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 selles klassis, 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! 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 sisendidNä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) 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. 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 a+b, 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 programmi kä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); 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 selle vä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.): 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