Amadeus_AlgJava KÄSIRAAMAT

Sissejuhatus
Keele AlgJava üldiseloomustus
Arenduskeskkond
Makrod

Programmi struktuur

Ekraanigraafika programmid
Konsooldialoogi kasutavad programmid
Jadafaile käitlevad programmid
Silumisvahendid
Rühmad ja kommentaarid

Täiendavaid küsimusi

Impordidirektiivid ja staatilised muutujad
Märgendatud stuktuurdirektiivid
Süsteemi omadused

Operatsioonisüsteemidevaheline migratsioon
Projekti tegevusteosa
Pildid

Java rakendusteek (API, Application Programming Interface)
      Klassi Math meetodite lühikirjeldused (ingl. k.)
      Klassi String meetodite lühikirjeldused (ingl. k.)
      Klassi Integer meetodite lühikirjeldused (ingl. k.)
      Klassi Double meetodite lühikirjeldused (ingl. k.)
      Klassi Graphics meetodite lühikirjeldused (ingl. k.)

Sissejuhatus

Süsteem Amadeus_AlgJava võimaldab väga kiiresti luua ja katsetada lihtsamaid Java-põhiseid programme, mille najal omandada programmeerimise põhimõisteid ja peamisi töövõtteid. Vastavas programmeerimiskeeles AlgJava on kasutatavad kõik Java primitiivid ja väga paljud Java standardklasside meetodid (sh kõik vahendid paketist java.lang), puudub aga võimalus ilmutatult arendada mitmeklassilisi programmsüsteeme.
Kasutajale pakutakse mitmeid lihtsustusi, näiteks eeldefineeritud raami ekraanigraafikaga tegelemiseks, väljastamiskorralduse [System.out.]println(...) analoogi-antipoodi readln() konsoolilt sisestamiseks jt. Silumist hõlbustab võimalus lisada AlgJava programmi vahepeatusi, milles saab inspekteerida vastavas vahepeatuses "tellitud" avaldiste väärtusi.

Kõik süsteemiga Amadeus_AlgJava kaasapandud näiteprogrammid kuuluvad projekti AlgJavaDemo.

Keele AlgJava üldiseloomustus

Üks elementaarkäsk on üks AlgJava primitiiv (ja lõpeb semikooloniga).

Kõik primitiivid kirjutatakse keeles Java.
Java struktuurid (meetodikirjeldused ja juhtimisdirektiivid) luuakse terviklike skeemidena. Looksulge programmi kirjutaja ise (ühekaupa) ei pane.

Erandina on sisse toodud järgmised lihtsustused:
käskude System.out.println(… ja System.out.print(…
asemel võib kasutada println(… ja print(…

jadatsükli päise for(int i = a; i <= b; i++)
asemel võib kirjutada i = a .. b (vähemalt 2 järjestikust punkti)

lõpmatu tsükli päise for(;;) võib jätta kirjutamata.

AlgJava programmi tegelikuks põhiosaks on üks Java klass - peaklass nimega Main.
Kasutaja programmis on kõik klassidega seonduv peidetud.
Samuti on peidetud peameetod (public static void main (String[] args)… ).
Programmi esimesed read (impordidirektiive ja staatilisi muutujaid arvestamata) kuni esimese meetodikirjelduseni (või programmi lõpuni, kui meetodikirjeldusi ei ole) moodustavad peameetodi sisu.
Kõik meetodikirjeldused esindavad klassimeetodeid ja paiknevad programmi lõpus. Meetodikirjelduse päises ei näidata piiritlejaid (public static …), automaatselt lisatakse aga piiritleja static.
Ekraanigraafika programmeerimise toetuseks tagatakse ühe graafilise raami (akna) olemasolu. Vastav isend luuakse programmeerija eest peidetult, selle osutiks (nimeks) on raam.
Konsooldialoogi programmeerimise toetuseks tagatakse (Javas vahetult puuduv) võimalus kasutada klaviatuurilt sisestamise meetodit readln.
Tekstiliste jadafailide lugejaid ja kirjutajaid võib deklareerida lihtsustatud moel.
Silumise hõlbustamiseks saab programmi lisada vahepeatuste (AlgJava-spetsiifilisi) primitiive.

Arenduskeskkond

Arenduskeskkond on loodud süsteemi Amadeus baasil. Selles süsteemis käideldakse tavapäraste lihttekstide asemel nn. skeemtekste, mille põhielemendiks on skeem. Skeem koosneb ühest või mitmest harust. Iga haru sisaldab oma liikmetena primitiive ja (alam)skeeme. Primitiiv kirjutatakse lihttekstina ühel või mitmel real. Nii skeemil kui ka harul võib olla veel (primitiivina esitatud) päis.
Kaheharulise skeemi struktuur:

- Skeemi algus
[SKEEMI PÄIS -- primitiiv]
- Haru (1)
[HARU PÄIS -- primitiiv]
   LIIGE -- primitiiv või alamskeem
   LIIGE -- primitiiv või alamskeem
             ...
- Haru (2)
[HARU PÄIS -- primitiiv]
   LIIGE -- primitiiv või alamskeem
   LIIGE -- primitiiv või alamskeem
             ...
- Skeemi lõpp

Nii skeemi, haru kui ka primitiivi teksti võib varustada kommentaariga, milleks on (roheline) üherealine lihttekst. Skeemi kommentaar kirjutatakse skeemi algusesse (dubleeritakse automaatselt skeemi lõpus). Haru kommentaar kirjutatakse haru algusesse. Primitiivi teksti kommentaar paikneb selle teksti viimase rea järel.
Tühja lihtteksti korral kuvatakse spetsiaalne sümbol » näitamaks lihtteksti (edaspidise kirjutamise) alguskohta.
Arendaja töötab peamiselt kahe aknaga. Üks neist on projektiaken, milles kuvatakse projekt ehk projektikirjeldus. Teises aknas - programmiaknas - on parajasti toimetatav ehk jooksev AlgJava programm. Viimase käivitamisel tekib lisaks konsooliaken tulemuste näitamiseks ning graafikaprogrammi korral veel graafilist pilti kuvav aken.
Projekti esimeses harus kirjeldatakse vajalikud kaustateed (sektsioonis Paths) ning jooksva programmi avamise ning salvestamise puhul tehtavad tegevused (vastavalt sektsioonides Open-script ning Save-script).

Süsteemiga Amadeus_AlgJava tulevad kaasa kaks projekti. Vastavad failid AlgJavaDemo.html ja AlgJavaWorks.html paiknevad kaustas .\Portfolio. Nende projektide esimesed harud erinevad ainult projektis vaadeldavate programmide asukohakausta (Kaust) määratluse poolest. Need määratlused on esitatud sektsioonis Paths, vastavalt:
Kaust: .\demo
Kaust: .\workspace

Kui kasutaja piirdub ainult nende projektidega, näiteks vaatab demoprogramme kaustast .\demo ja loob oma uusi programme kaustas .\workspace, siis pole tarvidust projektikirjeduse esimest haru muuta. Selle võib üldse suletuna (ikoniseerituna, kokkuvoldituna) hoida. Projekti teises harus seisab selle projekti all käsitletavate AlgJava programmide nimekiri. Nimekirja korrigeerib kasutaja vastavalt programmide lisandumisele või ülearuseks muutumisele.
Kui kasutaja programm on muutunud ülearuseks, siis kustutatakse selle programmi nimi projektikirjeldusest ja eemaldatakse (operatsioonisüsteemi vahendiga) ka seda programmi sisaldav fail kaustast .\workspace.

Programmi avamiseks ehk töösse võtmiseks on kaks võimalust.

Hiire vasak kolmikklõps programmi nimel projektiaknas loob uue programmiakna ja laadib sellesse nimetatud programmi.
Menüükäsk Fail>Avada programmiaknas laadib sellessse aknasse programmi, mille nimi projektiaknas on (eelnevalt) valitud.

Töösse võetud programmi nimi projektiaknas värvitakse halliks.
Kui projekti programmide kaustas puudub avatav fail, siis luuakse programmiaknasse uus, tühi AlgJava programm.

Uue programmi koostamist alustataksegi uue nime lisamisega projektikirjeldusse ja selle järgneva avamisega.

Programmi nimi ei tohi sisaldada tühikut. Nime laiend (soovitatavalt .algjava) on kohustuslik.

Muudetud projekt salvestatakse projektiaknast menüükäsuga Fail>Eksportida

Väga soovitatav on projektikirjeldus salvestada otsekohe pärast selle muutmist.
Vastkoostatud uus programm ei vaja eraldi salvestamist, sest salvestamine toimub alati koos töötlemisega.

Programmi töötlemine initsieeritakse menüükäsuga Fail>Salvestada (või Ctrl+S) ja seisneb projekti sektsioonis Save-script kirjeldatud tegevuste sooritamises. Standardsete projektide (AlgJavaDemo ja AlgJavaWorks) korral nähakse ette programmi salvestamine, teisendamine Java-programmiks, viimase kompileerimine ja käivitamine järgmise skeemi kohaselt.

Olgu jooksva programmi nimeks Tere.algjava. Siis Fail>Salvestada (või Ctrl+S) puhul

salvestatakse programm faili Tere.algjava
koostatakse vastav Java programm, mis salvestatakse faili Tere.java
kompileeritakse: javac Tere.java (õnnestumise korral: tulemus ==> Main.class)
väljastatakse veateated ja lõpetatakse; või täidetakse java Main

Kompileerimisel ilmnenud vigade diagnoos (ingliskeelsena) kuvatakse eraldi aknas. AlgJava tasemel lokaliseeritakse (püütakse lokaliseerida) esimene viga. Vastav vea koht AlgJava programmis märgistatakse programmiaknas punase ruudukesena primitiivi ees.

Kui programmis on ette nähtud käsurea argumentide töötlemine, siis tuleb vajalik käsurea argumentide komplekt eelnevalt kirjutada projektis sektsiooni Save-script viimase rea lõppu.

Programmile vastava Java-programmi genereerimine eraldi tegevusena:
Valida kogu AlgJava programm, seejärel Teisendus>Tekstualiseerida. Tulemus kuvatakse eraldi aknas.
Võimalik on (vaatlemiseks) teisendada Javasse vaid mingi osa programmist. Selleks eelnevalt võtta see osa omaette rühmaks (valida osa ja Toimeti>Haarata e. Ctrl+E ); seejärel Teisendus>Tekstualiseerida .

Programmi salvestamine teise nimega sooritatakse programmiaknast menüükäsuga
Fail>Eksportida

NB! Vaikimisi pakutakse selliselt salvestatava programmi nime laiendiks html, mitte algjava.
NB! Parajasti aknas olev jooksev programm jääb endiseks, st. ei muutu ei programmi ega programmiga seotud faili nimi.

Programmi sulgemiseks suletakse (×) programmiaken.

Makrod

Süsteemiga Amadeus_AlgJava tuleb kaasa vähemalt kolm komplekti makrosid. Makrode komplektid paiknevad kaustas .\macros (failidena, mille nimelaiendiks on html). Süsteemi käivitamisel (startimisel) aktiveeritakse makrod komplektidest, mille failinimed on antud omadustefailis Amadeus.properties. Standardselt aktiveeritakse makrod komplektidest AltGrMacro.html, AlgJavaMacro.html ja Kirillitsa.html. Aktiveeritud makrod on näha käivitatud süsteemi avaraamis (raamis, mis tekib käivitamisel kõige esimesena), sektsioonis nimega Macros activated.
Märkus. Kui omadustefailis on määratud
locale = RUS
või
locale = ENG
siis komplekti AlgJavaMacro asemel aktiveeritakse vastavalt kas AlgJavaMacroRUS või AlgJavaMacroENG.

Iga makrode komplekt on mitmeharuline skeem, kus iga haru esindab ühte makrot. Makro nimeks on haru kommentaar (roheline, kuni esimese tühikuni), sisuks aga haru sisu. Programmi toimetamise ajal saab makro sisu programmi lisada, hoides all klahvi Alt ja tippides samal ajal makro nime.
Näiteks nurksulupaar lisatakse, kui sisestatakse Alt+88; teksti println("_"); lisamiseks piisab sisestada Alt+pr, ekraanigraafika programmi malli lisamiseks tuleb vaid sisestada Alt+gr jne.

Uue makrode komplekti tegemine:

kopeerida AlgJavaMacro.html, nt faili MinuAlgJavaMacro.html

avada see fail: Raam>Uus + Fail>Importida ... MinuAlgJavaMacro.html
modifitseerida, kirjutada uued makrod (haru lisamiseks F5), eemaldada mittevajalikud.
salvestada see fail: Fail>Eksportida ... MinuAlgJavaMacro.html

Süsteemi omaduste failis täiendada omadus myMacros failinimega MinuAlgJavaMacro.
Järgmisel süsteemi startimisel aktiveeritakse siis ka makrode komplekt MinuAlgJavaMacro.html.
Uude makrode komplekti ei ole soovitatav lülitada ühetähelisi makrosid, st. makrosid, mille nimeks on üks täht.

Ajutiselt (jooksva seansi ajaks), näiteks proovimise eesmärgil, võib modifitseerida ka süsteemi avaraamis kuvatavaid makrokomplekte. Raami muudetud sisu ei ole vaja salvestada, lisatud/muudetud makrod on koheselt kasutatavad.

Programmi struktuur

AlgJava programm koosneb primitiivliikmetest (ehk primitiividest) ja skeemidest.

Primitiividena esitatakse järgmised Java lihtdirektiivid:

Lihtdirektiivi nimetus	Nimetus ingl. k.	Tüüpiline üldkuju ([] - puududa võiv osa)
muutujakirjeldus	variable declaration	tüüp muutujaNimi [= algväärtus];
meetodi väljakutse	method call statement	meetodiNimi([argum1, argum2, ...]);
omistamisdirektiiv	assignment statement	muutujaNimi [tehtemärk]= avaldis;
muu avaldisdirektiiv	expression statement	muutujaNimi++; või muutujaNimi--; ++muutujaNimi; või --muutujaNimi;
katkestusdirektiiv	break statement	break; tsükli- või lülitidirektiivis
jätkamisdirektiiv	continue statement	continue; tsüklidirektiivis
naasmisdirektiiv	return statement	return; meetodikirjelduses (ka peameetodi sisus) return ...; meetodikirjelduses
erindiseade direktiiv	throw statement	throw new ...Exception(...);
tühidirektiiv	empty statement	;

Tühi primitiiv luuakse sisestusklahvi Enter vajutamisega. Vajalikud sümbolid sisestatakse sellesse klaviatuurilt. Lihtdirektiivi viimaseks sümboliks on alati semikoolon.
Primitiiv on reeglina üherealine. Kuid võib kasutada ka poolitamist, milleks (primitiivil kursoriga sobivas kohas olles) vajutada klahvi F6. Poolitus annulleeritakse klahviga Backspace.
Ükski Java lihtdirektiiv ei saa olla jaotatud mitmesse primitiivi.

Skeemidena esitatakse Java struktuurid - struktuurdirektiivid ja meetodid:

Struktuuri nimetus	Nimetus ingl. k.	Tühi skeem luuakse klahviga	Tühi haru lisatakse klahviga
tingimusdirektiiv	if statement	F1	F5
tsüklidirektiiv	for statement / while statement	F2
meetodikirjeldus (meetod)	method declaration	F3
lülitidirektiiv	switch statement	F4	F5
katsendidirektiiv	try-catch statement	Shift + F4	F5

Skeeme kasutatakse veel programmi liikmete rühmade moodustamiseks.

Üldiselt koosneb AlgJava programm kahest järjestikusest osast:

Esimene osa: põhiosa (ehk peameetodi sisu).
Teine osa: meetoditena kirjeldatud abitegevused (alamülesannete lahendamise eeskirjad).

Teine osa võib ka puududa. Üheosalise AlgJava programmi näide vt (projektis AlgJavaDemo):
Tere.algjava

AlgJava programmi esimene osa sisaldab lihtdirektiive ja struktuurdirektiive (väljaarvatud meetodikirjeldused).
Meetodikirjeldused saavad esineda ainult teises osas. Ükski meetodikirjeldus ei sisaldu mingis teises meetodikirjelduses.
Meetodikirjelduses paiknevad vastava alamülesande lahendamist kirjeldavad lihtdirektiivid ja struktuurdirektiivid (väljaarvatud meetodikirjeldused). Kaheosalise AlgJava programmi näide vt:
Meetodid.algjava

Keerukamate programmide korral kaastakse programmi lisandeid, mille nimed loetletakse programmi haru kommentaaris (rohelisena). Tühja loetelu kohta tähistab alakriips.

Programmi teksti toimetamine

Toimetamine toimub ainult lisamisrežiimis, ülekirjutamisrežiim puudub.

Paljud toimetamisvõtted on tavapärased, näiteks:
Ctrl+c - valitud osa kopeerimine Amadeus_AlgJava lõikelauale;
Ctrl+v - kleepimine Amadeus_AlgJava lõikelaualt;
Ctrl+x - valitud osa kustutamine (koos kopeerimisega Amadeus_AlgJava lõikelauale);
Ctrl+z - tagasivõtt;
Ctrl+y - tagasivõtu tagasivõtt.

Eelmises jaotises on toodud klahvi Enter ning funktsionaalklahvide F1-F6 tähendused, jaotises silumisvahendid aga klahvi F7 otstarve.

Selleks, et lisada/kleepida olemasoleva struktuurdirektiivi j ä r e l e uus primitiiv, struktuurdirektiiv või vahepeatus, tuleb kursor eelnevalt viia selle struktuurdirektiivi (skeemijoone) algusesse.

Ühislõikelaual (system clipboard ) olevat teksti saab AlgJava programmi lülitada menüükäsuga Toimeti>Tuua. Seejuures kopeeritakse toodav tekst ühtlasi ka Amadeus_AlgJava lõikelauale. Kui toodav tekst on mitmerealine, siis iga rida tuuakse omaette primitiivliikmeks.

Ühekordne vasak hiireklõps valib lähima minimaalse tervikkonstruktsiooni. Terve skeemi valimiseks: vasak hiireklõps skeemi alguses (vasakus ülemises nurgas). Terve skeemi saab valida ka kahekordne vasaku hiireklõpsuga skeemijoonel. Haru valimiseks - vasak hiireklõps skeemijoonel (haru kohal).

Üldiselt, kahekordne vasak hiireklõps annab "järgu võrra" laiendatud valiku.

Ühekordne parem hiireklõps ikoniseerib/deikoniseerib parajasti valitud skeemi.
Kahekordne parem hiireklõps ikoniseerib/deikoniseerib kõik skeemid parajasti valitud tasemel.

Hiire vedamise teel saab valida ainult ekraanil olevaid konstruktsioone. Suurema osa valimiseks tuleb enne täiendavalt moodustada ja kokku voltida (ikoniseerida) alamrühmi, kasvõi ajutiselt.

Ekraanigraafika programmid

Kui AlgJava programmi algusesse (haru kommentaaris, rohelisena) kirjutada lisandi nimi raam, siis saab selles programmis kasutada vaikimisi loodavat graafilist raami. Raamiga seotud korraldused, nagu
   raam.setSize(..., ...);
   raam.setLocation(..., ...);
   raam.setTitle("...");
   raam.setVisible(true);
   raam.toFront();

kirjutatakse programmi esimesse ossa. Raamis joonise valmistamine kirjeldatakse eraldi meetodis, mille signatuuriks on
   joonistada(Tahvel t, Graphics g).
Meetodis joonistada kasutatakse selliseid graafikakäske nagu
   t.setBackground(…);
   t.getSize();
       g.setColor(…);
   g.drawString(…);
       g.fillOval(…); jt.,
mis toimetavad raamis oleva tahvliga t või selle graafikakontekstiga g.
Meetodis joonistada võib omakorda muidugi rakendada teisi vajalikke meetodeid.

Raamis olev tahvel on hiiretundlik: iga hiireklõps tahvlil käivitab tahvli ümberjoonistamise (rakendub meetod joonistada).
Tahvli t oleku meelespidamiseks võib meetodis joonistada kasutada tahvli (nähtamatut) nime, mille saab kätte tahvli meetodiga
t.getName(); // tagastatakse nimi sõnena
ja millele saab omistada sõne s tahvli meetodiga
t.setName(s); .
Tahvli nime algväärtuseks on null.

Ekraanigraafika-alaseid AlgJava programmide näiteid vt:

   Graafika00.algjava
   Graafika.algjava
   GraafikaVarvid.algjava
   MusterRek.algjava

Märkus. Soovitatav on hoiduda ekraanigraafika ja konsooldialoogi kooskasutamisest.

Graafilisse raami väljastatavatesse sõnedesse, meetodis g.drawString (operatsioonisüsteemi Windows korral ka meetodis raam.setTitle), võib lülitada vene tähti.

Konsooldialoogi kasutavad programmid

Kui AlgJava programmi algusesse (haru kommentaaris, rohelisena) kirjutada lisandi nimi readln(), siis saab selles programmis kasutada vaikimisi lisatud meetodit readln. Viimase täitmine seisneb selles, et oodatakse, kuni konsoolilt sisestatakse sümbolite järjend (kuni klahvi Enter vajutuseni) ja seejärel tagastatakse konsoolilt saadud sõne. Konsooldialoogi kasutava programmi näide vt:
Dialoog.algjava

Jadafaile käitlevad programmid

Kui AlgJava programmi algusesse (haru kommentaaris, rohelisena) kirjutada lisandi nimi I/O, siis saab selles programmis kasutada vaikimisi lisatud meetodeid readerFrom ja writerTo. Vt ka näiteprogramm
   Tekstifailid.algjava.

Tekstilisest, ridadest koosnevast sisendfailist (näiteks nimega s) ridade lugeja avatakse korraldusega
   BufferedReader lugeja = readerFrom(s);
Taolise avamiskorralduse malli saab programmi teksti lisada makroga Alt+from.
Seejärel järjekordse rea (tüüpi String) tagastab rakendus
   lugeja.readLine()
kui ridu enam ei ole siis ülaltoodud avaldise väärtuseks on null.
Lugeja suletakse korraldusega
   lugeja.close();

Tekstilisse väljundfaili (näiteks nimega v) ridade kirjutaja avatakse korraldusega
   PrintWriter kirjutaja = writerTo(v);
Taolise avamiskorralduse malli saab programmi teksti lisada makroga Alt+to.
Seejärel järjekordne rida r (tüüpi String) lisatakse väljundfaili korraldusega
   kirjutaja.println(r);
Kirjutaja suletakse korraldusega
   kirjutaja.close();

Avamise, lugemise, kirjutamise ja sulgemise korraldused tuleb paigutada katsendidirektiivi.
Taolise katsendidirektiivi malli saab programmi teksti lisada makroga Alt+io.

Silumisvahendid

Kui AlgJava programmi algusesse (haru kommentaaris, rohelisena) kirjutada lisand > , siis saab selles programmis kasutada vahepeatusi.
Vahepeatuse koht (break point) lisatakse programmi menüükäsuga Lisada>Vahepeatus (või klahviga F7). Süsteem märgistab vahepeatuse primitiivi (vasakult) sümboliga > ja kuvab kogu primitiivi erivärvilisena. Primitiivi algusesse saab kirjutada vahepeatuse kohanime (tühikuteta ja jutumärkideta sõne). Primitiivi võib lõpetada ühe inspekteerimiskorraldusega.
Kui programmi täitmisega jõutakse vahepeatuseni, siis väljastatakse ühte ritta:

jooksva meetodi nimi (main -- peameetodi, st. AlgJava programmi esimese osa korral)
>
kohanimi (kui on)
info inspekteerimiskorralduse täitmisest (kui on)

Seejärel jäädakse ootama jätkamisluba klaviatuurilt, milleks on suvasisestus, tüüpiliselt vaid Enter.
Märkus. Ekraanigraafika programmi täitmisel jätkamisluba ootama ei jääda.

Vahepeatuse primitiivi süntaks:
> [kohanimi] [inspekteerimiskorraldus]
Vahepeatuse kohanimeks on tühikute- ja jutumärkidevaba sõne.
AlgJava inspekteerimiskorraldusteks on inspect ja inspectArray. Inspekteerimiskorraldused AlgJava programmis võimaldavad vaadelda antud muutujate ja avaldiste väärtusi või antud massiivi kõigi elementide väärtusi.

Inpekteerimiskorralduse inspect süntaks:
inspect (koolon argument)+
kus argumendiks on üks järgmistest kirjutistest:

lihtmuutuja
ühemõõtmelise massiivi element ( kujul nimi[indeksavaldis] )
(avaldis)

Avaldises ei tohi esineda ühtegi jutumärki. Ümbritsevad sulud võib ära jätta, kui avaldises ei esine nurksulge.
Inpekteerimiskorralduse inspect täitmisel väljastatakse konsoolile iga argumendi korral koolon ning vastavalt

antud lihtmuutja nimi, võrdusmärk ja lihtmuutuja väärtus
massiivielemendi indeksavaldis, võrdusmärk ja indeksavaldise väärtus ning antud massiivielement, võrdusmärk ja massiivielemendi väärtus; kui indeksavaldiseks on täisarv-literaal, siis selle väärtust eraldi ei väljastata
antud avaldis, võrdusmärk ja avaldise väärtus.

Näiteid

Vahepeatus (meetodis mtd)	Vahepeatuses konsoolile väljastatava info näide
> A inspect :k :y :i	mtd>A: k = -234 : y = 13.075 : i = 3
> B inspect :a[0] :a[i-1]	mtd>B: a[0] = 20 : i-1 = 2 a[i-1] = 40
> pindala inspect :Math.PI * y * y	mtd>pindala: Math.PI * y * y = 537.0729355898515
> alla_100? inspect :(a[0]+a[i-1]/8)	mtd>alla_100?: (a[0] + a[i-1]/8) = 25
> inspect :i :y	mtd>: i = 3 : y = 13.075
> algab_sisemine_tsykkel	mtd>algab_sisemine_tsykkel:

Inspekteerimiskorralduse inspectArray süntaks:
inspectArray koolon massiiviNimi

Korralduse inspectArray ainukeseks argumendiks on ühemõõtmelise massiivi nimi (osuti) . Täitmisel väljastatakse koolon, antud massiivi nimi (osuti), nurksulupaar, koolon ja massiivi kõigi elementide väärtused.

Näiteid

Vahepeatus (meetodis mtd)	Vahepeatuses konsoolile väljastatava info näide
> enne_tsyklit inspectArray :a	mtd>enne_tsyklit:a[]: 30 320 -40 50
> peale_tsyklit inspectArray :a	mtd>peale_tsyklit:a[]: -40 30 50 320
> i-s_rida inspectArray :tabel[i]	mtd>i-s_rida:tabel[i][]: 0 -310 0 725 -1

Kui programmi alguses lisand > puudub, siis programmis olevaid vahepeatusi (seega ka korraldusi inspect ja inspectArray) lihtsalt ignoreeritakse.

Kõik vahepeatused eemaldatatakse AlgJava programmist (täpsemalt: valitud programmiosast) menüükäsuga Teisendus>Redutseerida.

Rühmad ja kommentaarid

AlgJava programmis võib moodustada suvalisi järjestikuste liikmete (ja rühmade) rühmi. Keelatud on vaid sellise "segarühma" loomine, mis hõlmab peameetodi (viimaseid) liikmeid ja mingit meetodikirjeldust.
Rühma moodustamiseks valitakse vajalik osa ekraanil (veetakse hiirega üle); seejärel menüükäsk Toimeti>Haarata (ehk Ctrl+E) võtab valitud osa päiseta lihtskeemi. Rühma kujutava lihtskeemi avamiseks: valida see skeem (vasak hiireklõps skeemijoonel) ja rakendada Toimeti>Togida (ehk Ctrl+T). Avada ei saa kommentaariga varustatud skeemi.
See, kuidas programm on rühmitatud, ei mõjuta kuidagiviisi programmi täitmist. Rühmale saab anda nime (ehk rühma kommentaari), kirjutades rühma skeemijoone algusesse (rohelisena) suvalise (kuid mitte kahe kaldkriipsuga algava) teksti. Nimega rühmi on hea voltida (ikoniseerida), sest nimi jääb ka ikooni juures nähtavaks.
Kogu rühma väljakommenteerimiseks tuleb rühmale anda kahe kaldkriipsuga algav nimi. Selliselt märgitud rühm elimineeritakse vastava Java-programmi koostamisel.
Primitiivliikme väljakommenteerimiseks tuleb selle algusesse kirjutada kaks kaldkriipsu. Vastav rida lülitatakse Java-programmi (reakommentaarina).
Primitiivliikme kommenteerimiseks lisatakse primitiivi kommentaar (rohelisena). Viimane kandub Java-programmi, kusjuures lisandub kahest kaldkriipsust koosnev prefiks.
Struktuurdirektiivile ja meetodikirjeldusele saab lisada kommentaare nii algusesse kui ka iga haru algusesse (rohelistena). Üldiselt sellised kommentaarid ei kandu üle vastavasse Java-programmi. Erandiks on struktuurdirektiivi märgend.
Nii rühmade nimedes kui ka kõikides teistes kommentaarides võib kasutada suvalisi sümboleid, sealhulgas ka vene tähti.
Vt. ka näiteprogramm Graafika.algjava.

Täiendavaid küsimusi

Impordidirektiivid ja staatilised muutujad

Programmi põhiosa ette võib lisada impordidirektiive ja staatiliste muutjate kirjeldusi. Näiteks

import javax.swing.JOptionPane; // impordidirektiiv
static boolean on = true; // staatilise muutuja (on) kirjeldus

Staatiline muutuja on kasutatav kõikides meetodites, kaasaarvatud programmi põhiosa (ehk peameetod).
Impordidirektiive ja staatiliste muutjate kirjeldusi ei tohi võtta rühma liikmeteks.

Märgendatud stuktuurdirektiivid

Struktuurdirektiivi märgend kirjutatakse vastava skeemi algusesse (skeemikommentaari kohale). Märgend peab olema Java identifikaator ja unikaalne programmi piires. Vastavasse Java-programmi, struktuurdirektiivi ette lisandub selle struktuurdirektiivi kooloniga varustatud märgend.
Märgendatud struktuurdirektiivi sees, sügavamatel tasemetel, saab kasutada katkestusdirektiivi kujul
break märgend; // katkestatakse selle struktuurdirektiivi täitmine
või, juhul kui märgendatud on tsüklidirektiiv, jätkamisdirektiivi kujul
continue märgend; // katkestatakse selle tsüklidirektiivi sisu täitmine

Süsteemi omadused

Süsteemi omadused sätestatakse failis Amadeus.properties. Need võetakse arvesse süsteemi igal käivitamisel.
NB! Separaator '\' kirjutatakse kahekordselt ('/' -- ühekordselt).

Omaduse nimetus	Väärtuse kuju; vaikeväärtus	Otstarve	Näide
AmadeusDirectory	Täistee	Tee Amadeus_AlgJava kodukaustani	AmadeusDirectory = D:\\AlgJava
defaultOpenDirectory	Täistee; vaikimisi: jooksev (.)	Otsimistee algus failidialoogides	defaultOpenDirectory = D:\\AlgJava\\Portfolio
myMacros	( fNimi[.tüüp] )+ Vaikimisi: tüüp = html	Algselt aktiveeritavate makrokomplektide failinimede loend	myMacros = AltGrMacro AlgJavaMacro
startProject	Projektikirjelduse faili nimi; vaiketüüp: html	Süsteemi stardil avatav projekt	startProject = AlgJavaWorks
defaultFont	nimi, stiil, suurus stiil: 0-plain / 1-bold / 2-italic/ 3-*bolditalic*	Kasutatav kiri (font)	defaultFont = Times New Roman, 1, 14
iconImageFileName	Vaikimisi: AmadeusDirectory \\gif\\collapsed.gif	Faili nimi, millest võetakse ikooni pilt	iconImageFileName = D:\\Algjava\\gif\\collapsed2.gif
autoSaveTimePeriod	Märgita täisarv; vaikimisi 1	Mitme minti järel toimub avatud failide automaatsalvestus	autoSaveTimePeriod = 3
locale	ENG \| EST \| RUS Vaikimisi: ENG	Süsteemi keelsus	locale = EST
selectionIntensity	LIGHT \| DARK Vaikimisi: DARK	Valiku kujutamise värvitugevus	selectionIntensity = LIGHT

Operatsioonisüsteemidevaheline migratsioon

NB! Jaosfailisüsteemide korral tuleb erinevates operatsioonisüsteemides töötada erinevates AlgJava kodukaustades.

Migratsioon operatsioonisüsteemist A operatsioonisüsteemi B:

Varem on töötatud operatsioonisüsteemis A kodukaustas AlgJavaA. Koostatud programmid paiknevad kaustas workspace.
Soovitakse üle minna töötamisele nende programmidega operatsioonisüsteemi B.

Tuleb: üle kanda programmid (*.algjava) ja projektis vastavalt täiendada programmide nimekirja.

Täpsemalt:

1. Luua AlgJava kodukaust AlgJavaB (kui veel ei ole).

2. Tuua üle (kopeerida) programmid *.algjava:
   AlgJavaA|workspace ==> AlgJavaB|workspace    (| tähistab separaatorit, \ või /)

3. Kodukaustas AlgJavaB startida (operatsioonisüsteemis B) tavalisel viisil Amadeus_AlgJava

4. Avada projekt AlgJavaWorks (kui veel ei ole avatud), sellesse tuua üle programmide nimekiri, nt:
   Raam>Uus
   Fail>Importida ... AlgJavaA|Protfolio|AlgJavaWorks.html
   Valida seal programmide nimekiri, kopeerida (Ctrl+c).
   Minna projektiaknasse (B), kleepida (Ctrl+v).
   Salvestada projekt (B): Fail>Eksportida ... AlgJavaB|AlgJavaWorks.html

5. Kui varasemal töötamisel oli muudetud makrofaili (nt. MyAlgJavaMacro.html), siis tuleb ka see üle kanda:
    AlgJavaA|macros|MyAlgJavaMacro.html ==> AlgJavaB|macros|MyAlgJavaMacro.html

6. Kui varasemal töötamisel oli muudetud süsteemi omadusi, siis võiks korrigeerida ka süsteemi omadustefaili
   AlgJavaB|Amadeus.properties faili AlgJavaA|Amadeus.properties eeskujul.
   Muudatused sätestuvad järgmisel stardil.

Projekti tegevusteosa

Projekti tegevusteosa paikneb projekti esimese harus (teises harus asub projekti kuuluvate AlgJava programmide failinimede loetelu). Tegevusteosa omakorda koosneb kolmest sektsioonist (alamskeemist) nimedega Paths, Open-script ja Save-script.
Järgnevas selgitatakse projekti tegevusteosa projekti AlgJavaDemo näitel. Teine süsteemiga kaasatulev projekt AlgJavaWorks on sellega üsna sarnane, ainult töökaustaks on workspace, mitte demo.

Esimeses sektsioonis (Paths) deklareeritakse nimed, mida kasutatakse ülejäänud kahes sektsioonis, aga ka selle sektsiooni järgmistes primitiivides:
Paths
   Kaust: .\demo                                                    --- Linuxi ja SunOS puhul: Kaust: ./demo
   JavaComp: javac -sourcepath "{Kaust}" -classpath "{Kaust}" -d "{Kaust}"
   JavaRun: runMain.bat "{Kaust}"
   JavaRunGr: java -cp "{Kaust}" Main --- Linuxi ja SunOS puhul: runMainGr.bat "{Kaust}"
Defineeritud on siin nimed: Kaust, JavaComp, JavaRun ning JavaRunGr.

Teises sektsioonis (Open-script) kirjeldatakse menüükäsud (vaadeldava näite korral üks menüükäsk), mis täidetakse programmi avamisel.
Open-script
   Import: path=Kaust       --- tuua AlgJava programm programmiaknasse kaustast Kaust (seega .\demo)

Kolmandas sektsioonis (Save-script) kirjeldatakse menüükäsud ja protsess (käsurida), mis täidetakse, kui jooksva AlgJava programmi aknast sooritatakse Fail>Salvestada.
Järgnevates selgitustes loetakse jooksva programmi nimeks pr.algjava.
Save-script --- Windows
   Export plain-HTML: path=Kaust
             --- salvestada jooksev AlgJava programm pr.algjava programmiaknast kausta Kaust
   Textualize+Write text: path=Kaust ext=java
             --- tekstualiseerida jooksev AlgJava programm ja kirjutada tulemus pr.java kausta Kaust
   Process: " {JavaComp} path=Kaust ext=java
            && start "KONSOOL" {JavaRun} arg0 arg1 ... arg7 "
--- 1) kompileerida pr.java kaustast Kaust (õnnestumise korral salvestatakse tulemus Main.class kausta Kaust)
--- 2) startida uus konsooliaken (nimega KONSOOL) ja
--- 3) selles käivitada runMain.bat .\demo arg0 arg1 ... arg7
Save-script   --- Linux ja SunOS
   Export plain-HTML: path=Kaust
             --- salvestada jooksev AlgJava programm pr.algjava programmiaknast kausta Kaust
   Textualize+Write text: path=Kaust ext=java
         --- tekstualiseerida jooksev AlgJava programm ja kirjutada tulemus pr.java kausta Kaust
   Process: " export LANG=et_EE.iso8859-15     --- puudub SunOS korral
            && {JavaComp} path=Kaust ext=java
            && sh {JavaRun} arg0 arg1 ... arg7 "
--- (1) seada keskonnamuutuja LANG
--- 2) kompileerida pr.java kaustast Kaust (õnnestumise korral salvestatakse tulemus Main.class kausta Kaust)
--- 3) käivitada runMain.bat ./demo arg0 arg1 ... arg7

Käsufail
runMain.bat --Windows XP:
echo off
IF NOT EXIST "%systemroot%\system32\tasklist.exe" GOTO NOTASKLIST
IF NOT EXIST x.bat ECHO REM>x.bat
x 2> log1.txt 1>log.txt & ECHO REM > x.bat && tasklist /nh /fi "Imagename eq cmd.exe" |
java -cp . GetPID_WinXP > x.bat && java -cp %1 Main %2 %3 %4 %5 %6 %7 %8 %9
GOTO END
:NOTASKLIST
java -cp %1 Main %2 %3 %4 %5 %6 %7 %8 %9
:END
   Lihtsustatult (ei püüa järgmisel käivitamisel likvideerida eelmisel käivitusel tekkinud konsooliakent):
echo off
java -cp %1 Main %2 %3 %4 %5 %6 %7 %8 %9
Sellist lihtsustatud käsufaili võiks kasutada juhul, kui konkreetne Windows XP verioon ei luba käske tasklist ja
taskkill. Kui aga need käsud on täidetavad, siis võib soovi korral käsufailist eemaldada teise rea ja neli viimast rida:
echo off
IF NOT EXIST x.bat ECHO REM>x.bat
x 2> log1.txt 1>log.txt & ECHO REM > x.bat && tasklist /nh /fi "Imagename eq cmd.exe" |
java -cp . GetPID_WinXP > x.bat && java -cp %1 Main %2 %3 %4 %5 %6 %7 %8 %9

runMain.bat --Linux:
xterm -hold -geometry 100x60+100+100 -e java -cp $1 Main $2 $3 $4 $5 $6 $7 $8 $9

runMain.bat   --SunOS:
xterm -geometry 100x60+100+100 -e java -cp $1 Main $2 $3 $4 $5 $6 $7 $8 $9

Soovitus.
Graafikaprogrammide korral, kus konsooliaken ei oma tähtsust, võiks sektsioonis Save-script nime JavaRun asemel kasutada nime JavaRunGr. Linuxi ja SunOS puhul rakendub siis käsufail   runMainGr.bat:
xterm -e java -cp $1 Main $2 $3 $4 $5 $6 $7 $8 $9
Windowsi puhul aga lihtsalt käsk
java -cp "{Kaust}" Main

Pildid

Alates versioonist 70423 on süsteemi funktsionaalsust täiendatud mõningate (piiratud) pilditöötlusvahenditega. AlgJava teksti on võimalik pilte lisada ja neid sealt eemaldada. Teksti semantikat pildid reeglina ei mõjuta.
Pildifailid (*.gif, *.jpg, ...) paiknevad kaustas gif / pro.
Pilti ei saa lisada jooksvasse, projekti alt avatud AlgJava programmi.

Klassi Math meetodite lühikirjeldused

Method Summary
`static double`	`abs(double a)` Returns the absolute value of a `double` value.
`static float`	`abs(float a)` Returns the absolute value of a `float` value.
`static int`	`abs(int a)` Returns the absolute value of an `int` value.
`static long`	`abs(long a)` Returns the absolute value of a `long` value.
`static double`	`acos(double a)` Returns the arc cosine of an angle, in the range of 0.0 through pi.
`static double`	`asin(double a)` Returns the arc sine of an angle, in the range of -pi/2 through pi/2.
`static double`	`atan(double a)` Returns the arc tangent of an angle, in the range of -pi/2 through pi/2.
`static double`	`atan2(double y, double x)` Converts rectangular coordinates (`x`, `y`) to polar (r, theta).
`static double`	`cbrt(double a)` Returns the cube root of a `double` value.
`static double`	`ceil(double a)` Returns the smallest (closest to negative infinity) `double` value that is greater than or equal to the argument and is equal to a mathematical integer.
`static double`	`cos(double a)` Returns the trigonometric cosine of an angle.
`static double`	`cosh(double x)` Returns the hyperbolic cosine of a `double` value.
`static double`	`exp(double a)` Returns Euler's number e raised to the power of a `double` value.
`static double`	`expm1(double x)` Returns e^x -1.
`static double`	`floor(double a)` Returns the largest (closest to positive infinity) `double` value that is less than or equal to the argument and is equal to a mathematical integer.
`static double`	`hypot(double x, double y)` Returns sqrt(x² +y²) without intermediate overflow or underflow.
`static double`	`IEEEremainder(double f1, double f2)` Computes the remainder operation on two arguments as prescribed by the IEEE 754 standard.
`static double`	`log(double a)` Returns the natural logarithm (base e) of a `double` value.
`static double`	`log10(double a)` Returns the base 10 logarithm of a `double` value.
`static double`	`log1p(double x)` Returns the natural logarithm of the sum of the argument and 1.
`static double`	`max(double a, double b)` Returns the greater of two `double` values.
`static float`	`max(float a, float b)` Returns the greater of two `float` values.
`static int`	`max(int a, int b)` Returns the greater of two `int` values.
`static long`	`max(long a, long b)` Returns the greater of two `long` values.
`static double`	`min(double a, double b)` Returns the smaller of two `double` values.
`static float`	`min(float a, float b)` Returns the smaller of two `float` values.
`static int`	`min(int a, int b)` Returns the smaller of two `int` values.
`static long`	`min(long a, long b)` Returns the smaller of two `long` values.
`static double`	`pow(double a, double b)` Returns the value of the first argument raised to the power of the second argument.
`static double`	`random()` Returns a `double` value with a positive sign, greater than or equal to `0.0` and less than `1.0`.
`static double`	`rint(double a)` Returns the `double` value that is closest in value to the argument and is equal to a mathematical integer.
`static long`	`round(double a)` Returns the closest `long` to the argument.
`static int`	`round(float a)` Returns the closest `int` to the argument.
`static double`	`signum(double d)` Returns the signum function of the argument; zero if the argument is zero, 1.0 if the argument is greater than zero, -1.0 if the argument is less than zero.
`static float`	`signum(float f)` Returns the signum function of the argument; zero if the argument is zero, 1.0f if the argument is greater than zero, -1.0f if the argument is less than zero.
`static double`	`sin(double a)` Returns the trigonometric sine of an angle.
`static double`	`sinh(double x)` Returns the hyperbolic sine of a `double` value.
`static double`	`sqrt(double a)` Returns the correctly rounded positive square root of a `double` value.
`static double`	`tan(double a)` Returns the trigonometric tangent of an angle.
`static double`	`tanh(double x)` Returns the hyperbolic tangent of a `double` value.
`static double`	`toDegrees(double angrad)` Converts an angle measured in radians to an approximately equivalent angle measured in degrees.
`static double`	`toRadians(double angdeg)` Converts an angle measured in degrees to an approximately equivalent angle measured in radians.
`static double`	`ulp(double d)` Returns the size of an ulp of the argument.
`static float`	`ulp(float f)` Returns the size of an ulp of the argument.

Klassi String isendi- ja klassimeetodite lühikirjeldused

Method Summary
`char`	`charAt(int index)` Returns the `char` value at the specified index.
`int`	`codePointAt(int index)` Returns the character (Unicode code point) at the specified index.
`int`	`codePointBefore(int index)` Returns the character (Unicode code point) before the specified index.
`int`	`codePointCount(int beginIndex, int endIndex)` Returns the number of Unicode code points in the specified text range of this `String`.
`int`	`compareTo(String anotherString)` Compares two strings lexicographically.
`int`	`compareToIgnoreCase(String str)` Compares two strings lexicographically, ignoring case differences.
`String`	`concat(String str)` Concatenates the specified string to the end of this string.
`boolean`	`contains(CharSequence s)` Returns true if and only if this string contains the specified sequence of char values.
`boolean`	`contentEquals(CharSequence cs)` Returns `true` if and only if this `String` represents the same sequence of char values as the specified sequence.
`boolean`	`contentEquals(StringBuffer sb)` Returns `true` if and only if this `String` represents the same sequence of characters as the specified `StringBuffer`.
`static String`	`copyValueOf(char[] data)` Returns a String that represents the character sequence in the array specified.
`static String`	`copyValueOf(char[] data, int offset, int count)` Returns a String that represents the character sequence in the array specified.
`boolean`	`endsWith(String suffix)` Tests if this string ends with the specified suffix.
`boolean`	`equals(Object anObject)` Compares this string to the specified object.
`boolean`	`equalsIgnoreCase(String anotherString)` Compares this `String` to another `String`, ignoring case considerations.
`static String`	`format(Locale l, String format, Object... args)` Returns a formatted string using the specified locale, format string, and arguments.
`static String`	`format(String format, Object... args)` Returns a formatted string using the specified format string and arguments.
`byte[]`	`getBytes()` Encodes this `String` into a sequence of bytes using the platform's default charset, storing the result into a new byte array.
`void`	`getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)` Deprecated. This method does not properly convert characters into bytes. As of JDK 1.1, the preferred way to do this is via the `getBytes()` method, which uses the platform's default charset.
`byte[]`	`getBytes(String charsetName)` Encodes this `String` into a sequence of bytes using the named charset, storing the result into a new byte array.
`void`	`getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)` Copies characters from this string into the destination character array.
`int`	`hashCode()` Returns a hash code for this string.
`int`	`indexOf(int ch)` Returns the index within this string of the first occurrence of the specified character.
`int`	`indexOf(int ch, int fromIndex)` Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.
`int`	`indexOf(String str)` Returns the index within this string of the first occurrence of the specified substring.
`int`	`indexOf(String str, int fromIndex)` Returns the index within this string of the first occurrence of the specified substring, starting at the specified index.
`String`	`intern()` Returns a canonical representation for the string object.
`int`	`lastIndexOf(int ch)` Returns the index within this string of the last occurrence of the specified character.
`int`	`lastIndexOf(int ch, int fromIndex)` Returns the index within this string of the last occurrence of the specified character, searching backward starting at the specified index.
`int`	`lastIndexOf(String str)` Returns the index within this string of the rightmost occurrence of the specified substring.
`int`	`lastIndexOf(String str, int fromIndex)` Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the specified index.
`int`	`length()` Returns the length of this string.
`boolean`	`matches(String regex)` Tells whether or not this string matches the given regular expression.
`int`	`offsetByCodePoints(int index, int codePointOffset)` Returns the index within this `String` that is offset from the given `index` by `codePointOffset` code points.
`boolean`	`regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)` Tests if two string regions are equal.
`boolean`	`regionMatches(int toffset, String other, int ooffset, int len)` Tests if two string regions are equal.
`String`	`replace(char oldChar, char newChar)` Returns a new string resulting from replacing all occurrences of `oldChar` in this string with `newChar`.
`String`	`replace(CharSequence target, CharSequence replacement)` Replaces each substring of this string that matches the literal target sequence with the specified literal replacement sequence.
`String`	`replaceAll(String regex, String replacement)` Replaces each substring of this string that matches the given regular expression with the given replacement.
`String`	`replaceFirst(String regex, String replacement)` Replaces the first substring of this string that matches the given regular expression with the given replacement.
`String[]`	`split(String regex)` Splits this string around matches of the given regular expression.
`String[]`	`split(String regex, int limit)` Splits this string around matches of the given regular expression.
`boolean`	`startsWith(String prefix)` Tests if this string starts with the specified prefix.
`boolean`	`startsWith(String prefix, int toffset)` Tests if this string starts with the specified prefix beginning a specified index.
`CharSequence`	`subSequence(int beginIndex, int endIndex)` Returns a new character sequence that is a subsequence of this sequence.
`String`	`substring(int beginIndex)` Returns a new string that is a substring of this string.
`String`	`substring(int beginIndex, int endIndex)` Returns a new string that is a substring of this string.
`char[]`	`toCharArray()` Converts this string to a new character array.
`String`	`toLowerCase()` Converts all of the characters in this `String` to lower case using the rules of the default locale.
`String`	`toLowerCase(Locale locale)` Converts all of the characters in this `String` to lower case using the rules of the given `Locale`.
`String`	`toString()` This object (which is already a string!) is itself returned.
`String`	`toUpperCase()` Converts all of the characters in this `String` to upper case using the rules of the default locale.
`String`	`toUpperCase(Locale locale)` Converts all of the characters in this `String` to upper case using the rules of the given `Locale`.
`String`	`trim()` Returns a copy of the string, with leading and trailing whitespace omitted.
`static String`	`valueOf(boolean b)` Returns the string representation of the `boolean` argument.
`static String`	`valueOf(char c)` Returns the string representation of the `char` argument.
`static String`	`valueOf(char[] data)` Returns the string representation of the `char` array argument.
`static String`	`valueOf(char[] data, int offset, int count)` Returns the string representation of a specific subarray of the `char` array argument.
`static String`	`valueOf(double d)` Returns the string representation of the `double` argument.
`static String`	`valueOf(float f)` Returns the string representation of the `float` argument.
`static String`	`valueOf(int i)` Returns the string representation of the `int` argument.
`static String`	`valueOf(long l)` Returns the string representation of the `long` argument.
`static String`	`valueOf(Object obj)` Returns the string representation of the `Object` argument.

Klassi Integer isendi- ja klassimeetodite lühikirjeldused

Method Summary
`static int`	`bitCount(int i)` Returns the number of one-bits in the two's complement binary representation of the specified int value.
`byte`	`byteValue()` Returns the value of this `Integer` as a `byte`.
`int`	`compareTo(Integer anotherInteger)` Compares two `Integer` objects numerically.
`static Integer`	`decode(String nm)` Decodes a `String` into an `Integer`.
`double`	`doubleValue()` Returns the value of this `Integer` as a `double`.
`boolean`	`equals(Object obj)` Compares this object to the specified object.
`float`	`floatValue()` Returns the value of this `Integer` as a `float`.
`static Integer`	`getInteger(String nm)` Determines the integer value of the system property with the specified name.
`static Integer`	`getInteger(String nm, int val)` Determines the integer value of the system property with the specified name.
`static Integer`	`getInteger(String nm, Integer val)` Returns the integer value of the system property with the specified name.
`int`	`hashCode()` Returns a hash code for this `Integer`.
`static int`	`highestOneBit(int i)` Returns an int value with at most a single one-bit, in the position of the highest-order ("leftmost") one-bit in the specified int value.
`int`	`intValue()` Returns the value of this `Integer` as an `int`.
`long`	`longValue()` Returns the value of this `Integer` as a `long`.
`static int`	`lowestOneBit(int i)` Returns an int value with at most a single one-bit, in the position of the lowest-order ("rightmost") one-bit in the specified int value.
`static int`	`numberOfLeadingZeros(int i)` Returns the number of zero bits preceding the highest-order ("leftmost") one-bit in the two's complement binary representation of the specified int value.
`static int`	`numberOfTrailingZeros(int i)` Returns the number of zero bits following the lowest-order ("rightmost") one-bit in the two's complement binary representation of the specified int value.
`static int`	`parseInt(String s)` Parses the string argument as a signed decimal integer.
`static int`	`parseInt(String s, int radix)` Parses the string argument as a signed integer in the radix specified by the second argument.
`static int`	`reverse(int i)` Returns the value obtained by reversing the order of the bits in the two's complement binary representation of the specified int value.
`static int`	`reverseBytes(int i)` Returns the value obtained by reversing the order of the bytes in the two's complement representation of the specified int value.
`static int`	`rotateLeft(int i, int distance)` Returns the value obtained by rotating the two's complement binary representation of the specified int value left by the specified number of bits.
`static int`	`rotateRight(int i, int distance)` Returns the value obtained by rotating the two's complement binary representation of the specified int value right by the specified number of bits.
`short`	`shortValue()` Returns the value of this `Integer` as a `short`.
`static int`	`signum(int i)` Returns the signum function of the specified int value.
`static String`	`toBinaryString(int i)` Returns a string representation of the integer argument as an unsigned integer in base 2.
`static String`	`toHexString(int i)` Returns a string representation of the integer argument as an unsigned integer in base 16.
`static String`	`toOctalString(int i)` Returns a string representation of the integer argument as an unsigned integer in base 8.
`String`	`toString()` Returns a `String` object representing this `Integer`'s value.
`static String`	`toString(int i)` Returns a `String` object representing the specified integer.
`static String`	`toString(int i, int radix)` Returns a string representation of the first argument in the radix specified by the second argument.
`static Integer`	`valueOf(int i)` Returns a Integer instance representing the specified int value.
`static Integer`	`valueOf(String s)` Returns an `Integer` object holding the value of the specified `String`.
`static Integer`	`valueOf(String s, int radix)` Returns an `Integer` object holding the value extracted from the specified `String` when parsed with the radix given by the second argument.

Klassi Double isendi- ja klassimeetodite lühikirjeldused

Method Summary
`byte`	`byteValue()` Returns the value of this `Double` as a `byte` (by casting to a `byte`).
`static int`	`compare(double d1, double d2)` Compares the two specified `double` values.
`int`	`compareTo(Double anotherDouble)` Compares two `Double` objects numerically.
`static long`	`doubleToLongBits(double value)` Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout.
`static long`	`doubleToRawLongBits(double value)` Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout, preserving Not-a-Number (NaN) values.
`double`	`doubleValue()` Returns the `double` value of this `Double` object.
`boolean`	`equals(Object obj)` Compares this object against the specified object.
`float`	`floatValue()` Returns the `float` value of this `Double` object.
`int`	`hashCode()` Returns a hash code for this `Double` object.
`int`	`intValue()` Returns the value of this `Double` as an `int` (by casting to type `int`).
`boolean`	`isInfinite()` Returns `true` if this `Double` value is infinitely large in magnitude, `false` otherwise.
`static boolean`	`isInfinite(double v)` Returns `true` if the specified number is infinitely large in magnitude, `false` otherwise.
`boolean`	`isNaN()` Returns `true` if this `Double` value is a Not-a-Number (NaN), `false` otherwise.
`static boolean`	`isNaN(double v)` Returns `true` if the specified number is a Not-a-Number (NaN) value, `false` otherwise.
`static double`	`longBitsToDouble(long bits)` Returns the `double` value corresponding to a given bit representation.
`long`	`longValue()` Returns the value of this `Double` as a `long` (by casting to type `long`).
`static double`	`parseDouble(String s)` Returns a new `double` initialized to the value represented by the specified `String`, as performed by the `valueOf` method of class `Double`.
`short`	`shortValue()` Returns the value of this `Double` as a `short` (by casting to a `short`).
`static String`	`toHexString(double d)` Returns a hexadecimal string representation of the `double` argument.
`String`	`toString()` Returns a string representation of this `Double` object.
`static String`	`toString(double d)` Returns a string representation of the `double` argument.
`static Double`	`valueOf(double d)` Returns a Double instance representing the specified double value.
`static Double`	`valueOf(String s)` Returns a `Double` object holding the `double` value represented by the argument string `s`.

Klassi Graphics meetodite lühikirjeldused

Method Summary
abstract void	clearRect(int x, int y, int width, int height) Clears the specified rectangle by filling it with the background color of the current drawing surface.
abstract void	clipRect(int x, int y, int width, int height) Intersects the current clip with the specified rectangle.
abstract void	copyArea(int x, int y, int width, int height, int dx, int dy) Copies an area of the component by a distance specified by dx and dy.
abstract Graphics	create() Creates a new Graphics object that is a copy of this Graphics object.
Graphics	create(int x, int y, int width, int height) Creates a new Graphics object based on this Graphics object, but with a new translation and clip area.
abstract void	dispose() Disposes of this graphics context and releases any system resources that it is using.
void	draw3DRect(int x, int y, int width, int height, boolean raised) Draws a 3-D highlighted outline of the specified rectangle.
abstract void	drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) Draws the outline of a circular or elliptical arc covering the specified rectangle.
void	drawBytes(byte[] data, int offset, int length, int x, int y) Draws the text given by the specified byte array, using this graphics context's current font and color.
void	drawChars(char[] data, int offset, int length, int x, int y) Draws the text given by the specified character array, using this graphics context's current font and color.
abstract boolean	drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer) Draws as much of the specified image as is currently available.
abstract boolean	drawImage(Image img, int x, int y, ImageObserver observer) Draws as much of the specified image as is currently available.
abstract boolean	drawImage(Image img, int x, int y, int width, int height, Color bgcolor, ImageObserver observer) Draws as much of the specified image as has already been scaled to fit inside the specified rectangle.
abstract boolean	drawImage(Image img, int x, int y, int width, int height, ImageObserver observer) Draws as much of the specified image as has already been scaled to fit inside the specified rectangle.
abstract boolean	drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcolor, ImageObserver observer) Draws as much of the specified area of the specified image as is currently available, scaling it on the fly to fit inside the specified area of the destination drawable surface.
abstract boolean	drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer) Draws as much of the specified area of the specified image as is currently available, scaling it on the fly to fit inside the specified area of the destination drawable surface.
abstract void	drawLine(int x1, int y1, int x2, int y2) Draws a line, using the current color, between the points (x1, y1) and (x2, y2) in this graphics context's coordinate system.
abstract void	drawOval(int x, int y, int width, int height) Draws the outline of an oval.
abstract void	drawPolygon(int[] xPoints, int[] yPoints, int nPoints) Draws a closed polygon defined by arrays of x and y coordinates.
void	drawPolygon(Polygon p) Draws the outline of a polygon defined by the specified Polygon object.
abstract void	drawPolyline(int[] xPoints, int[] yPoints, int nPoints) Draws a sequence of connected lines defined by arrays of x and y coordinates.
void	drawRect(int x, int y, int width, int height) Draws the outline of the specified rectangle.
abstract void	drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) Draws an outlined round-cornered rectangle using this graphics context's current color.
abstract void	drawString(AttributedCharacterIterator iterator, int x, int y) Draws the text given by the specified iterator, using this graphics context's current color.
abstract void	drawString(String str, int x, int y) Draws the text given by the specified string, using this graphics context's current font and color.
void	fill3DRect(int x, int y, int width, int height, boolean raised) Paints a 3-D highlighted rectangle filled with the current color.
abstract void	fillArc(int x, int y, int width, int height, int startAngle, int arcAngle) Fills a circular or elliptical arc covering the specified rectangle.
abstract void	fillOval(int x, int y, int width, int height) Fills an oval bounded by the specified rectangle with the current color.
abstract void	fillPolygon(int[] xPoints, int[] yPoints, int nPoints) Fills a closed polygon defined by arrays of x and y coordinates.
void	fillPolygon(Polygon p) Fills the polygon defined by the specified Polygon object with the graphics context's current color.
abstract void	fillRect(int x, int y, int width, int height) Fills the specified rectangle.
abstract void	fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) Fills the specified rounded corner rectangle with the current color.
void	finalize() Disposes of this graphics context once it is no longer referenced.
abstract Shape	getClip() Gets the current clipping area.
abstract Rectangle	getClipBounds() Returns the bounding rectangle of the current clipping area.
Rectangle	getClipBounds(Rectangle r) Returns the bounding rectangle of the current clipping area.
Rectangle	getClipRect() Deprecated. As of JDK version 1.1, replaced by getClipBounds().
abstract Color	getColor() Gets this graphics context's current color.
abstract Font	getFont() Gets the current font.
FontMetrics	getFontMetrics() Gets the font metrics of the current font.
abstract FontMetrics	getFontMetrics(Font f) Gets the font metrics for the specified font.
boolean	hitClip(int x, int y, int width, int height) Returns true if the specified rectangular area might intersect the current clipping area.
abstract void	setClip(int x, int y, int width, int height) Sets the current clip to the rectangle specified by the given coordinates.
abstract void	setClip(Shape clip) Sets the current clipping area to an arbitrary clip shape.
abstract void	setColor(Color c) Sets this graphics context's current color to the specified color.
abstract void	setFont(Font font) Sets this graphics context's font to the specified font.
abstract void	setPaintMode() Sets the paint mode of this graphics context to overwrite the destination with this graphics context's current color.
abstract void	setXORMode(Color c1) Sets the paint mode of this graphics context to alternate between this graphics context's current color and the new specified color.
String	toString() Returns a String object representing this Graphics object's value.
abstract void	translate(int x, int y) Translates the origin of the graphics context to the point (x, y) in the current coordinate system.