ĮVADAS The Java programming language was introduced in 1995 by Sun Microsystems which has since merged into Oracle Corporation. Derived from languages such as C and C++. Pradžioje Java buvo skirta programuoti įrenginius tokius kaip telefonai, po to išsiplėtė iki pilnavertės objektinio programavimo kalbos. In 2014, Oracle Corporation released Java 8, which was another milestone release. Not only was Java already the most modern, statically typed, object oriented language available for development, but Java 8 adds important new enhancements to the language, such as lambda expressions, streams processing, and default methods. JavaFX 8 was also released at the same time, advancing desktop Java applications more than ever. JavaFX 8 can be used for developing rich desktop and Internet applications using the Java language. It provides a rich set of graphical and media user interfaces to develop extraordinary visual applications. There are many editions of Java, such as the Mobile Edition (ME) and the Enterprise Edition (EE). Java SE is the Standard Edition and represents the heart of the language. Programuojant Java, reikia skirti tris pagrindines dalis: Java programavimo kalba; Java virtuali mašina (angl. JVM Java Virtual Machine); Java platforma. Programuojant Java kalba, pirmiausia yra parašomas programos tekstas (angl. source, tai parastas tekstinis failas su praplėtimu *.java). Po to šis programos tekstas sukompiliuojamas gaunamas objektinis modulis (failas *.class), kuris dar yra susiejamas su Java bibliotekomis, kurių funkcijos yra panaudotos sukurtoje Java programoje. Java programa kompiliuojant paverčiama į Java virtualios mašinos (JVM) komadas, o ne konkretaus kompiuterio procesoriaus komandas. Todėl sukompiliuota Java programa (dar vadinama baitiniu kodu, angl. byte code) vienodai veiks ant visų kompiuterių, kur yra įdiegta JVM, jos nereikės perkompiliuoti kiekvienam kompiuteriui/procesoriui atskirai. JVM atlieka baitinio kodo interpretavimą (vykdymą). The JVM is the base upon which compiled Java class files run and is responsible for interpreting compiled Java classes and executing the code. Every operating system that is capable of running Java code has its own version of the JVM. Applications developed in the Java language can run on any operating system that contained a Java Virtual Machine (JVM). Java has been described as a language that allows developers to write once, run everywhere. The Java platform APIs and libraries are a collection of predefined classes that are used by all Java applications. Any application that runs on the JVM makes uses the Java platform APIs and libraries. This allows applications to use the functionality that has been predefined and loaded into the JVM. Java platforma yra aibė Java klasių (bibliotekų), kurios yra kiekvienoje Java installiacijoje. All programs written in the Java language rely on the set of predefined classes that comprise the Java platform. Java classes are organized into related groups known as packages. The Java platform defines packages for functionality such as input/output, networking, graphics, user-interface creation, security, and much more. Kita Java savybė visos standartinės funkcijos, kurios yra kviečiamos programos kode, prijungiamos tik programos vykdymo metu (dinaminis pririšimas, angl. dynamic binding), o neįtraukiamos į baitinį kodą. Dėl šios priežasties sukompiliuotos programos apimtis būna nedidelė. 1
Pirmosiose JVM versijose dinaminis pririšimas lėtindavo programos vykdymą, tačiau dabar JVM taip ištobulinta, kad tai nesukelia jokių problemų. Java baitinis kodas yra interpretuojamas. Although interpreters are not typically considered highperformance systems, JVM performance has improved dramatically since the first versions of the language. The latest releases of Java run remarkably fast. Java runtime environment (JRE) sudaro Java Virtuali Mašina(JVM), java platformos bazinės klasės ir pagalbinės Java platformos bibliotekos. Java platformą galima praplėsti papildomais paketais (optional packages). JRE įeina į naršykles, operacines sistemas, duomenų bazių sistemas ir pan. Pagrindinė JRE komada yra java, kuri atlieka baitinio kodo vykdymą (interpretavimą): java pavyzdys1 Java Development Kit (JDK), which is composed of the Java Runtime Environment (JRE), the Java programming language, and platform tools that are necessary to develop and run Java applications. The JRE contains the Java Virtual Machine (JVM), plus the Java application programming interfaces (APIs) and libraries that assist in the development of Java applications. Norint sukompiliuoti ir vykdyti Java kodą, reikia įsidiegti Java Development Kit (JDK). Pagrindinės JDK komandos yra: javac, kuri kompiliuoja Java kodą, ir java, kuri atlieka baitinio kodo vykdymą (interpretavimą): javac pavyzdys1.java //sukompilaivus sukuriamas failas pavyzdys1.class java pavyzdys1 // paleidžiamas sukompiliuotas failas pavyzdys1.class Atkreipkit dėmesį, kad JRE tik vykdo, o JDK kompiliuoja ir vykdo. JRE yra JDK poaibis. INSTALIAVIMAS Java galima parsisiųsti ir susiinstaliuoti adresu (versija Java SE 8u31, 2015): http://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html Programavimo aplinkos: NetBeans (nuoroda ta pati, kaip ir Java) Eclipse: http://www.eclipse.org 2
PERFORMANCE As described earlier, Java programs are compiled to a portable intermediate form known as byte codes, rather than to native machine-language instructions. The Java Virtual Machine runs a Java program by interpreting these portable byte-code instructions. This architecture means that Java programs are faster than programs or scripts written in purely interpreted languages, but Java programs are typically slower than C and C++ programs compiled to native machine language. Keep in mind, however, that although Java programs are compiled to byte code, not all of the Java platform is implemented with interpreted byte codes. For efficiency, computationally intensive portions of the Java platform such as the stringmanipulation methods are implemented using native machine code. Although early releases of Java suffered from performance problems, the speed of the Java VM has improved dramatically with each new release. The JVM has been highly tuned and optimized in many significant ways. Furthermore, most current implementations include a just-in-time (JIT) compiler, which converts Java byte codes to native machine instructions on the fly. Using sophisticated JIT compilers, Java programs can execute at speeds comparable to the speeds of native C and C++ applications. Java is a portable, interpreted language; Java programs run almost as fast as native, nonportable C and C++ programs. THE UNICODE CHARACTER SET Java programs are written using Unicode. You can use Unicode characters anywhere in a Java program, including comments and identifiers such as variable names. Unlike the 7-bit ASCII character set, which is useful only for English, and the 8-bit ISO Latin-1 character set, which is useful only for major Western European languages, the Unicode character set can represent virtually every written language in common use on the planet. 16-bit Unicode characters are typically written to files using an encoding known as UTF- 8, which converts the 16-bit characters into a stream of bytes. The format is designed so that plain ASCII text (and the 7-bit characters of Latin-1) are valid UTF-8 byte streams. Thus, you can simply write plain ASCII programs, and they will work as valid Unicode. 3
PIRMA PROGRAMA JAVA public class Paskaita1 { public static void main(string[] args) { String str = vakaras ; int i = 10, j= 10; long l = 20; float f = (float)0.01; double d = 0.02; byte b1 = 50; char c1 = A, c2 =?, c3 = \n ; System.out.println( Labas + str + ; i= + i + ; l= + l + ; f= + f + ; d= + d); Išsaugoti failą būtina tokiu pačiu pavadinimu, kaip ir klasės pavadinimas: Paskaita1.java javac Paskaita1.java sukompiliuojamas failas, sukuriamas baitinis kodas Paskaita1.class java Paskaita1 interpretatorius įvykdo kodą,ekrane išvedamas tekstas: Labas vakaras; i=10; l=20; f=0.01; d=0.02 Programą sudaro viena ar kelios klasės (public class Paskaita1). Klasėspradžia žymima žodžiu: class po to eina klasės pavadinimas (iš didžiosios raidės), pvz. Paskaita1 Klasės kūnas (class body) rašomas tarp riestinių skliaustų. Visi veiksmai surašomi metoduose (kitose progr. Kalbose vadinama funkcijomis). Metodams suteikiami pavadinimai iš mažosios raidės. Būtinai turi būti vienas metodas pavadinimu main(string[] args), nes nuo jo pradedama vykdyti programa. Metodas gali grąžinti vieną reikšmę (return), kurios tipas nurodomas prieš metodo pavadinimą. Jei metodas negrąžina jokios reikšmės, tipas nurodomas void. Po metodo pavadinimo tarp skliaustelių nurodomi paduodami argumentai (parametrai) ir jų tipai. Pvz. String[] args yra masyvas sudarytas iš teksto eilučių. Prieš metodo tipą gali būti nurodomi modifikatoriai (modifiers): public reiškia, kad metodas pasiekiamas iš bet kur, static leidžia iškviesti main() pačioje programosvykdymo pradžioje. Modifikatoriai metodams nebūtini, išskyrus main() metodą, kur ji e privalomi. Metodo kūnas (suprogramuoti veiksmai) surašomi tarp riestinių skliaustų. Kiekvienos eilutės ar reiškinio gale dedamas kabliataškis. System.out.println() - išveda į ekraną tekstą. Java kalboje didžiosios ir mažosios raidės skirasi. Turi būti nurodyti kintamųjų tipai. KOMENTARAI Vienos eilutės komentavimas: //======PRADŽIA====== Kelių eilučių komentavimas: /* ČIA YRA PRADŽIA */ 4
PAVADINIMAI Kintamųjų, metodų ir klasių pvadinimai turi būti sudaryti iš lotyniškų raidžių, pabraukimo simbolio _ ar skaičių. Remiantis Java kodo konvencija rekomenduojama klasių pavadinimus rašyti iš didžiosios raidės, metodų ir kintamųjų pavadinimus mažosiomis raidėmis, konstantų pavadinimus visomis didžiosiomis raidėmis. public class Paskaita1 { public static int MIN_DELTA = 10; // klases pavadinimas // konstanta public static void main(string[] args) { // metodas String str = vakaras ; // kintamieji int i = 10, j= 10; long l = 20; float f = (float)0.01; double d = 0.02; byte b1 = 50; char c1 = A, c2 =?, c3 = \n ; System.out.println( Labas + str + ; i= + i + ; l= + l + ; f= + f + ; d= + d); Pavadinimas negali prasidėti skaičiumi. Pavadinimams negalima naudoti sisteminių Java žodžių pvz. kaip class, void, public, static, float, int ir t.t. EILUTES Rašomos tarp dvigubų kabučių: Dvi eilutes galima sujungti + ženklu: String str = vakaras ; Labas + vakaras SIMBOLIAI \n naujos eilutės simbolis (ASCII kodas 10) \r kursoriaus permetimo simbolis - grąžina į eilutės pradžią (ASCII kodas 13) \t tabuliacija \ dviguba kabutė \ - vienguba kabutė \\ - atgalinis pasvirasis brūkšnys System.out.println( Labas \n vakaras ); System.out.println( Labas \t vakaras ); System.out.println( Labas \ vakaras\ ); System.out.println( Labas \ vakaras\ ); 5
Raides galima nurodyti ir UTF-8 kodais, pvz.: "Balsis \u017eod\u017eio gale prie\u0161 priebalsius"; // \u017e radidė ž, \u0161 raidė š "Balsis daugiau nei trij\u0173 skiemen\u0173 \u017eodyje"; // \u0173 raidė ų Kompiliatorius visas raides kovertuoja į UTF-8 koduotę, tame tarpe ir patį programos tekstą. SVEIKIEJI SKAIČIAI Pvz. 5, -7, 12345678 Pvz. 25L, -37L Jie pagal nutylėjimą išsaugomi int tipo formatu (4 baitai). Kai gale prirašyta raidė L arba l, išsaugoma long tipo formatu (8 baitai). Sveikieji tipai: Tipo pavadinimas Kiek užima baitų Diapazonas byte 1-128 iki 127 short 2-32768 iki 32767 int 4-2147483648 iki 2147483647 (-2^31 iki 2^31-1) long 8-2^63 iki 2^63-1 char 2 \u0000 iki \uffff,dešimtainėj formoj nuo 0 iki 65535 Sveikieji skaičiai atmintyje saugomi dvejetainiu pavidalu su papildomu kodu, t.y. neigiamiems sveikiems skaičiams saugomas atitinkamo dvejetainio kodo papildomas kodas (two s complement). Pvz. int b1 = 50, b2=-99; Atmintyje b1=50 bus saugomas kaip 50 dvejetainis kodas 00110010. b2=-99 bus saugomas tokiu principu: 99 dvejetainis kodas yra 01100011; nuliukai keičiami vienetais, vienetai nuliukais, gaunamas papildomas kodas 10011100, ir pridedame vienetą, gauname atmintyje saugomą papildomą kodą 10011101. Tokio papildomo kodo saugojimo tikslas yra tas, kad prie 99 pridėjus -99, turi gautis 0, taip pat skaičiaus dvejetainį kodą sudėjus su papildomu kodu (two s complement) yra gaunamas nulis (vyriausias bitas yra numetamas: baitą sudaro 8 bitai, todėl 9-tas bitas numetamas): 01100011 + 10011101 = 100000000 Tokiu būdu saugant neigiamo skaičiaus priešingą dvejetainį kodą vietoje atimties veiksmo yra naudojamas sudėties veiksmas. 6
DVEJETAINIŲ SKAIČIŲ ARITMETIKA Dvejetainių skaičių suma: 0+0=0 0+1=1 1+0=1 1+1=0, 1 laikomas atmintyje, pridedamas prie sekančio skaitmens. Pvz.: 1 1 1 1 1 + 1 1 0 0 0 0 0 Dvejetainių skaičių atimtis: 0 0 = 0 0 1 = 1, pasiskolinamas 1 iš sekančio skaitmens 1 0 = 1 1 1 = 0 1 1 0 1 1 1 0-1 0 1 1 1 1 0 1 0 1 1 1 Papildomi dvejetainiai skaičiai Yra dviejų tipų papildomi dvejetainiai skaičiai: One s complement ir Two s complement. One s complement : gaunamas kai dvejetainio kodo nuliukai keičiami vienetais, vienetai nuliukais. Pvz. 1011 papildomas kodas bus 0100. Two s complement : gaunamas kai dvejetainio kodo nuliukai keičiami vienetais, vienetai nuliukais ir pridedamas 1tas. Pvz. 01100011 papildomas kodas bus 10011101. An N-bit ones' complement numeral system can only represent integers in the range (2 N 1 1) to 2 N 1 1 while two's complement can express 2 N 1 to 2 N 1 1. Praktikoje paprastai yra naudojamas Two s complement kodas. 7
REALIEJI SKAIČIAI Jie pagal nutylėjimą išsaugomi double tipo formatu. Pvz. 37.25, -128.0 Pvz. 2.5e34, 2.5E-3 Pvz. 3.5F Pvz. 3.5D Su fiksuotu tašku. Su plaukiojančiu tašku. Kai gale prirašyta raidė F arba f, išsaugoma float tipo formatu. Kai gale prirašyta raidė D arba d, išsaugoma double tipo formatu (nurodyti D nebūtina,nes ir taip pagal nutylėjimą išsaugoma double tipu). Tipo pavadinimas Kiek užima baitų Diapazonas float 4 3.4e-38 < x < 3.4e38 (7-8 skaitmenys po kablelio) double 8 1.7e-308 < x < 1.7e308 (17 skaitmenų po kablelio) Jei reiškinyje vienas narys yra double tipo, tai ir kiti nariai pakeliami iki double tipo ir rezultatas yra double. Jei reiškinyje nėra double nario, bet dalyvauja float narys,tai ir kiti nariai pakeliami iki float tipo ir rezultatas yra float. LOGINIS TIPAS Galimos dvi reikšmės: true, false Pvz.: boolean b1 = true, b2 = false; LOGINĖS OPERACIJOS! NOT & AND OR ^ XOR && Conditional-AND Conditional-OR b1 b2!b1 b1&b2 b1 b2 b1^b2 true true false true true false true false false false true true false true true false true true false false true false false false Operacijose && ir dešinės pusės operandas skaičiuojamas tik tada, kai rezultatas nebūna aiškus iš karės pusės. Pvz. jei kairėje operacijos && pusėje yra false, tai dešinė pusė nebeskaičiuojama,nes aišku,kad atsakymas bus false. Jei kairėje operacijos pusėje yra true, tai dešinė pusė nebeskaičiuojama, nes aišku, kad atsakymas bus true. Ši taisyklė praverčia pvz. tokiais atvejais, kur nereikės bijoti dalybos iš nulio: if (x!= 0 && y/x > 0.001) if (x == 0 y/x > 0.001) Praktikoje programuojant būtent && ir operacijos yra naudojamos. boolean a, b, c; a = true; b = false; c = a & b; System.out.println("a & b=" + c); //a & b=false 8
c = a b; System.out.println("a b=" + c); //a b=true c = a ^ b; System.out.println("a ^ b=" + c); //a ^ b=true c =!a; System.out.println("!a=" + c); //!a=false System.out.println("\nOPERACIJOS && ir "); int x, y; x = 0; y = 5; if(x!= 0 && y / x > 2) { System.out.println("x!= 0 && y / x > 2"); else { System.out.println("NOT (x!= 0 && y / x > 2)"); if(x == 0 y / x > 2) { System.out.println("x == 0 y / x > 2"); else { System.out.println("NOT (x == 0 y / x > 2)"); PRISKYRIMO OPERACIJA Reikšmės priskyrimo operacija yra lygybės ženklas. Pvz.: int a = 5; Operacija Pvz. Operacija Pvz. = int i = 5; &= boolean b1 = true,b2=false; b1 &= b2; // atitinka b1 = b1 & b2; += int i = 5; ^= Analogiškai i += 3; // atitinka i = i + 3; atsakymas 5 + 3 = 8 -= int i = 5; = Analogiškai i -= 3; // atitinka i = i 3; atsakymas 5 3 = 2 *= int i = 5; i *= 3; // atitinka i = i * 3; atsakymas 5 * 3 = 15 /= Analogiškai %= Analogiškai 9
OPERACIJOS SU SVEIKAIS SKAIČIAIS + suma - skirtumas * daugyba / dalyba % liekanos radimas ++ padidinimas vienetu -- sumažinimas vienetu Tipo keitimas pvz. (float)2.0 +, -, * operacijos atliekamos paprastai, pvz.: c = a + b; Reikia atkreipti dėmesį, kad dviejų sveikų saičių dalybos rezultatas vėl bus sveikas skaičius. Pvz. 5 / 2 = 2, o ne 2.5. Trupmeninė dalis yra tiesiog numetama. Tačiau 5 / 2.0 = 2.5, nes reiškinyje dalyvauja realus skaičius 2.0, todėl rezultatas irgi bus realus 2.5. int aa, bb, rez1; float cc, rez2, rez3; aa = 5; bb = 2; cc = (float)2.0; cc = 2; rez1 = aa / bb; //rez1 = aa / cc; rez2 = aa / cc; rez3 = (float)aa / bb; // KLAIDINGA!!! // TEISINGA!!! // TEISINGA!!! System.out.println("aa*bb=" + (aa*bb)); System.out.println("aa/bb=" + rez1); System.out.println("aa/cc=" + rez2); System.out.println("aa/bb=" + rez3); //aa*bb=10 //aa/bb=2 //aa/cc=2.5 //aa/bb=2.5 ++ ir operacijas galima naudoti ir atskirai, ir reikškinio viduje, tačiau tai gali duoti skirtingus rezultatus. Jei operacija ++ ar -- yra atskirai, t.y. i++; arba ++i, tai tiesiog yra padidinama/sumažinama vienetu. Jei i++ ar i- operacija naudojama reiškinyje, tai pradžioje yra suskaičiuojamas reiškinys, po to yra padidinama/sumažinama vienetu. Jei ++i ar --i operacija naudojama reiškinyje, tai pradžioje yra padidinama/sumažinama vienetu po to suskaičiuojamas reiškinys. int i, j rez1; System.out.println("====== (++) ir (--) OPERACIJOS======"); i = 10; i++; System.out.println("i=" + i); // 11 i = 10; rez1 = i++; // rez1=10!!! System.out.println("rez1=" + rez1); // 10!!! System.out.println("i=" + i); // 11 i = 10; System.out.println("i++ " + i++); // 10 System.out.println("i=" + i); // 11 i = 10; j = (i++) + 5; System.out.println("1) j=" + j); // 15 i = 10; j = (++i) + 5; System.out.println("2) j=" + j); // 16 10
System.out.println(); i = 0; j = 0; for (int k=0; k < 5; k++) { System.out.println(k + ") i++:" + i++ + "; ++j:" + (++j)); // k=0..4 i=0..4 j=1..5 TIPO KEITIMO OPERACIJA Kai skaičiuojamas reiškinys visada vyskta reiškinyje dalyvaujančių narių tipo pakėlimas (angl. promotion) iki didžiausio reikškinyje dalyvaujančio tipo tokiu principu: Kai atliekamos aritmetinės operacijos (+,-,*,/) su sveikaisiais skaičiais (byte, short, int, char), visada tipas yra pakeliamas iki int tipo ir rezultatas gaunamas irgi int tipo. Tačiau, jei bent vienas reiškinio narys yra long tipo, visi kiti nariai pakeliami iki long tipo ir atsakymas yra long tipo. Panašiai jei bent vienas reiškinio narys yra float / double tipo, visi kiti nariai pakeliami iki float / double tipo ir atsakymas yra float / double tipo. Programuotojas gali pats nurodyti, kokiu tipu išsaugoti duomenis, prieš skaičių ar kintamąjį paprastuose skliaustuose įrašęs norimą tipą, pvz. int tipo skaičius 2 konvertuojamas į float tipą: float f = (float)2; Kaip jau turėjome ankstesniame pavyzdyje: int aa, bb, rez1; float cc, rez2, rez3; aa = 5; bb = 2; cc = 2; // int tipas praplečiamas iki float tipo rez1 = aa / bb; // 2 //rez1 = aa / cc; // KLAIDA, nes aa/cc yra float tipo, bandoma įrašyti į mažesnį int rez2 = aa / cc; // TEISINGA, atsakymas 2.5 rez3 = aa / bb; // 2.0, nes aa/bb=2 yra int tipo, praplečiama iki float rez3 = (float)aa / bb; // 2.5, nes aa konvertuojamas į float, ir visas aa/bb tampa float Tipą galima ne tik praplėsti, bet ir susiaurinti. Tai reikia daryti atsargiai!!! 1 Pvz.: cc = (float)2.0; // 2.0 yra double, tačiau double tipas susiaurinamas iki float 2 Pvz.: skaičius 300 dvejetainėje sistemoje yra 100101100, kurį sudaro devyni bitai, bet šį skaičių įrašius į byte tipo kintamąjį, kuriam išskirta aštuoni bitai atminties, vysriausias bitas yra numetamas, ir atsakyme gauname skaičių 00101100=44: // tipo susiaurinimas byte by = (byte)300; // atsakymas by=44 byte b1 = 50, b2 = -99; short k; k = b1 + b2; // KLAIDINGA: Type mismatch: cannot convert from int to short // desineje puseje atliekama artim-ne op-cija ir tipas pakeliamas iki int k = (short)(b1 + b2); // TEISINGA, atliekamas tipo susiaurinimas 11
by = 1; //by = by + 10; // KLAIDINGA, nes desineje puseje by tipas pakeliamas iki int!!! by += 10; // TEISINGA, nes 10 tipas susiaurinamas iki byte!!! System.out.println("by="+ by); //by=11 PALYGINIMO OPERACIJOS > daugiau >= daugiau lygu == lygu < mažiau <= mažiau lygu!= nelygu if(a > 5) if(b == 2) while(c!= 0) SĄLYGINĖ OPERACIJA (sąlyga)? (atsakymas, jei sąlyga=true) : (atsakymas, jei sąlyga=false) Pvz.: //======SALYGINE OPERACIJA====== System.out.println("======SALYGINE OPERACIJA======"); int i = 10, j = -10, rez1; rez1 = i<0?0:i; System.out.println("1) i=10 rez1=" + rez1); //1) i=10 rez1=10 rez1 = j<0?0:j; System.out.println("2) j=-10 rez1=" + rez1); //2) j=-10 rez1=0 REIŠKINIO SKAIČIAVIMAS Reiškiniai yra skaičiuojami iš kairės į dešinę. Reiškinio skaičiavimo tvarką galima nurodyti skliaustelių pagalba. Operacijų atlikimo prioriteto tvarka: 1. i++, i-- 2. ++i, --i, ~,! 3. Tipo keitimas, pvz. (float)i 4. *, /, % 5. +, - 6. >, <, >=, <= 7. ==,!= 8. & 9. ^ 10. 11. && 12. 13. (sąlyga)? (atsakymas, jei sąlyga=true) : (atsakymas, jei sąlyga=false) 14. =, +=, -=, *=, /=, %=, &=, ^=, =, 12
OPERATORIAI Java kalboje yra tokie operatoriai: Kintamųjų paskelbimo operatoriai; Operatoriai-išraiškos (pvz. a+5); Priskyrimo operatoriai (pvz. a=b-1); if while, do-while, for switch; break, continue, return; blokas nurodomas riestiniais skliausktais { tuščias operatorius (kabliataškis) OPERATORIUS if if (max < y) { max = y; if (a < x) { x = a + b; else { x = a - b; if (n == 0) { sign = 0; else if (n < 0) { sign = -1; else { sign = 1; CIKLO OPERATORIUS for for (int k=0; k < 5; k++) { System.out.println(k + ") i++:" + i++ + "; ++j:" + (++j)); // k=0..4 i=0..4 j=1..5 CIKLO OPERATORIUS while, do-while The while statement continually executes a block of statements while a particular condition is true: while (expression) { statement(s) The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false. Using the while statement to print the values from 1 through 10 can be accomplished as in the program: class WhileDemo { public static void main(string[] args){ int count = 1; while (count < 11) { System.out.println("Count is: " + count); count++; 13
You can implement an infinite loop using the while statement as follows: while (true){ // your code goes here The Java programming language also provides a do-while statement, which can be expressed as follows: do { statement(s) while (expression); The difference between do-while and while is that do-while evaluates its expression at the bottom of the loop instead of the top. Therefore, the statements within the do block are always executed at least once: class DoWhileDemo { public static void main(string[] args){ int count = 1; do { System.out.println("Count is: " + count); count++; while (count < 11); OPERATORIAI continue ir break Operatorius continue nutraukia esamos ciklo iteracijos vykdymą ir peršokia prie sekančios ciklo iteracijos: int x = 0; for(int i = 0; i <= N; i++) { if (i < 3) continue; x += i; // x = suma nuo 4 iki N Operatorius break nutraukia ciklo vykdymą ir peršokia į sekančią eilutę, esančią iš karto už ciklo pabaigos: int x = 0; for(int i = 0; i < N; i++) { if (i > 8) break; x += i; // x = suma nuo 0 iki 7 OPERATORIUS switch A switch works with the byte, short, char, and int primitive data types. It also works with enumerated types, the String class, and a few special classes that wrap certain primitive types: Character, Byte, Short, and Integer. The following code example, SwitchDemo, declares an int named month whose value represents a month. The code displays the name of the month, based on the value of month, using the switch statement. 14
public class SwitchDemo { public static void main(string[] args) { int month = 8; String monthstring; switch (month) { case 1: monthstring = "January"; break; case 2: monthstring = "February"; break; case 3: monthstring = "March"; break;.. case 7: monthstring = "July"; break; case 8: monthstring = "August"; break; case 9: monthstring = "September"; break; case 10: monthstring = "October"; break; case 11: monthstring = "November"; break; case 12: monthstring = "December"; break; default: monthstring = "Invalid month"; break; System.out.println(monthString); In this case, August is printed to standard output. return Statement The return statement exits from the current method, and control flow returns to where the method was invoked. The return statement has two forms: one that returns a value, and one that doesn't. To return a value, simply put the value (or an expression that calculates the value) after the return keyword. return v; The data type of the returned value must match the type of the method's declared return value. When a method is declared void, use the form of return that doesn't return a value. return; 15
MASYVAI Masyvas yra skirtas laikyti kelis vieno tipo elementus, kurie saugomi gretimose atminties celėse. Masyvai priskiriami prie nuorodų tipų (reference types). Masyvo paskelbimas vykdomas trimis žingsniais: Paskelbimas (declaration), pvz.: double[] a, b; int[] c; Šiame žingsnyje yra sukuriamos nuorodos a ir b į du double tipo masyvus, bei nuoroda c į int tipo masyvą. Apibrėžimas (instantiation),pvz.: a = new double[5]; b = new double[10]; c = new int[20]; Nurodomas masyvo elementų skaičius (dar vadinamas masyvo ilgiu), pavyzdyje 5, 10 ir 20, operatyvinėje atmintyje išskiriama vieta masyvui, nuorodos kintamajam (a, b ir c) priskiriamas masyvo adresas atmintyje. Visa tai padaro operacija new, kuri objektui išskiria atmintį ir grąžina atitinkamą adresą. Masyvo elementai yra numeruojami nuo 0, t.y. a[0],..., a[4]. Masyvo elemento indeksas turi būti sveikasis skaičius ar kintamasis, išskyrus long tipą. Pvz.: int i=2; a[i]=3.5; Inicializacija (initialization) masyvo elementams yra priskiriamos reikšmės,pvz.: a[0]=0; a[1]=1; a[2]=2; a[3]=3; a[4]=4; for(int i=0; i<10; i++) { b[i]=2*i+0.5; Pirmus du žingsnius galima apjungti į vieną: double[] a = new double[5]; double[] b = new double[10]; int[] c = new int[20]; arba: double[] a = {0.5, 0.1, 3.6, 7.0, 10.1; Į ką reikia atkrepti dėmesį: Kadangi masyvai yra nuorodos tipo, tai nuoroda į masyvą nėra masyvo dalis. Nuorodą į masyvą galima permesti, kad rodytų į kitą tokio paties tipo masyvą. Pvz.: Po priskyrimo veiskmo: a = b; abi nuorodos a ir b rodys į tą patį double[] masyvą, kurio dydis yra 10 (pirmasis double masyvas iš 5 elementų bus prarastas, tiksliau jokia nuoroda į jį neberodys). Pvz. Palyginimo operacijose: a == b; a!= b; yra lyginami ne masyvų elementai, o jų adresai, saugomi nuorodose a ir b, t.y. nustatome ar nuorodos rodo į tą patį masyvą ar ne. Kiekvienam masyvui be nuorodos į jį papildomai yra sukuriama sveikoji konstanta pavadinimu length, kurioje saugomas masyvo ilgis. Pvz.: a.length yra lygus 5, b.length yra lygus 10, c.length yra lygus 20. 16
DAUGIAMAČIAI MASYVAI Daugiamačio masyvo paskelbimas ir reikšmių priskyrimas: int[][] d = new int[3][4]; d[0][0] = 0; d[0][1] = 1;...; d[2][3] = 5; Arba: int m[][] = new int [3][4]; for (int i=0; i < m.length; i++) { for (int j=0; j < m[0].length; j++) { m[i][j] = i+j; System.out.println(m[i][j]); Arba: int[][] e = {{1,2,3, {4,5,6; Java kalboje dvimatis masyvas neprivalo būti stačiakampis. Masyvo elelemntai gali būti kiti masyvai. Pvz.: char[][] c = new char[3][]; Čia paskelbiama, kad masyvą c sudaro 3 elementai, kurie vėl yra masyvai. Dabar apibrėšime tuos 3 elementus-masyvus: c[0] = new char[2]; c[1] = new char[4]; c[2] = new char[3]; Tada: c.lenght = 3 c[0].length = 2 c[1].length = 4 c[2].length = 3 Paskutiniame žingsnyje priskiriame konkrečias reikšmes: c[0][0]= a ;c[0][1]= b ;c[1][0]= c ; c[1][1]= d ; ir t.t. 17
VECTOR Masyvų trūkumai: Iš anksto reikia žinoti elementų skaičių. Nepatogu įterpinėti per vidurį naujus elementus praktiškai reikia kurti naują didesnį masyvą. Nepatogu per vidurį ištrinti elementus reikia arba pernumeruoti elementus, arba kurti naują, mažesnį masyvą. Elementai privalo būti vieno tipo. Kai iš anksto nežinomas elementų skaičius, ir reikia dažnai įterpti / ištrinti elementus, reikia naudoti kitas struktūras. Viena iš anksčiausiai Java kalboje atsiradusių struktūrų duomenų saugojimui yra Vector. Vector klasė yra Java pakete java.util. Vektoriuje saugomi bendriausio tipo Object elementai, t.y. bet kokio tipo. Elementai gali būti skirtingų tipų. Elementų skaičius iš ansto nefiksuojamas/ nenurodomas, jis automatiškai keičiasi pridedant ar ištrinant elementus. Jei vektorių sudaro N elementų, jie numeruojami 0, 1,..., N-1. Veiksmas Vektoriaus sukūrimas, kai nežinomas elementų skaičius: new Vector() Vektoriaus sukūrimas, kai žinomas elementų skaičius: new Vector(N) Elemento pridėjimas vektoriaus gale: add() Elemento įdėjimas nurodytoje pozicijoje: add(int index, Object element) Pasirinktoje vietoje buvęs el-tas ir visi sekantys yra perstumiami per vieną poziciją. El-to, esančio nurodytoje pozicijoje, pakeitimas: set(int index, Object element) Pasirinktoje vietoje buvęs el-tas ištrinamas, vetoje jo įrašomas naujas Pavyzdys // el-tai Integer, Float ir string tipo Vector<Integer> v1 = new Vector<Integer> (); Vector<Float> v2 = new Vector<Float> (); Vector<String> v3 = new Vector<String> (); // el-tai bet kokio tipo Vector<Object> v4 = new Vector<Object> (); // vektorius sudarytas iš 5 el-tų Vector<Integer> v1 = new Vector<Integer> (5); // gale pridedamas el-tas, kurio reikšmė nurodyta v1.add(13); v1.add(14); v1.add(17); v1.add(18); v3.add( Labas ); // pozicijoje nr. 2 įterpiamas naujas el-tas =15, // kiti el-tai perstumiami v1.add(2, 15); // pozicijoje nr. 3 užrašomas naujas el-tas 16 v1.set(3, 16); 18
Ar vektorius tuščias isempty() Vektoriaus el-to gavimas: get(int index) Ar vektoriuje yra nurodytas elementas contains() Nurodyto el-to pozicija indexof() El-to ištrynimas pagal reikšmę: remove(object obj) El-to ištrynimas pagal indeksą arba indeksus nuoiki: remove(int index) removerange(int begin, int end) Visų vektoriaus el-tų ištrynimas: clear() // atsakymas true, jei tuščias v1.isempty() // grąžina el-tą, esantį 3-je pozicijoje v1.get(3); // atsakymas true, jei vektoriuje yra el-tas =16 v1.contains(16); //el-tas =16yra 3-je pozicijoje v1.indexof(16); // ištrina pirmą surastą el-tą = Labas v3.remove( Labas ); // ištrina pozicijoje 1 esantį el-tą v1.remove(1); v1.removerange(2, 4); v2.clear(); 19
KLASĖS APRAŠYMAS Klasės aprašymas prasideda nuo žodžio class po kurio nurodomas klasės pavadinimas (rekomenduojama klasių pavadinimus rašyti iš didžiosio raidės). Prieš žodį class galima nurodyti modifikatorių: public, abstract, final ir kt. Klasės kūnas, kuriame surašomi klasės kintamieji ir metodai, rašomas tarp riestinių skliaustų. Prekė kodas pavadinimas šalis kainavnt import java.util.vector; public class Preke { int kodas; String pavadinimas; String salis; float kainavnt; public Preke(int pkodas, String ppav, String psalis, float pkainavnt) { kodas = pkodas; pavadinimas = ppav; salis = psalis; kainavnt = pkainavnt; public void spausdinti() { System.out.println(kodas + + pavadinimas + + salis + + kainavnt); private int getkodas() { return kodas; Klasės kintamieji dar vadinami laukais (angl. field), yra skelbiami nurodant jo tipą ir pavadinimą. Prieš kintamojo tipą galima nurodyti modifikatorių: public, protected, private, static, final, kt. Ką reiškia modofikatoriai, bus paaiškinta vėliau. Kintamųjų ir metodų (funkcijų) pavadinimus rekomenduojama rašyti iš mažosios raidės. Klasės metodai skelbiami nurodant grąžinamos reikšmės tipą, metodo pavadinimą, tarp paprastų skliaustų išvardijami metodui paduodami kintamieji su jų tipais, atskiriami kableliais. Toliau tarp riestinių skliaustų programuojami metodo atliekami veiksmai. Metodo pabaigoje yra grąžinama reikšmė operatoriumi return. Jei metodo tipas nurodytas void, tai metodas jokios reikšmės negrąžina, ir return operatorius nereikalingas. Metodo aprašymas gali prasidėti nuo modifikatoriaus: public, protected, private, abstract, static, final, ir kt. Metodo signatūrą sudaro: metodo pavadinimas, jo parametrų skaičius ir jo parametrų tipų sąrašas. Todėl du metodai su vienodais pavadinimais tačiau skirtingais parametrų tipais ar skirtingu parametrų skaičiumi yra laikomi skirtingais metodais, pvz.: 20
// metodas nuskaito tik duomenis su data=pdata public Vector nuskaityti(string pdata) { Vector v = new Vector(); // is lenteles nuskaitomi irasai, kur Data == pdata // nuskaityti irasai surasomi i kintamaji v return v; // metodas nuskaito visus duomenis public Vector nuskaityti() { Vector v = new Vector(); // is lenteles nuskaitomi visi // nuskaityti irasai surasomi i kintamaji v return v; Toks metodų su vienodais pavadinimais tik skirtingais parametrais naudojimas vadinamas metodų perkrovimu (angl. overloading). KLASĖS KONSTRUKTORIUS Klasės Preke objektas yra sukuriamas taip: Preke p1 = new Preke(1, "Duona", "LT", 2); Dešinėje pusėje po new yra kreipiamasi į klasės kostrukrotių, kurio pagalba klasės kintamiesiems yra priskiriamos konkrečios reikšmės: public Preke(int pkodas, String ppav, String psalis, float pkainavnt) { kodas = pkodas; pavadinimas = ppav; salis = psalis; kainavnt = pkainavnt; Klasės konstruktorius aprašomas panašiai kaip metodas, kurio vardas sutampa su klasės pavadinimu. Konstruktoriaus savybės: Kiekviena klasė turi konstruktorių. Net jei konstruktoriaus kodas nėra parašytas, Java pati sukuria konstruktorių (default constructor), kuris yra tuščias ir neatlieka jokių veiksmų,tik iškviečia tėvinės klasės konstruktorių (komanda super() ). Konstruktoriaus kūnas rašomas tarp riestinių skliaustų. Jame surašomi veiksmai, kuriuos reikia atlikti prieš pradedant naudoti klasės objektą, pvz. pradinių reikšmių priskyrimas. Kai yra kuriamas klasės objektas, Java visada pradžioje sukuria klasės kintamuosius, steikia jiems nulines reikšmes, tada automatiškai įvykdo konstruktorių. Tik po to galima pradėti naudoti objektą. Konstruktorius nelaikomas metodu. Konstruktorius negrąžina jokios reikšmės, todėl jo aprašyme nėra nurodytas tipas void. Konstruktoriui galima nurodyti modifikatorių public, protected ar private. Konstruktoriuje komanda super() galima kreiptis į tėvinės klasės konstruktorių (ši komanda visada turi būti pati pirma, tik po jos seka kiti veiksmai): public Preke(int pkodas, String ppav, String psalis, float pkainavnt) { super(); kodas = pkodas; pavadinimas = ppav; salis = psalis; kainavnt = pkainavnt; 21
Net jei konstruktoriuje nėra įrašyta komanda super(), Java vis tiek pati iškviečia tėvinės klasės konstruktorių, ir tik po to vykdo kitus konstruktoriuje surašytus veiksmus. Klasė gali turėti kelis konstruktorius, su skirtingais parametrais (analogiškai kaip ir kelis vienodo pavadinimo metodus su skirtingais parametrais). OPERACIJA new Operacija new išskiria atmintį masyvams ir objektams. Masyvų atveju (a yra nuoroda į sukurtą masyvą): double a[] = new double[10]; Objektų atveju: Preke p1 = new Preke(1, "Duona", "LT", 2); kur dešinėje pusėje yra kreipiamasi į klasės konstruktorių, p1 yra nuoroda į objektą. Tada: Klasės kintamiesiems-skaičiams yra priskiriamos nulinės reikšmės, loginiams kintamiesiems - reikšmės false, nuorodoms reikšmės null. Po to yra vykdomas konstruktoriaus kodas, t.y. priskiriamos parametruose nurodytos reikšmės (1, "Duona", "LT", 2). KINTAMŲJŲ MATOMUMO DIAPAZONAS Kintamųjų matomumą aprašysime pavyzdyje: class Matomumas { int a = 1, p; // a ir p matomi visuose klasės metoduose, // kuriuose jų neuždengia kiti tokio pat vardo kintamieji // p priskiriama pradinė reikšmė 0 public Matomumas (int pp) { // pp lokalus kintamasis matomas tik konstruktoriaus viduje p = pp ; // klasės kintamajam p priskiriama reikšmė iš lokalaus pp // cia pp jau nebeegzistuoja, p matomas public void funkcija (int b) { // b lokalus kintamasis matomas tik metodo funkcija() viduje int a = 2; // a lokalus kintamasis matomas tik metodo funkcija() viduje // jis perdengia klasės kintamąjį a int c; ; // c lokalus kintamasis matomas tik metodo funkcija() viduje // c kol kas nepriskirta jokia reikšmė c = 8; // c priskirta reikšmė 8 for(int i=0; i < 10; i++) { // i lokalus kintamasis matomas tik ciklo viduje int e = 5; // e lokalus kintamasis matomas tik ciklo viduje System.out.println( e= + e); // visada išves reikšmę 5 // i ir e nebeegzistuoja ciklo išorėje 22
public static void main (String[] args) { int a = 1; // a lokalus kintamasis matomas tik metodo main() viduje funkcija(a); Taigi klasės kintamiesiems, juos sukuriant automatiškai yra priskiriamos pradinės (nulinės) reikšmės, o lokaliems kintamiesiems nepriskiriamos jokios reikšmės, programuotojas pats turi pasirūpinti priskyrimu. Kompiliatorius parodo pranešimus, jei yra lokalių kintamųjų, kuriem nepriskirtos jokios pradinės reikšmės. PAVELDINČIOS IR TĖVINĖS KLASĖS Pvz.: Turime klasę Zmogus, su kintamuoju vardas ir keliais metodais: Zmogus.java: public class Zmogus { String vardas; public Zmogus(String v) { vardas = v; public void labas() { System.out.println("Zmogus.labas(): Labas " + vardas); visogeroprivate(); // TIK sioje klaseje galima kreiptis i private metoda private void visogeroprivate() { System.out.println("Zmogus.visoGeroPrivate(): Viso gero " + vardas); protected void visogeroprotected() { System.out.println("Zmogus.visoGeroProtected(): Viso gero " + vardas); Tai yra bendra (tėvinė) klasė. Norime sukurti iš jos paveldinčias klases Lietuvis ir Anglas, kuriose yra paveldimi visi kintamieji ir metodai iš tėvinės klasės ir sukuriami papildomi skirtingi metodai. Tėvinės klasės pavadinimas, iš kurios yra paveldima, nurodomas po žodžio extends: Lietuvis.java: public class Lietuvis extends Zmogus { public Lietuvis(String v) { super(v); public void labasrytas() { System.out.println("Lietuvis.labasRytas(): Labas rytas " + vardas); public void dauginti(int n) { int rez = 1; for(int i = 1; i <= n; i++) { rez *= i; System.out.println("Lietuvis.dauginti(): rez=" + rez); 23
Anglas.java: public class Anglas extends Zmogus { public Anglas(String v) { super(v); public void labas() { System.out.println("Anglas.labas(): Hello " + vardas); public void labasrytas() { System.out.println("Anglas.labasRytas(): Good morning " + vardas); public void sumuoti(int n) { int rez = 0; for(int i = 1; i <= n; i++) { rez += i; System.out.println("Anglas.sumuoti(): rez=" + rez); Pagrindinis.java: public class Pagrindinis { public static void main(string[] args) { Zmogus zm = new Zmogus("Zmogus"); Lietuvis lt = new Lietuvis("Petras"); Anglas en = new Anglas("John"); zm.labas(); zm.visogeroprotected(); //zm.visogeroprivate(); // KLAIDA: private metodo cia negalima kviesti lt.labas(); lt.visogeroprotected(); lt.labasrytas(); lt.dauginti(5); en.labas(); en.visogeroprotected(); en.labasrytas(); en.sumuoti(5); Programos rezultatas: Zmogus.labas(): Labas Zmogus Zmogus.visoGeroPrivate(): Viso gero Zmogus Zmogus.visoGeroProtected(): Viso gero Zmogus Zmogus.labas(): Labas Petras Zmogus.visoGeroPrivate(): Viso gero Petras Zmogus.visoGeroProtected(): Viso gero Petras Lietuvis.labasRytas(): Labas rytas Petras Lietuvis.dauginti(): rez=120 Anglas.labas(): Hello John Zmogus.visoGeroProtected(): Viso gero John Anglas.labasRytas(): Good morning John Anglas.sumuoti(): rez=15 24
Kaip matome, tiek objektas lt tiek objektas en turi iš tėvinės klasės paveldėtą kintamąjį vardas ir metodą labas(). Taip pat kiekvienas objektas atskirai turi savo metodus dauginti() ir sumuoti(). Be to tėvinėje klasėje esantis metodas gali būti perrašomas paveldinčioje klasėje, t.y. paveldinčioje klasėje gali būti sukurtas metodas su tokiu pačiu pavadinimus ir parametrais, kaip ir tėvinėje klasėje tik su pakeistu programiniu kodu. Tai vaidinama metodo overriding. Pvz. Klasėje Anglas galima perrašyti tėvinės klasės metodą labas(): public class Anglas extends Zmogus { //... public void labas() { System.out.println("Hello " + vardas); Tokiu atveju metodo pasiekiamumą galima tik praplėsti, negalima susiaurinti, t.y. jei tėvinėje klasėje metodas buvo public, jis ir turi likti public, o jei buvo protected, tai gali paveldinčioje klasėje pasikeisti į public. Į tėvinės klasės metodus galima kreiptis pridedant žodį super. Pvz.: public class Anglas extends Zmogus { //... public void labas() { super.labas(); // kviečiamas tėvinės klasės metodas labas() PUBLIC PRIVATE PROTECTED Klases, klasės kintamuosius ir mtodus galima pažymėti modifikatoriais public, private ar protected. Klasės nariai pažymėti public yra matomi visose kitose klasėse ir aišku pačios klasės viduje. Pvz: public void labasrytas() { System.out.println("Anglas.labasRytas(): Good morning " + vardas); Į metodą labasrytas() galima kreiptis ir iš pačios klasės viduje esančių metodų ir iš bet kurios kitos klasės. Tuo tarpu klasės nariai, į kuriuos nebus kreipiamasi iš išorės, turėtų būti pažymėti private, t.y. į juos galima kreiptis tik iš esamos klasės vidaus. Tai vadinama inkapsuliacija. 25
Pvz.: Į metodą visogeroprivate(), esantį klasėje Zmogus, galima kreiptis tik iš pačios klasės Zmogus vidaus, pvz. iš metodo labas(): public class Zmogus { //... public void labas() { System.out.println("Zmogus.labas(): Labas " + vardas); visogeroprivate(); // TIK sioje klaseje galima kreiptis i private metoda private void visogeroprivate() { System.out.println("Zmogus.visoGeroPrivate(): Viso gero " + vardas); //... Tačiau tiesiai į metodą visogeroprivate() negalima kreiptis nei iš paveldinčios klasės Lietuvis, nei iš klasės Anglas, nei iš metodo main(). Programuojant programos struktūros sukuriamos žymiai paprastesnės, kai ryšiai tarp klasių yra kuo mažesni, t.y. kiekvienoje klasėje yra sukuriami tik tai klasei reikalingi metodai, nesusiję su kitomis klasėmis. Tai vadinama low coupling ir tuo tikslu tik klasės viduje naudojami kintamieji bei metodai žymimi private modifikatoriumi. Klasės nariai, į kuriuos nebus kreipiamasi iš išorės, tačiau galima kreiptis iš esamos klasės ir iš paveldinčių klasių, turėtų būti pažymėti protected. Pvz.: public class Zmogus { //... protected void visogeroprotected() { System.out.println("Zmogus.visoGeroProtected(): Viso gero " + vardas); //... public static void main (String[] args) { //... zm.labas(); zm.visogeroprotected(); //... lt.visogeroprotected(); //... en.visogeroprotected(); FINAL Metodą pažymėjus modifikatoriumi final, yra uždraudžiama paveldinčiose klasėse jį perrašyti (overriding). Būtent final yra matematinės bibliotekos metodai: Math.cos(), Math.sin() ir t.t. Jei final pažymėta visa klasė, iš jos negalima paveldėti. Tokia klasė yra Math: public final class Math {... 26
Kintamųjų atveju final modifikatorius nurodo, kad kintamojo reikšmės negalima keisti, t.y. paskelbiama konstanta: public final double PI = 3.14; Pagal Code Conevntion kanstantų pavadinimai rašomi visomis didžiosiomis raidėmis. STATINIAI KINTAMIEJI Sukūrus kelis tos pačios klasės objektus, kiekvienam jų atskirai yra sukuriami savi kintamieji, kintamiesiems yra išskiriamos atskiros atmitys, ir viename objekte keičiant kintamojo reikšmę, kito objekto to pačio kintamojo reikšmė nesikeičia. Pvz.: Point p1 = new Point(1,2,3); Point p2 = new Point(3,4,5); p1.x = 2; p2.y = 3; Taško p1 koordinatės bus (2,2,3), o taško p2 koordinatės bus (3,3,4), t.y. vieno taško koordinačių keitimas neįtakoja kito taško koordinačių. Tačiau gali būti atvejų, kai reikia sukurti kintamąjį bendrą visiems klasės objektams, t.y. tokį, kurio reikšmę keičiant viename objekte, reikšmė pasikeistų ir kituose tos klasės objektuose. Tokie kintamiemi paskelbiami static. Statiniam kintamajam išskiriama viena atminties ląstelė, kuria naudojasi visi klasės objektai. Pvz. klasės Automobile statinis kintamasis number skaičiuoja, kiek buvo sukurta tos klasės objektų: public class Automobile { public static int number; public String name; public Automobile(String pname) { name = pname; public class test { public static void main(string[] args) { Automobile a1 = new Automobile( automobilisa ); a1.number++; System.out.println(a1.name + nr= + a1.number); Automobile a2 = new Automobile( automobilisb ); a2.number++; System.out.println(a2.name + nr= + a2.number); Automobile a3 = new Automobile( automobilisc ); a3.number++; System.out.println(a3.name + nr= + a3.number); Rezulatas: automobilisa nr=1 automobilisb nr=2 automobilisc nr=3 27
STATINIAI METODAI Metodai, kuriuose yra naudojami statiniai kintamieji irgi paskelbiami statiniais, pridedant žodį static, pvz.: public static void main(string[] args) {... Statiniai metodai turi visai kitą prasmę negu kintamieji. Nepriklausomai nuo to ar metodas statinis ar ne, atmintyje visada sukuriama tik viena metodo mašininio kodo kopija, kuria naudojasi visi kalsės objektai (dar sakoma visi klasės egzemlpioriai). Pagrindinė statinio metodo savybė statinis metodas įvykdomas iš karto visuose klasės objektuose (egzemplioriuose). PRIMITYVŪS IR NUORODOS DUOMENŲ TIPAI Java turi aštuonis primityvius duomenų tipus (angl. primitive types), išvardintus lentelėje žemiau. Papildomai Java turi penkis nuorodos tipus (angl. reference types) tokius, kaip klasės, interfeisai, masyvai, sunumeruoti, anotacijos (angl. classes, interfaces, arrays; enumerated types and annotation types are reference types). Java primityvūs duomenų tipai Type Contains Default Size boolean true or false false 1 bit char Unicode character \u0000 16 bits byte Signed integer 0 8 bits short Signed integer 0 16 bits int Signed integer 0 32 bits long Signed integer 0 64 bits float IEEE 754 floating point 0.0 32 bits double IEEE 754 floating point 0.0 64 bits REFERENCE vs. PRIMITIVE TYPES Reference types and objects differ substantially from primitive types and their primitive values: Eight primitive types are defined by the Java language. Reference types are user-defined, so there is an unlimited number of them. For example, a program might define a class named Point and use objects of this newly defined type to store and manipulate X,Y points in a Cartesian coordinate system. The same program might use an array of characters of type char[ ]to store text and might use an array of Point objects of type Point[ ]to store a sequence of points. Primitive types represent single values. Reference types are aggregate types that hold zero or more primitive values or objects. Our hypothetical Point class, for example, might hold two double values to represent the X and Y coordinates of the points. The char[ ] and Point[ ] array types are obviously aggregate types because they hold a sequence of primitive char values or Point objects. 28
Primitive types require between one and eight bytes of memory. When a primitive value is stored in a variable or passed to a method, the computer makes a copy of the bytes that hold the value. Objects, on the other hand, may require substantially more memory. Memory to store an object is dynamically allocated on the heap when the object is created and this memory is automatically "garbage-collected" when the object is no longer needed. When an object is assigned to a variable or passed to a method, the memory that represents the object is not copied. Instead, only a reference to that memory is stored in the variable or passed to the method. This last difference between primitive and reference types explains why reference types are so named. The sections that follow are devoted to exploring the substantial differences between types that are manipulated by value and types that are manipulated by reference. COPYING OBJECTS The following code manipulates a primitive int value: int x = 42; int y = x; After these lines execute, the variable y contains a copy of the value held in the variable x. Inside the Java VM, there are two independent copies of the 32-bit integer 42. Now think about what happens if we run the same basic code but use a reference type instead of a primitive type: Point p = new Point(1.0, 2.0); Point q = p; After this code runs, the variable q holds a copy of the reference held in the variable p. There is still only one copy of the Point object in the VM, but there are now two copies of the reference to that object. This has some important implications. Suppose the two previous lines of code are followed by this code: System.out.println(p.x); // Print out the X coordinate of p: 1.0 q.x = 13.0; // Now change the X coordinate of q System.out.println(p.x); // Print out p.x again; this time it is 13.0 Since the variables p and q hold references to the same object, either variable can be used to make changes to the object, and those changes are visible through the other variable as well. This behavior is not specific to objects; the same thing happens with arrays, as illustrated by the following code: char[] greet = { 'h','e','l','l','o' ; // greet holds an array reference char[] cuss = greet; // cuss holds the same reference cuss[4] = '!'; // Use reference to change an element System.out.println(greet); // Prints "hell!" 29
A similar difference in behavior between primitive types and reference types occurs when arguments are passed to methods. Consider the following method: void changeprimitive(int x) { while(x > 0) System.out.println(x--); x = 5; changeprimitive(x); // 5 4 3 2 1 System.out.println(x); // 5 When this method is invoked, the method is given a copy of the argument used to invoke the method in the parameter x. The code in the method uses x as a loop counter and decrements it to zero. Since x is a primitive type, the method has its own private copy of this value, so this is a perfectly reasonable thing to do. On the other hand, consider what happens if we modify the method so that the parameter is a reference type: void changereference(point p) { while(p.x > 0) System.out.println(p.x--); When this method is invoked, it is passed a private copy of a reference to a Point object and can use this reference to change the Point object. Consider the following: Point q = new Point(3.0, 4.5); // A point with an X coordinate of 3 changereference(q); // Prints 3,2,1 and modifies the Point System.out.println(q.x); // The X coordinate of q is now 0! When the changereference( ) method is invoked, it is passed a copy of the reference held in variable q. Now both the variable q and the method parameter p hold references to the same object. The method can use its reference to change the contents of the object. Note, however, that it cannot change the contents of the variable q. In other words, the method can change the Point object beyond recognition, but it cannot change the fact that the variable q refers to that object. The title of this section is "Copying Objects," but, so far, we've only seen copies of references to objects, not copies of the objects and arrays themselves. To make an actual copy of an object, you must use the special clone( ) method (inherited by all objects from java.lang.object): Point p = new Point(1,2); // p refers to one object Point q = (Point) p.clone( ); // q refers to a copy of that object q.y = 42; // Modify the copied object, but not the original int[] data = {1,2,3,4,5; // An array int[] copy = (int[]) data.clone( ); // A copy of the array Note that a cast is necessary to coerce the return value of the clone( ) method to the correct type. There are a couple of points you should be aware of when using clone( ). clone creates a shallow copy of an object. The copied object contains copies of all the primitive values and references in the original object. In other words, any references in the object are copied, not cloned; clone( ) does not recursively make copies of the objects referred to by those references. A class may need to override this shallow copy behavior by defining its own version of the clone( ) method that explicitly performs a deeper copy where needed. To understand the shallow copy behavior of clone( ), consider cloning a two-dimensional array of arrays: 30