• Szerző: Sallai András
• Copyright © 2009, Sallai András
• Szerkesztve: 2009-2021
• Licenc: CC BY-SA 4.0
• Web: https://szit.hu

A Java-át James Gosling, Patrick Naughton, Chris Warth, Ed Frank, és Mike Sheridan hozta létre a Sun Microsystems, Inc. cégnél 1991-ben. 18 hónap telt el az első verzió megjelenéséig. Ennek az első nyelvnek a neve Oak volt, később 1995-ben lett átnevezve Java-ra. 2009-ben a Sun Microsystems-t felvásárolta az Oracle, így a Java rendszert ők viszik tovább.

Java-át úgy tervezték, hogy az így megírt programok minden operációs rendszeren fussanak minden változtatás nélkül. Ez úgy lehetséges, hogy a Java program nem az operációs rendszeren fut natív módon, azt egy Java környezetben futtatjuk.

A Java nyelven írt programokat java fordítóval fordítjuk le, és Java futtató környezettel futtatjuk. Ez utóbbi azt jelenti, hogy egy operációs rendszeren önállóan futni nem képes. A futtató környezet általánosan keretrendszernek is hívjuk, de az Oracle keretrendszerét Java Runtime Environment néven használjuk, röviden JRE. A fejlesztői környezet pedig a JDK, azaz a Java Development Kit. A fejlesztői környezet tartalmazza többek között a java fordítót, amely parancs a „javac”.

A Java nyelv szigorúan osztályok halmaza, kis és nagybetű érzékeny, minden utasítást pontosvesszővel zárunk.

A Java nyelven írt programokból bájtkódot szokás létrehozni.

Azonban vannak fordítók, amelyek gépi kód létrehozására is alkalmasak.

A bájtkód futtatását a Java keretrendszer, vagy futtató környezet, angolosan Java Runtime Environment, röviden JRE biztosítja.

Készítse el a következő forráskódot a megadott néven, majd mentse, fordítsa és futtassa:

Test.java

class Test {
    public static void main(String[] args) {
        System.out.println("Java működik a gépeden");
    } 
}

Fordítás:

javac test.java

Futtatás:

java test

Előfordul, hogy a futtató keretrendszer nem találja a keretrendszer osztályait. Ekkor a következő kapcsoló megadása szükséges:

java -cp . test

A programban megfigyelhetjük, hogy az összetartozó részeket, továbbiakban blokkokat kapcsos zárójelek határolják:

{  ez a blokk  }

{
   egyik sor
   másik sor
}

A példa alapján azt is észrevehetjük, hogy a blokkok egymásba ágyazhatók, és minden blokknak van egy fejrésze. A blokk fejrészében írjuk le mire is való az adott blokk. A Javaban mindig osztályokkal dolgozunk, angolul class. Osztályokba szervezzük a megvalósítandó programjainkat. Ennek valamilyen nevet kell adni. Fenti példánkban a név „test”. Ennek a névnek meg kell egyeznie az állomány nevével. Ez lesz a kiindulási osztályunk, a program végrehajtása ebben az osztályban kezdődik majd.

A Javaban az egyes tevékenységeket függvényekben valósítjuk meg és szokásos módon metódusnak nevezzük. Minden Java program kell tartalmazzon egy „main” nevű metódust. A programnak ez lesz kiindulási pontja, innen indul, amit úgy mondunk: a program „belépési pontja”. A main metódust a kiinduló osztályunkban hozzuk létre. A neve előtt és után egy pár dolgot meg kell adnunk. A main előtt módosítókat adunk meg. A main kötelező módosítói a public és static. A public biztosítja, hogy a program indításakor a main metódus elérhető legyen az operációs rendszerből. A static módosító biztosítja, hogy a main metódust a nélkül is elérhessük, hogy példányosítanánk a test osztályt (Később látni fogjuk, hogy az osztályokkal sokszor úgy dolgozunk, hogy létrehozunk belőle egy példányt). A void egy speciális típus, azt jelenti nincs típus. Esetünkben ezzel azt mondjuk, hogy a program visszatérési értékkel nem rendelkezik a futtató környezet felé.

A main név után zárójelekben adjuk meg a program bemenő paramétereinek leírását. Ez „String[] args” A bemenő paraméterek leírását akkor is meg kell adnunk ha nem használjuk őket. Fordításkor nem is de futtatáskor hibát kapunk, ha hiányzik. A példában azt látjuk, hogy egy String típusú tömbben amelynek neve „args” tároljuk el a bemenő paramétereket. A String típusról és a tömbökről később lesz szó.

A példában szereplő forrást a javac paranccsal fordítjuk. Alap esetben persze ez nem áll rendelkezésére. Telepítenünk kell a Java SDK valamely verzióját. A telepített SDK könyvtárában lesz egy „bin” nevű könyvtár, ezt útvonalba tesszük. Itt található a javac fordító is.

A java futtató parancs általában működni szokott, ha böngészőnk miatt már telepítettünk egy Java JRE csomagot.

A Java nyelvben osztályokkal dolgozunk. Mivel sok osztály létezik szükséges azok csoportosítása. Az összetartozó osztályokat csomagokban tároljuk. Egy csomag a háttértárolón egy könyvtárnak felel meg.

A System osztály a java.lang csomagból (wrapper) való. Ha egy osztályt a Java nyelvben használni szeretnénk, akkor importálni kell azt a csomagot, amely azt tartalmazza. A java.lang egy olyan alaposztály, amelyet a Javaban nem kötelező importálni, ez biztosítja a Java program alapszerkezetét.

• Milyen kiterjesztése van egy Java forráskódnak?
• Milyen kiterjesztése van egy lefordított Java programnak?
• Eredetileg hány ember hozta létre a Java-át?
• Milyen paranccsal fordítjuk le a Java nyelven írt programunkat?
• Milyen paranccsal tudjuk futtatni a Java programot?
• Egy Java program futtatásakor meg kell adni a program kiterjesztését?
• Mit kell tudni a main() metódusról?
• Milyen karakterrel jelezzük egy blokk kezdetét és végét?
• A main() metódusnak milyen kötelező módosítói vannak?
• A main() metódusnak milyen kötelező bemenő paramétere van?
• A System osztály melyik csomagban található?
• Mi az a void?
• Írasson ki karaktersorozat helyett számokat a képernyőre.
• Oldjon meg feladatokat az általános feladatgyűjteményből. Önnek jelenleg körülbelül az első 20 feladat megoldása jöhet szóba.
• Melyik csomag van alapértelmezetten importálva?
• A Java nyelv kisbetű-nagybetű érzékeny?
• Mi a JDK?
• Mi a JRE?

• A következő programban 3 hiba van. Keresse meg őket.

• A következő programban 2 hiba van. Keresse meg őket.

• A következő programban 2 hiba van. Keresse meg.

• A következő programban 2 hiba van. Keresse meg.

• A következő programban 2 hiba van. Keresse meg.

• A következő programban 2 hiba van. Keresse meg.

class Prog01 {
	public static void main(String[]) {
		System.println("Valami");		
	}
}

• A következő programban 2 hiba van. Keresse meg.

class Prog01 {
	public static void min(String[] args) {
		System.out.pritln("Valami");		
	}
}

• A következő programban 2 hiba van. Keresse meg.

public Prog01 {
	public static void main(String[] arg) {
		System.out.println"Valami");		
	}
}

• A következő programban 2 hiba van. Keresse meg.

class Prog01 {
	public static oid Main(String[] args) {
		System.out.println("Valami");		
	}
}

• A következő programban 2 hiba van. Keresse meg.

class Prog01 {
	Public static void main(String[] args) 
		System.out.println("Valami");		
	}
}

• A következő programban 2 hiba van. Keresse meg.

Progr01.java

class Prog01 {
	public static void main(String[ args) {
		System.out.println("alma");		
		System.out.println("körte")		
		System.out.println("barack");		
		System.out.println("szilva");		
	}
}

A Java nyelvben egy és kétsoros megjegyzések használhatók.

Az egysoros megjegyzést a kettőd darab perjel valósítja meg:

// egy soros megjegyzés

Több soros megjegyzést a /* és */ karakterek közzé írhatunk:

/* ez
   egy
   több
   soros
   megjegyzés */

• A következő programban van egy szintaktikai hiba. Keresse meg.

• A következő programban van egy szintaktikai hiba. Keresse meg.

A kivitel alapesetben azt jelenti írok a képernyőre. Ezt megtehetjük a következő két metódussal a System osztályból:

• print()
• println()

A következőkben összehasonlítjuk a két metódust, megnézzük a különbségeket.

Írjunk programot, amely az „Első” és a „Második” szavakat írja a képernyőre. Használjunk println() metódust:

System.out.println("Első");
System.out.println("Második");

Most írassuk ki a két szót print() metódussal.

System.out.print("Első");
System.out.print("Második");

Nemcsak karaktersorozatokat írathatunk ki, lehet számok és más karakterek is:

System.out.println("ElsőMásodik");

System.out.println("1234");

System.out.println("@!+=");

Ha számokat szeretnénk kiíratni, akkor azokat nem kötelező idézőjelek közzé tenni:

System.out.println(1234);

Ha a számokat idézőjelek nélkül adjuk meg paraméterként, akkor számításokat is végezhetünk vele.

A következő példában beszorozzuk az 1234-es értéket 2-vel.

System.out.println(1234 * 2);

Esetleg összeadásokat végezhetünk vele:

System.out.println(3 + 2);

A kimenet:

5

Ügyeljünk arra, hogy ha az előbbi kifejezést idézőjelbe tesszük, akkor nem az összeadás eredménye íródik ki, hanem a kifejezés karakterről karakterre:

System.out.println("3 + 2");

Kimenet:

3 + 2

Statikus import:

Program01.java

import static java.lang.System.*;
class Program01 {
	public static void main(String[] args) {
		out.println("Hi");
	}
}

A különleges karakterek másként escape szekvenciák.

Néhány karakternek speciális értelmezése is lehet. Ha így akarjuk használni, akkor ezt valahogy jelezni kell. Ilyen speciális értelmezés lehet, amikor egy sortörést akarunk kiíratni. Ezt az „n” karakterrel tehetjük meg, ha a speciális jelentését használjuk. A speciális jelentést egy visszaperjellel (\) jelezzük:

\n

Ilyen speciális kérés lehet egy tabulátorjel kiíratása. A tabulátorjelet a „t” karakter jelképezi. A használatához itt is a visszaperjelet tesszük elé:

\t

Az ilyen karaktereket Escape szekvenciának hívjuk.

Gyakorlásként írjuk a képernyőre a „Helló Világ” nevű programot a következő formában:

Program.java

class Program {
    public static void main(String[] args) {
        System.out.println("Helló\nVilág");
    }
}

A példafeladatban a (\n) escape szekvenciát használjuk.

Program.java

class Program {
    public static void main(String[] args) {
        System.out.println("Helló\tVilág");
    }
}

Vannak olyan karakterek is, amelyeknek a Java nyelven eleve speciális jelentésük van. Ilyen az idézőjel („), amely egy szöveg elejét és végét jelzi. Ha egy karaktersorozatban szeretnénk kiíratni, nehézségekbe ütközünk. Ehhez is tartozik persze escape szekvencia:

\"

Program.java

class Program {
    public static void main(String[] args) {
        System.out.println("Helló\"Világ");
    }
}

Az escape szekvenciák tehát egy-egy betű, amelyet ha alkalmazunk visszaperjellel vezetjük be. Alkalmazhatjuk őket karakterek helyén is.

char sortores = '\n';

A Java nyelv Escape karakterei az alábbi táblázatban láthatók.

Escape szekvenciával megadhatunk Unicode karakter is ha tudjuk annak kódját.

Az alábbi táblázatban a Copyright és negáció jelek unicode-ját látjuk.

A példa kedvéért így íratjuk kia copyright karaktert:

System.out.println("\u00a9");

Még több unicode karakter: http://www.unicode.org/charts/PDF/U0080.pdf

Karakter típusú változók létrehozása és értékadás így a következő módon néz ki:

char ch;
char idezojel;
 
ch = 'a';
idezojel = '\"';

W7 alatt fok:

\u0159

A memóriában adatokat tárolunk, amelyek lehetnek egész számok, valós számok, karakterek, esetleg karaktersorozatok. Az ilyen memóriahelyeket a programozás során mint változókat emlegetjük. A változókat használatuk előtt deklarálni kell. Ez azt jelenti, meg kell mondanunk milyen típusú adatot szeretnénk tárolni az adott memória helyen. Ez azért fontos, mert a rendszer így tudja mekkora helyet kell az adatnak lefoglalni. Az alábbiakban megnézzük hogyan foglalhatunk helyet egész, valós, karakteres, stb., típusok számára.

Példa egy változó deklarációra:

int szam;

A különböző primitív adattípusok számára a memóriában helyet foglalunk, használat előtt. Azonban nem mindegy mekkora helyet kell lefoglalni. Más méretet foglalunk le egy egész típusú számnak vagy más méretet egy valóst típusú számnak.

A memóriában lefoglalt helyre értéket helyezhetünk el a következő utasítással:

szam = 35;

A „szam” nevű memóriahelyre 35 értéket tettük. Akármekkora számot nem tehetünk a memóriahelyre. Ha deklaráláskor az „int” kulcsszót tettük a deklarációba, akkor a legnagyobb beírható szám: 2147483647. A legkisebb: -2147483648.

Az int helyett megadható még egy pár típus. A következő táblázatokban azt látjuk, melyik mekkora helyet foglalhat a memóriában és így mekkora számot tárolhatunk benne, maximum és minimum értékekkel.

Ha nagyobb értéket akarunk elhelyezni egy változóban, mint amire névlegesen megengedett:

short a = 32768;

Fordításkor a következő hibaüzenetet kapjuk:

javac -cp Program.java 
Program.java:6: possible loss of precision
found   : int
required: short
		short a = 32768;
		          ^
1 error
>Exit code: 1

Az int típus esetén:

integer number too large: 2147483648
		int c = 2147483648;
		        ^

Valós típusok tárolására a float és a double típusok használhatók. Tartományuk az alábbi táblázatban látható:

A float egyszeres pontosságú számokat képres tárolni, míg a double dupla pontosságú számokat képes tárolni.

A valós típusok használata:

double a = 3.4d;

double a = 3.4f;

A double esetén elhagyható a szám végéről a „d” betűt:

double a = 3.4;

A karaktereket a char segítségével definiálhatunk, amely egy darab karaktert szimbolizál, ami lehet egy betű, egy szám vagy valamilyen írásjel.

Például:

a

vagy

b

vagy

@

Az „a”, „b” és „et” jel karaktereket jelentik.

Ha meg akarok adni egy karaktert a Java nyelvben azt mindig aposztrófok között adjuk meg. Például:

'a'

vagy:

'b'

vagy:

'@'

Ezek után egy változót a következő módon tárolunk változóban:

char ch; 
ch = 'a';

Gyakorlásként írjunk egy programot, amely egy-egy változóban eltárolja a következő betűket: „a”, „l”, „m”, „a”. Majd írassuk a képernyőre egy sorba:

Program.java

class Program {
    public static void main(String[] args) {
        char a = 'a';
        char b = 'l';
        char c = 'm';
        char d = 'a';
        System.out.print(a);
        System.out.print(b);
        System.out.print(c);
        System.out.print(d);
    }
}

A logikai változóknak két értéke lehet true és false. Deklarálásra a következő szót használom: boolean

Használata például:

boolean van;
van = true;

A szelekciós vagy iterációs kifejezésekben hasznunkra lehetnek, lásd később a szelekciónál.

float a = 3.87;

Ebben a formában hibaüzenetet ad, mi szerint elveszítjük a pontosságot. Ezért egy „f” betűt kell a végére tenni.

float a = 3.87f;

A Java nyelvben nem minden objektum. Az adattípusok egy ilyen speciális csoportot alkotnak. Ezeket primitív típusoknak is szoktuk nevezni.

A Java nyelvben minden típus előjeles (signed), azaz nincs előjel nélküli (unsigned) típus.

A primitív típusok rendelkeznek egy nekik megfelelő csomagolóosztállyal (vagy burkoló osztály).

A következő program true értéket ír a képernyőre, mivel a két változó értéke egyenlő:

double a = 3.0;
double b = 3.0;
System.out.println(a == b);

Ha burkoló osztállyal hozom létre a változókat, az egyenlőség nem igaz:

Double a = 3.0;
Double b = 3.0;
System.out.println(a == b);

Az egyenlőség nem igaz, mert osztályok között az „==” operátor a két osztály hivatkozását hasonítja össze, nem az tartalmát.

Burkoló osztály esetén használjuk az osztály equals() metódusát:

Double a = 3.0;
Double b = 3.0;
System.out.println(a.equals(b));

Maximum értékek kiíratása:

System.out.println(Byte.MAX_VALUE);			
System.out.println(Short.MAX_VALUE);		
System.out.println(Integer.MAX_VALUE);		
System.out.println(Long.MAX_VALUE);

Minimum értékek kiíratása:

System.out.println(Byte.MIN_VALUE);			
System.out.println(Short.MIN_VALUE);		
System.out.println(Integer.MIN_VALUE);		
System.out.println(Long.MIN_VALUE);

Hány biten tároljuk az adott típust:

System.out.println(Byte.SIZE);
System.out.println(Short.SIZE);
System.out.println(Integer.SIZE);
System.out.println(Long.SIZE);

A printf metódussal tizedestört formában is kiírhatók a lebegőpontos számok:

System.out.printf("%f\n\n", Double.MAX_VALUE);

Írjon programot, amelybe a fenti utasításokat helyettesíti be. Például:

Program01.java

class Program01 {
    public static void main(String[] argv) {
        System.out.println(Byte.MIN_VALUE);			
    }
}

A típusok konverziója szélesítéssel angolul: Automatic Type Promotion.

Ha van egy kisebb számokat tárolni képes változónk, annak értéke eltárolható egy nagyobb értékek tárolására képes változóban. Ezt nevezzük szélesítésnek.

Ha eltárolom például egy 35-öt egy byte típusú változóban:

byte a = 35;

Később átadhatom az értéket egy short, int, long, stb. típusú változónak:

byte a = 35;
int b = a;

Ezt azért tehetem, mert „b” változóban nagyobb szám tárolható mint az „a” változóban. Ezt nevezzük szélesítésnek. Fordítva azonban már nem lehetséges.

Az alábbiakban az egyes típusokat látjuk milyen szélesítés alkalmazható rajtuk:

• byte → short, int, long, float, double
• short → int, long, float, double
• char → int, long, float, double
• int → long, float, double
• long → float double
• float → double

Lássuk újabb példával:

byte a = 3;
short b = a;

A példában 3-s számot az „a” változóban tároljuk először, az után szélesítést alkalmazunk meg „a” értékét egy olyan változóban tároljuk el, amely már nagyobb számok tárolására is képes. Vagyis, egy byte típusú változót tartalmát egy short típusúban tárolhatom, ehhez semmiféle konverzióra nincs szükség.

A szűkítés már kényesebb dolog. Az értéket olyan változóban szeretném tárolni amely kisebb számok tárolására alkalmas mint az eredeti.

• short → byte, char
• char → byte, short
• int → byte, short, char
• long → byte, short, char, int
• float → byte, short, char, int, long
• double → byte, short, char, int, long, float

Példa:

short a = 3;
byte b  = (byte) a;

A példánkban a short nagyobb számok tárolására alkalmas, így nem írhatjuk le:

b = a;

Helyette típus kényszerítést használunk. A típuskényszerítés során zárójelbe tesszük annak a típusnak a nevét, amelybe szeretnénk átalakítani. Ha az egyenlőségjel baloldalán egy byte típus van, akkor zárójelbe azt írom „byte”. A típuskényszerítést „kasztolás” névvel is használjuk.

A kasztolás egyébként az angol casting szó magyarosan ejtése: casting [UK: ˈkɑːstɪŋ][US: ˈkæstɪŋ] esés, hajítás, horgászás, kimustrálás, öntés, öntvény, szereposztás, vetemedés, vetés. Eredeti formája: „type casting”. A C nyelvben terjedt el használata. Egy újabb példa a kasztingra:

double a = 3;
int b = (int)a;

Az „a” változó értékét kasztoljuk int típussá.

A literális egy olyan állandó, aminek nincs neve. Literális például a „3”, az „a” betű, a „/” jel, bármi.

Amikor leírjuk, hogy

int a = 3;

a három az egy literális állandó. Állandó, mert a program további részében ezt az adatott nem tudom megváltoztatni, és literális mivel nincs neve. Nem egy névvel hivatkozok rá, hanem beírtam úgy ahogy van.

Literális a következő karakter, egyenlőség jel jobboldalán:

char ch = 'a';

Literális a következő is:

String s = "szilva";

Láthatjuk hogy a szám literálisokat csak úgy leírjuk, a karakterlitárálisokat felsővesszők közé tesszük, a karaktersorozat literálisokat pedig idézőjelek közé tesszük a Java nyelvben.

• Milyen primitív típusok vannak a Java nyelvben?
• Lehet-e valós számokat tárolni egy int típusú változóban?
• Lehet-e valós számokat tárolni egy double típusú változóban?
• Eltárolható-e a 300-as egész érték egy byte típusú változóban?
• Milyen értékeket vehet fel egy boolean típusú változó?
• Írjon le minimum négy primitív típus, írja mellé milyen burkoló osztály tartozik hozz!

A Java-ban a legkisebb tárolási egység. A változókat használat előtt deklarálni kell.

double fizetes;
double _fizetes;
int fizetes;
int $fizetes;
long fizetes;
boolean kesz;

Nem használható változónevek:

double 1salary;
double %salary;
int #holidays;

Egy változó nem kezdődhet számmal, nem kezdődhet százalékjellel, nem kezdődhet kettős-kereszttel.

A változók deklaráláskor értékét is definiálhatjuk:

double fizetes = 70000;

Eddig is használtunk állandókat, konkrétan literális állandókat. A következő állandók úgynevezett nevesített állandók. Azt vállaljuk, hogy a memóriaterületen elhelyezett értéket a program további részében nem fogjuk megváltoztatni. Ehhez a final kulcsszót fogjuk használni:

Program01.java

class Program01 {
	public static void main(String args[]) {
		final int a = 5;		
		System.out.println(a);
	}
}

A programunkban azt vállaljuk, hogy a program további részében az „a” nevű memóriahely tartalmát többet nem változtatjuk meg.

Program01.java

class Program01 {
	public static void main(String args[]) {
		final int ALAPFIZETES = 200000;		
 
		System.out.println(ALAPFIZETES);
	}
}

Az állandókat nagybetűvel szokás írni, hogy megkülönböztessük azokat a változóktól. Így a forráskódban azonnal felismerhető.

• Hogyan nevezzük az egyedváltozókat másként?
• Hogyan nevezzük a statikus változókat másként?
• A helyi változókat hol hozzuk létre?
• Hol érvényesek a paraméterként létrehozott változók?
• Hogyan deklarálunk egy nevesített állandót?
• Mondjon vagy írjon példát literális állandóra.

1. Készítsen egy programot, amely legalább 3 mezőt tartalmaz. Írja át a mezőneveket úgy, hogy ne legyen szabályos. Milyen hibaüzeneteket kap?
2. Az előző programban próbáljon meg mezőket úgy létrehozni, hogy nem ad kezdőértéket.

Értékadást egy darab (=) karater segítségével végzünk. A Java nyelvben előfordul két egyenlőségjel karakter is egymás után, annak azonban más jelentése van. Értékadáshoz csak egy darab karaktert használunk.

Az egyenlőségjel baloldalán álló változó felveszi a jobboldalon álló számállandó, változó vagy kifejezés értékét.

Float a = 3F;

vagy kisbetűvel:

Float a = 3f;

Primitív típus egész számmal:

float b = 3;

Valós számmal már szükséges az „f” vagy „F” jelző:

float b = 3.0f;

Double c = 3.;

double d = 3;

Használhatjuk a „d” vagy „D” jelzőt:

double d = 3.0d;

float a = b;

float a = (b + c) * 3;

A kifejezés operátorokat és operandusokat tartalmazó összeállítás. A példában a operandusok az egyenlőség jel jobb oldalán a „b”, a „c” és a „3”. Operátorok a záró és szorzójel.

Értékadás esetén kifejezés nem állhat az egyenlőségjel baloldalán. A következő utasítás teljesen hibás: (b + c) * 3 = a;

Nézzük meg a következő kifejezés hogyan lesz kiértékelve, mit ír a program a képernyőre:

double a = 1 / 2;
System.out.println(a);

Az eredmény nulla, pedig 0.5 vártunk volna. Pedig egy double típusban tároljuk az eredményt. Mivel az értékadás jobboldalán csak egész számok szerepelnek az értékadás során a tört részek elvesznek.

Ha legalább egy számot valós típusúvá teszünk az eredmény 0.5 lesz.

double a = 1 / 2.0;
System.out.println(a);

A 2-es értéket valóssá számmá változtattuk azzal, hogy után írtunk egy pontot (.) és egy nullát (0). A nulla a Java nyelvben elhagyható:

double a = 1 / 2.;
System.out.println(a);

Használhatjuk a számok után a f vagy a d jelzőt:

double a = 1 / 2f;
System.out.println(a);
 
double b = 1 / 2d;
System.out.println(b);

• Lehet-e egy egyenlőség jel baloldalán összeadni?
• A Double típus esetén milyen jelzőt használunk a szám literális után?
• A Float típus esetén milyen jelzőt használunk a szám literális után?
• Float típus esetén kötelező a szám literális után megadni a jelzőt?

Formázott kivitel esetén, amikor számot vagy egyéb érték használok, az egyszerű képernyőre írás helyett, apróbb formai változtatásokat hajtok végre. Ilyen lehet, hogy a számot, mindenképpen 10 helyen ábrázolom. Az üres helyeken vezető nullákat írok ki. Vagy 3 tizedesjegy pontossággal ábrázolok egy számot. Esetleg mindig ábrázolom az előjelt.

Formázott kivitelt például a printf() metódussal lehetséges:

System.out.printf("formátumkód", változó_állandó_vagy_kifejezés);

Az első argumentum egy formátumszöveg (formátum-karaktersorozat) , amely tartalmaz egy formátumkódot. A második egy változó, egy állandó vagy egy kifejezés.

A formátumkód szintaxisa:

%[argumentum_index$][jelzők][szélesség][.pontosság]konverziós_karakter

A formátumkód mindig százalékjellel (%) kezdődik és egy formátumkarakterrel (konverziós karakter) végződik. A formátumkaraktereket lásd alább. A formátumkód előtt és után bármi állhat a karaktersorozatban.

Ha több argumentum is van, akkor megadhatjuk annak sorszámát, amelyet ki szeretnénk íratni. Az indexelés 1-gyel kezdődik.

Az alábbi példában nem használjuk az argumentumindexet:

System.out.printf("%d %d\n", 3, 4);

Így a képernyőre a következő íródik:

3 4

Az argumentumindext használva a megfordításhoz:

System.out.printf("%2$d %1$d\n", 3, 4);

A következő a kimenet:

4 3

Ehhez persze elég lett volna a két érték felcserélése, ezért a legkevésbé használt lehetőség.

A kiírás szélessége. Egy egész szám, például:

10

System.out.printf("%10d\n", 35);

A kiíratandó szám akárhány számjegyből áll, azt 10 helyen fogjuk ábrázolni, a a maradék hely szóközökkel lesz kitöltve. A tíz helyen a szám jobbra lesz igazítva.

A tizedes jegyek száma. Mindig egy ponttal (.) kezdődik. Például két tizedes jegy:

.2

Valós számok esetén megadhatjuk a tizedesjegyek számát:

System.out.printf("%.2f\n", 35.1234567);

Egyszerre megadható az szám ábrázolásának szélessége és a tizedesjegyek száma is:

System.out.printf("%10.2f\n", 35.1234567);

A könnyebb olvashatóság érdekében nagyobb számok esetén ezredenként elválasztót szoktunk használni a számoknál. Amerikai szokás szerint ez egy vessző (,), de nálunk a magyar nyelvben ezt szóközökkel oldjuk meg. A Java nyelvben egy vessző megadásával vehetjük rá a programunkat az ezredeselválasztó használatára:

System.out.printf("%,f\n", 32432344842.52334);

Program.java

class Program {
	public static void main(String args[]) {
		int a = 45;
		int b = 27;
		System.out.printf("%d  %d\n", a , b);
	}
}

Program.java

class Program {
	public static void main(String args[]) {
		int a = 5;
		int b = 4;
                int c = 3;
		System.out.printf("%d  %d %d\n", a , b, c);
	}
}

Az egymás után megadott „a”, „b”, stb. változók kiíratásának sorrendje megváltoztatható:

Program.java

class Program {
	public static void main(String args[]) {
		int a = 45;
		int b = 27;
		System.out.printf("%d  %d\n", a , b);
		System.out.printf("%2$d  %1$d\n", a , b);
	}
}

Egy dollár jel előtt megadjuk, melyik indexű változó kiíratására gondoltunk. Ezzel persze egy változó többször is kiíratható. A következő példában az „a” változó tartalmát kétszer is kiíratom.

Program.java

class Program {
	public static void main(String args[]) {
		int a = 45;
		int b = 27;
		System.out.printf("%d  %d\n", a , b);
		System.out.printf("%2$d  %1$d  %1$d\n", a , b);
	}
}

A váltózók indexei 1-gyel kezdődnek.

A jelzők sorrendje felcserélhetők. Az összes jelző alkalmazás lehetséges, de előfordul, hogy az egyik jelző használat értelmetlen a másik mellett.

Az ezredeselválasztó Linuxon gond nélkül működik, Windowson Unicode fontokat kell beállítani, másként nem működik.

A formátumkódot mindig egy konverziós karakter zárja . Az alábbi táblázatban láthatjuk a lehetséges formátumkódokat.

double a = 2,7183;
System.out.printf("Szám: %+10.4f", a);
// " Szám =    +2,7183"
 
System.out.format("Hatvany: %.2f\n", b);

Az óra, perc, másodperc kiíratása:

System.out.printf("%tT\n", java.util.Calendar.getInstance());

Az év kiíratása:

System.out.printf("%tY\n", java.util.Calendar.getInstance());

Az óra kiíratása:

System.out.printf("%tH\n", java.util.Calendar.getInstance());

Program.java

import java.util.Calendar;
 
class Program {
	public static void main(String args[]) {
 
		Calendar datum = Calendar.getInstance();
		System.out.printf("%tH\n", datum);
	}
}

Még több példa:

      Calendar c = Calendar.getInstance();
      // -->  "May 29, 2006"
      System.out.format("%tB %te, %tY%n", 
                        c, c, c);
 
      // -->  "2:34 am"
      System.out.format("%tl:%tM %tp%n",
                        c, c, c);
 
      // -->  "05/29/06"
      System.out.format("%tD%n", c);

Mint azt fentebb láttuk sortörést lehet kiíratni a println() metódussal, de az '\n' escapeszekvencia is használható erre a célra. Ugyanezt tehetjük meg a „%n” segítségével.

Az aktuális operációs rendszer sortörésének kiíratása:

System.out.format("%f%n%n", 455.3823);

Forma.java

import java.io.*;
import java.util.*;
class Forma {
    public static void main(String args[]) throws IOException {
        Formatter formazo = new Formatter();
 
        formazo.format("%s %d %f", "Java", 10, 97.5);
 
        System.out.println(formazo);
 
	System.in.read();
    }
}

A Formatter osztály a java.util csomagban található.

Program.java

import java.text.DecimalFormat;
 
class Program {
	public static void main(String args[]) {
		DecimalFormat sajatForma = new DecimalFormat("###,###.###");
		System.out.format(sajatForma.format(123456.789));
	}
}

Program.java

import java.io.Console;
 
class Program3 {
	public static void main(String args[]) {
		Console konzol = System.console();		
		konzol.printf("Helló Világ!\n");
	}
}

• Mikor használjuk a formázott kivitelt?
• Mi a formátumkód?
• Mi a formátumkarakter?
• Milyen formátumkóddal írathatunk ki egész számokat?
• Mit jelent a formátumkódban a %?
• Milyen formátumkóddal írathatunk ki karaktereket?
• Írjon példát, hogyan határozza meg, hogy egy „a” változóban tárolt valós szám, három tizedesjegy pontossággal íródjon ki.
• Milyen formátumkóddal írathatunk ki valós számokat?
• Milyen formátumkóddal írathatunk ki karaktersorozatokat?

A Math osztály olyan metódusokat tartalmaz, amelyek megkönnyítik a matematikai feladataink megoldását. Ilyenek az abszolút érték számítása, gyökvonás, hatványozás, trigonometriai függvények számítása, stb.

A Math osztály importálás és példányosítás nélkül azonnal rendelkezésünkre áll. A következő példában -15 abszolút értékét számítjuk ki.

Matek

import java.io.*;
class Matek {
    public static void main(String args[]) throws IOException {
        System.out.format("%d\n", Math.abs(-15));		
	System.in.read();
    }
}

Egy szám abszolút értékét adja vissza.

Ha megnézzük a Java API dokumentációt ehhez hasonlókat láthatunk:

double abs(double a)
float abs(float a)
int abs(int a)
long abs(long a)

Ebből tudhatjuk, hogy az abs metódusnak négy módon használhatjuk. Megadhatunk paraméterként double, float, int vagy long típust. Ha double adunk meg double típust ad vissza. Ezt az első sorból látjuk:

double abs(double a)

A „double a” mutatja, hogy milyen bemenő paraméter jöhet szóba, az elején a „double” pedig azt mutatja milyen értéket ad vissza a metódus.

Hatvány számítása:

double a = Math.pow(3, 2);

Az első szám alap, a második a kitevő.

double b = 1;

Adott szám gyökével tér vissza.

System.out.println(Math.sqrt(9));

double c = Math.sin(b * Math.PI / 180);
double d = Math.sin(Math.toRadians(b));
 
System.out.printf("Szinusz : %.5f\n", c);
System.out.printf("Szinusz : %.5f\n", d);

A trigonometriai függvények radiánban várják az értékeket. A bemenő paramétert ezért át kell konvertálni előbb radiánba.

System.out.println(Math.PI);

A PI nem függvény! Tulajdonság!

Az Euler-féle szám (jele: e) egy matematikai állandó, amit a természetes logaritmus alapja

System.out.println(Math.E);

Az E nem függvény! Tulajdonság!

Két szám közzül a nagyobbat adja vissza:

System.out.println(Math.max(7,4));

Két szám közül a kisebbet adja vissza:

System.out.println(Math.min(7,4));

A round a tizedes törtet kerekíti. .4-től lefele, .5-től felfele:

System.out.println(Math.round(1.5));

Eredménye: 2

System.out.println(Math.round(1.4));

Eredménye: 1

A ceil függvény a tizedes törtet felfelé kerekíti.

System.out.println(Math.ceil(1.0));

Eredménye: 1

System.out.println(Math.ceil(1.1));

Eredménye: 2

A floor függvény a tizedes törtet lefelé kerekíti.

double floor(double a)

Két példa:

System.out.println(Math.floor(1.1));

Eredménye: 1

System.out.println(Math.floor(1.9));

Eredménye: 1

Radiánfok átszámítása szögfokká.

Math.toDegrees(85);

Szögfok átszámítása radiánfokká.

Math.toRadians(85);

Az exponenciális függvény e^x vagy exp(x), ahol e egy matematikai állandó, a természetes alapú logaritmus alapja, értéke körülbelül 2,718281828, és Euler-féle szám

double exp(double a)

A hatványozás egyik megfordított (inverz) művelete

double log(double a)

A log() a szám természetes logaritmusát adja. A matematikában ln(x) a jelölése.

double log10(double a)

A log10() a szám 10 alapú logaritmusát adja. A matematikában a lg(x) a jelölése.

double log1p(double x)

A log1p a szám és 1 összegének logaritmusát adja.

• Milyen értéket várnak a trigonometriai függvények? Radián vagy szög?
• Milyen metódussal számítható át szögfok radiánra?
• A log(a) melyik logaritmust típust számítja ki?
• Melyik metódussal kerekíthetünk a tört részeket felfelé?
• Melyik metódussal kerekíthetjük a tört részeket lefelé?
• Melyik metódussal tudunk a kerekítés szabályai szerint kerekíteni?
• A log(a) függvénynek milyen típusú a bemenőparamétere és a visszatérési értéke?

A véletlenszámok előállítására két osztály áll rendelkezésünkre. A Random és a Math.

Az eddig használt osztályok a java.lang csomagban voltak, amit nem kellett importálni. A Random osztály az eddigiektől eltérően importálni kell, a java.util csomagban található. Használni sem használhatjuk csak példányosítással. A példányosítás azt jelenti létrehozunk az osztályból egy példányt.

Az osztályok hasonlítanak például a „dolgozó” fogalomhoz. Ha azt mondom „dolgozó” az nem egy konkrét személy, konkrét ember, akár ki lehet. Ha azt mondom a Jóska nevű dolgozó akkor már konkretizáltam. A Jóska tulajdonképpen a dolgozó egy példánya. A Java nyelvben ehhez használjuk az osztályokat. Az osztály egy általános dolog. Ha példányosítom akkor, létrehoztam az adott osztály egy példányát. A létrehozott példányt objektumnak nevezzük. Az előbbi „dolgozó” analógiában az objektum a „Jóska példánynak” felel meg.

A Random osztályt példányosítani kell használat előtt, azt pedig a new utasítással tudjuk megtenni. Lássunk a példányosításra egy példát:

Random veletlen = new Random();  

A példánkban kitaláltunk egy objektum nevet, ez a „veletlen”. A példányosítás utn a „veletlen” egy olyan objektum, amelyet a Random osztályból hoztunk létre a „new Random()” kifejezés segítségével.

A háttérben, tulajdonképpen a memóriában egy „veletlen” nevű objektumnak foglaltunk helyet a „new Random()” kifejezéssel.

A Random osztály importálása:

import java.util.Random;

A Random osztály példányosítása veletlen objektum létrehozásával:

Random veletlen = new Random();

A veletlen objektum használata:

int szam = veletlen.nextInt(3);

A Random osztály egyik metódusa a nextInt(). A nextInt() metódus egy véletlen számot generál, ha meghívjuk a veletlen objektumon. A példánkban a generált számot a „szam” nevű változóban tároljuk.

A nextInt() metódusnak paraméterként 3-at megadva 0 és 2 közötti értéket kaphatunk.

1 és 6 közötti szám előállítása ezek után:

Random veletlen = new Random();
int dobas = veletlen.nextInt(6) + 1;

A következő táblázatban a Random osztály további metódusait láthatjuk. A „veletlen” objektum helyett, azonban csak egy „r” nevű objektumot használunk a rövidség miatt.

A Math.random() 0.0…0.999999 között állít elő egy számot.

double a = Math.random();
System.out.printf("%.20f\n", a);

A következő kimenetet adja:

0,509873801078128200000

Ha négyel szoroztam volna a számot:

double a = Math.random();
System.out.printf("%.20f\n", a * 4);

Kimenet például:

2,03949520431251270000

A szám egész része egy 0 és 3 közötti szám.

Ebből lehet egy egész véletlen számom.

Esetleg így is írhatjuk:

double a = 4 * Math.random();
System.out.println(a);

Ha mindig hozzáadunk 1-t, akkor 1 és 4 közötti számot kapunk:

double a = 4 * Math.random() + 1;
System.out.println(a);

Példa 1 és 10 közötti egész szám előállítására:

szam = (int) (10 * Math.random()) + 1;

• Mit állít elő a Math.random() metódus?
• Generáljon 10 és 20 között egy számot.
• Milyen osztályokkal állíthatunk elő véletlen számokat?
• Mondjon két példát a Random osztály metódusaira.
• Szükséges-e példányosítani a Random osztályt használatához?

Az értékadást általánosan így írhatjuk le:

<változó> = <kifejezés> 

Lássunk néhány konkrét példát a használatára:

int a, b;
a = 2;     // 2 értéket hozzárendeljük az a változóhoz
b = 5;     // 5 értéket hozzárendeljük a b változóhoz

Home home1 = new Home();  // új objektum készítése
Home home2 = home1;       // home1 referencia home2-be rendelése

A (+) egyoperandusú operátort a C nyelvben tették szabvánnyá először a (-) operátor ellentéteként csak a szimetria kedvéért. A (+) operátor használata így nem tesz semmit az értékkel, azt kapjuk ami van.

A (!) operátor az ellentétére fordít egy logikai értéket. A true értékből false értéket csinál és fordítva. Teszteljük a következő programmal:

System.out.println(true);
System.out.println(!true);
 
System.out.println(false);
System.out.println(!false);

Az egyenlő operátor visszaad egy true vagy false értéket, attól függően igaz-e amit állítunk.

int a = 4;
System.out.println(a == 3);

A következő program ugyanígy true vagy false értéket ír ki, de most az ellentétére kérdezünk:

int a = 4;
System.out.println(a != 3);

A többi logikai operátor is hasonlóan használható.

Az && operátor feltételes ÉS, amelyet két logikai állítás között szoktunk használni. A következő példában két állítást teszünk. Először azt állítjuk, hogy az „a” értéke 3, majd b értéke 4. Ha mindkettő igaz lenne, akkor kapnánk igaz értéket a teljes kifejezésben:

int a = 4;
int b = 4;
System.out.println(a == 3 && b == 4);

A példánkban false értéket kapunk, mert az a változóban nem 3-as érték szerepel.

Ha egy kifejezésben több operátor is van, akkor el kell dönteni, mi lesz az operátorok végrehajtásának sorrendje. Ezt nevezzük precedenciának. Az alábbiakban a Java nyelv precedencia táblázatát látjuk:

A táblázatban legfelül látjuk azokat amelyek hamarabb végrehajtásra kerülnek. Mi történik akkor, ha azonos precedenciaszintű operátorokból van több? Ebben az esetben azok balról jobbra, sorba egymás után hajtódnak végre.

Lássunk egy példát:

int szam = 1 + 2 + 3;
System.out.println(szam);

Az utasítások balról jobbra végrehajtódnak, de nekünk persze mindegy, mert az eredmény ugyanaz, ha először a második összeadás hajtódik végre.

A következő példában viszont nem mindegy melyik operátor hajtódik először végre:

int szam = 1 + 2 * 3;
System.out.println(szam);

Ebben az esetben először a szorzás hajtódik végre, majd az összeadás.

A zárójelekkel azonban ezen változtathatunk:

int szam = (1 + 2) * 3;
System.out.println(szam);

Először a zárójelen belüli összeadás kerül végrehajtásra, majd a szorzás.

Adott a következő Java programrészlet:

int a = 3;
b = a++;

Jó kérdés lehet, hogy milyen érték kerül a b változóba. A kérdés úgy is feltehető, hogy az „++” operátor mikor növeli az „a” változó értékét? Mielőtt átadja az értékét „b” változónak, vagy csak utána. A helyes válasz csak utána. A b változóba tehát 3 kerül, utána növeli a ++ operátora az „a” változó tartalmát.

Ezzel ellentétes viselkedés is elérhető, ha az ++ operátort nem a változó utána, hanem az előtt szerepeltetjük:

int a = 3;
b = ++a;

Ebben az esetben a „b” változó értéke 4 lesz, mivel az operátor előbb növelte „a” értékét, majd ez az érték került átadásra.

A „–” operátor használata megegyezik a „++” használatával, ebből a szempontból.

Program02.java

class Program02 {
	public static void main(String[] args) {
		int a = 3;
		int b = ~a;
		System.out.printf("%32s\n", Integer.toBinaryString(a));
		System.out.printf("%32s\n", Integer.toBinaryString(b));
	}
}

Program01.java

//Előjeles balra mozgatás (baloldalon mindig az előjel bit jön be)
class Program01 {
	public static void main(String[] args) {
		int a = 3; //Próbáljuk ki negatív értékkel
		int b = a << 2;
		System.out.printf("%4s\n", Integer.toBinaryString(a));
		System.out.printf("%4s\n", Integer.toBinaryString(b));
	}
}
//A baloldali első bit az előjel bit negatív számok esetén 1, pozitív esetén 0.

Program03.java

//Előjel nélküli jobbra mozgatás (baloldalon mindig 0 jön be)
class Program03 {
	public static void main(String[] args) {
		int a = 14;
		int b = a >>> 1;
		System.out.printf("%32s\n", Integer.toBinaryString(a));
		System.out.printf("%32s\n", Integer.toBinaryString(b));
	}
}

Program03.java

//Előjeles jobbra mozgatás
class Program03 {
	public static void main(String[] args)
	{
		int a = 14;
		int b = a >> 1;
		System.out.printf("%32s\n", Integer.toBinaryString(a));
		System.out.printf("%32s\n", Integer.toBinaryString(b));
	}
}

A feltételes operátor tulajdonképpen az if-then-else hasonlata. Van egy feltétel a kérdőjel előtt. Ha igaz, akkor az első értéket kapj az egyenlőség baloldalán álló „b” változó. Ne nem igaz, akkor a kettőspont utáni értéket kapja.

Program.java

class Program {
	public static void main(String[] args) {
		int a = 8;
		String b =  a > 5  ?  "Nagyobb"  :  "Kisebb";
		System.out.println(b);
	}
}

Program01.java

class Program01 {
	public static void main(String[] args) {
		Integer a = 3;
 
		System.out.println(a instanceof Integer);
	}
}

Primitív típussal nem működik a instanceof operátor!

A mellékletek részben találunk egy sokkal hasznosabb példát az operátor használatára. A jelen példának azért nincs sok értelme, mert az Integer helyett nem is tudunk mást írni.

Legyen egy „a” változó, amelynek értékét szeretnénk 2-vel növelni. Ekkor ezt írnánk:

int a = a + 2;

Ennek van egy rövidebb formája:

int a += 2;

A plusz jelet az egyenlőség jel elé tesszük, az „a” változóba pedig csak egyszer írom le.

Lehetséges kombinált értékadó operátorok:

+= -= *= /= %= &= ^= |= <<= >>=

Hármas operátor. Ennek az operátornak három operandusa van, ezért a neve.

Az operátor egy kérdőjelből és egy kettőspontból áll:

? :

Használatát lásd a szelekciónál.

• A bitenkéni AND vagy a logikai AND van előrébb a prioritási sorban?
• A logikai AND vagy a logikai OR van a prioritási sorban előbb?
• Mire való az instaceof változó?
• Mutassa be hogyan működik a feltételes értékadás.
• Mi a különbség a >> és a >>> operátor között?

System.out.println(Integer.parseInt("89"));

String s = "25";
int a = Integer.valueOf(s).intValue();

A valueOf() egyik prototípusa:

static Integer valueOf(String s) 

Visszatér egy karaktersorozat számértékével egy Integer objektumban eltárolva.

Az intValue() metódussal primitív int típussá alakítjuk.

Az intValue()prototípusa:

int intValue()

String s = "87";
System.out.println(Integer.parseInt(s));

Szöveges formában tárolt valós számot alakítunk egésszé.

int a = Float.valueOf( "799.87" ).intValue();

System.out.println(Double.parseDouble("89.5"));

Double d = Double.valueOf(str).doubleValue();

Float f = Float.valueOf(str).floatValue();

  long l = Long.valueOf(str).longValue();
 
  Long l = Long.parseLong(str);

System.out.println(Integer.toString(77));

System.out.println(Float.toString(77.88));

System.out.println(Double.toString(77.88));
 
double a = 3; 
System.out.println(Double.toString(a));

Long a = 7L;
String str = Long.toString(a);

int a = Integer.valueOf("B8DA3", 16).intValue();

int a = Integer.parseInt("B8DA3", 16); 

A következő sor például a 11-et ír a képernyőre:

System.out.println(Integer.parseInt("B", 16));

String s = String.valueOf('c');

char ch = 'A';
int b = ch;
System.out.println(b); //Az eredmény: 97

vagy:

char ch = 'A';
int b  = (int) ch; 
System.out.println(b); //Az eredmény: 97

int a = 97;
char ch = (char)a;
System.out.println(ch); //Az eredmény: a

String str = "ABCD";
for ( int i = 0; i < str.length(); ++i ) {
     char c = str.charAt(i);
     int j = (int) c;
     System.out.println(j);
}

int a = 2;
boolean b = (a != 0);

A nulla érték mindig hamis lesz. Az ettől eltérő pedig igaz.

boolean a = true;
int b = a ? 1 : 0;

A true és a false a következő módon alakul át:

• true –> 1
• false –> 0

try {
    a = Integer.parseInt(str);
} catch(NumberFormatException e) {
 
}

String s = "some text here";
byte[] b = s.getBytes("UTF-8");

byte[] b = {(byte) 99, (byte)97, (byte)116};
String s = new String(b, "US-ASCII");

Az US-ASCII helyett lehet „UTF-8” is

Double a = 3.8;
int b = Double.valueOf(a).intValue();

Float a = 3.8f;		
int b = Float.valueOf(a).intValue();

double a = 3.8;
int b = (int) a;

Konvert.java

import java.io.*;
 
class Konvert {
    public static void main(String args[]) throws IOException {
		int i = 2;
		String bin = Integer.toBinaryString(i);
		System.out.println(bin);
 
		System.in.read();
    }
}

Konvert.java

import java.io.*;
 
class Konvert {
    public static void main(String args[]) throws IOException {
		int i = 11;
		String bin = Integer.toBinaryString(i);
		System.out.println(bin);
 
		String hexstr = Integer.toHexString(i);
		System.out.println(hexstr);
 
		System.in.read();
    }
}

String s = "1000100010000000";
int a = Integer.parseInt(s, 2);

• Hogyan konvertálunk karaktersorozatot egész számmá?
• Hogyan konvertálunk karaktersorozatot egész valós?
• Hogyan konvertálunk valós számot karaktersorozattá?
• Hogyan konvertálunk egész számot karaktersorozattá?
• Hogyan konvertálunk karaktert karaktersorozattá?

A Java nyelven az olvasás a billentyűzetről nem egyszerű feladat. Van ugyan az in mezőnek egy read() metódusa, de az csak egyetlen bájtot olvas be. Ha ezzel kérnénk be egy számot, azt utána még át kellene konvertálnunk számmá. A System.in.read() metódust így legfeljebb arra használjuk, hogy várjunk egy „Enter” lenyomására.

Másik megoldás lehet a projekten jobb egér gomb „Run Maven” > Goals. Majd töltsük ki:

• Goals: exec:java
• egy_létező-profile
• exec.mainClass=and.zold.main.Main

Megoldás lehet még, a java.io csomag osztályainak használata.

Program01.java

import java.util.Scanner;
 
class Program01
{
    public static void main(String args[])
    {
        Scanner bevitel = new Scanner(System.in);
 
        System.out.print("Egész szám: ");
	int a = bevitel.nextInt();
 
	System.out.println(a);
 
     }
}

Program02.java

import java.util.Scanner;
 
class Program02
{
    public static void main(String args[])
    {
        Scanner bevitel = new Scanner(System.in);
 
	System.out.print("Valós szám: ");
	double b = bevitel.nextDouble();
	System.out.println(b);
     }
}

Program03.java

import java.util.Scanner;
 
class Program03
{
    public static void main(String args[])
    {
        Scanner bevitel = new Scanner(System.in);
 
	System.out.print("Szöveg: ");
	String s = bevitel.nextLine();
	System.out.println(s);
     }
}

Program04.java

import java.util.Scanner;
class Program04
{
	public static void main(String args[])
	{
		Scanner bevitel = new Scanner(System.in);
 
		System.out.print("Egész szám: ");
		int a = bevitel.nextInt();
 
		System.out.print("Valós szám (vesszővel írjuk a tizedesvesszőt): ");
		double b = bevitel.nextDouble();
 
		System.out.println(a + b);
	}
}

Program05.java

import java.util.Scanner;
class Program05
{
	public static void main(String args[])
	{
		Scanner bevitel = new Scanner(System.in);
 
 
		System.out.print("Szöveg: ");
		String s1 = bevitel.nextLine();
 
		System.out.print("Szöveg: ");
		String s2 = bevitel.nextLine();
 
		System.out.println(s1 + " " + s2);
	}
}

A Scanner osztállyal nem tudunk közvetlenül char vagy Character típust bekérni, bár megtehetjük, hogy egy beolvasott karaktersorozat első elemét vesszük:

Program06.java

import java.util.Scanner;
 
class Program06
{
	public static void main(String args[])
	{
		Scanner olvaso = new Scanner(System.in);
 
		char ch = olvaso.nextLine().charAt(0);
 
		System.out.println("Olvasott: " + ch);
	}
}

A fenti példákban láttuk, hogy Scanner osztály remek lehetőség a bekérésekre. Ha viszont magyar ékezetes betűket írunk bekéréskor Windowson, azok hibásan jelennek meg, mivel a felület ahol a bekérés történik 852-s kódlappal dolgozik, és erről nem tud a Scanner osztály. Lehetőség van, azonban arra, hogy megadjuk mi beviteli környezet kódlapja. A kódlapok a következők lehetnek:

• 852 (közép-európai környezetben, parancssorban)
• cp1250 – Windows-1250 (közép-európai környezetben)
• cp1252 – Windows-1252 (nyugat európai környezetben)

Ha parancsablakban fut a program, 852 bemenet beállítása:

Scanner sc = new Scanner(System.in, "852");

Ha Windows ablakban fut a program, cp1250 bemenet beállítása:

Scanner sc = new Scanner(System.in, "cp1250");

Ha szeretnénk operációs rendszertől függővé tenni a kódlap beállítást, akkor használhatjuk a System osztály getProperty() metódusát.

System.out.println(System.getProperty("os.name"));

Az OS megállapítása:

String os = System.getProperty("os.name").toLowerCase();
if(os.indexOf("win") >= 0) {
	System.out.println("Windows");
}else if(os.indexOf("nix") >=0 || os.indexOf("nux") >=0 || os.indexOf("aix") >0) {
	System.out.println("Unix");
}else if(os.indexOf("mac") >= 0) {
	System.out.println("Mac");
}

Az io csomagból a BufferedReader és az InputStreamReader osztályokat vesszük segítségül. Az io csomag osztályait nem használhatjuk kivételek feldolgozása nélkül. A metódust felkészíthetjük, hogy kezelje a kivételt, vagy rávesszük, hogy dobja el azt.

A példaprogramunkban kivételeket nem kezelünk, eldobjuk őket. Az eldobáshoz a metódus fejrészének a végére írjuk: „throws IOException.

Program01

import java.io.*;
 
public class Program01
{
    public static void main(String[] args) throws IOException
    {
        InputStreamReader befolyam = new InputStreamReader(System.in);
        BufferedReader bemenet = new BufferedReader(befolyam);
        String s;
        int szam;
 
        System.out.print("Szám: ");
        s = bemenet.readLine();
        szam = Integer.valueOf(s).intValue();
 
        System.out.println("Ezt írtad: " + szam);
    } /* main vége */
} /* Fő osztály vége*/

Amit még felfedezhetünk, hogy a bekéréshez két osztály szükséges.

A következő kód megegyezik az előzővel, de az InputStreamReader deklarációt beágyaztuk a BufferedReader részbe.

import java.io.*;
 
public class ap 
{
    public static void main(String[] args) throws IOException
    {
        BufferedReader bemenet = new BufferedReader(new InputStreamReader(System.in));
        String s;
        int szam;
 
        System.out.print("Szám: ");
        s = bemenet.readLine();
        szam = Integer.valueOf(s).intValue();
 
        System.out.println("Ezt írtad: " + szam);
    } /* main vége */
} /* Fő osztály vége*/

konzol.java

import java.io.*;
class Program
{
	public static void main(String args[])
	{
		Console console = System.console();
                System.out.print("Szöveg: ");
		String str = console.readLine();
		System.out.println(str);
	}
}

Beolvasásra használható a System.console() metódus. Ez a metódus egy Console osztályt ad vissza, amelyen van egy readLine() metódusa, amely már alkalmas beolvasásra.

Program01.java

class Program01
{
	public static void main(String args[])
	{		
		System.out.print("Név: ");
		String nev = System.console().readLine();
 
		System.out.println("Ezt írtad: " + nev);
	}
}

A bekéréssel együtt írhatunk is a képernyőre a bekérés előtt:

Program01.java

class Program04
{
	public static void main(String[] args)
	{
		String szamStr = System.console().readLine("Kerek egy szamot: ");
		System.out.println("Ezt irtad: " + Integer.parseInt(szamStr));
	}
}

A readLine() valójában formázott bemenetre képes.

Program.java

import java.io.Console;
 
class Program
{
	public static void main(String args[])
	{
		Console kon = System.console();
 
		System.out.print("Név: ");
		String szoveg = kon.readLine();
 
		System.out.println("Neved: " + szoveg);		
	}
}

Program.java

import java.io.Console;
 
class Program
{
	public static void main(String args[])
	{
		Console kon = System.console();
 
		System.out.print("Szam: ");
		int szam = Integer.parseInt(kon.readLine());
 
		System.out.println("Duplája: " + szam * 2);		
	}
}

char ch;
 
System.out.print("Karakter: ");
ch = (char) System.in.read(); System.in.read();
System.out.println("A beírt karakter: " + ch);
 
System.out.print("Karakter: ");
ch = (char) System.in.read(); System.in.read();
System.out.println("A beírt karakter: " + ch);
 
System.out.print("Karakter: ");
ch = (char) System.in.read();
System.out.println("A beírt karakter: " + ch);

Ha több karaktert kérünk be az első karakter leütése után a leütött „Enter” a billentyűzet pufferben marad. Így következő billentyűzetről olvasás nem vár billentyűnyomásra, hanem tovább lép. Ezt az „Enter” billentyűt kiolvassuk a bekérés után tett System.in.read() utasítással.

Komplett példa:

Program.java

import java.io.*;
 
class Program
{
	public static void main(String args[]) throws IOException
	{
		System.out.print("Karakter: ");
		char ch1 = (char) System.in.read(); System.in.read();
 
		System.out.print("Karakter: ");
		char ch2 = (char) System.in.read(); System.in.read();
 
		System.out.print("Karakter: ");
		char ch3 = (char) System.in.read(); System.in.read();
 
		System.out.println("A beírt karakterek: " + ch1 + " " + ch2 + " " + ch3);
	}
}

Karakterbekérés két másik módja:

ch = (char) System.console().reader().read(); //Java 6

A következő megoldás nem hagyja az Entert a billentyűzetpufferben.

ch = (char) new InputStreamReader(System.in).read();

Program.java

import java.io.*;
 
class Program
{
	public static void main(String args[]) throws IOException
	{
 
		char ch;
 
		System.out.print("Karakter: ");		
		ch = (char) System.console().reader().read();
		System.console().reader().read();
		System.out.println(ch);
 
		System.out.print("Karakter: ");		
		ch = (char) System.console().reader().read(); 
		System.console().reader().read(); 
		System.out.println(ch);
 
		System.out.print("Karakter: ");		
		ch = (char) new InputStreamReader(System.in).read();
		System.out.println(ch);
 
		System.out.print("Karakter: ");		
		ch = (char) new InputStreamReader(System.in).read();
		System.out.println(ch);
	}
}

Újabb példa:

Program.java

import java.io.*;
 
class Program
{
	public static void main(String args[]) throws IOException
	{
		System.out.print("Karakter: ");
		char ch1 = (char) new InputStreamReader(System.in).read();
 
		System.out.print("Karakter: ");
		char ch2 = (char) new InputStreamReader(System.in).read();
 
		System.out.print("Karakter: ");
		char ch3 = (char) new InputStreamReader(System.in).read();
 
		System.out.println("A beírt karakterek: " + ch1 + " " + ch2 + " " + ch3);
	}
}

• Soroljon fel osztályokat, amelyekkel megvalósítható bekérés.
• A Scanner osztállyal milyen primitív típust nem tudunk bekérni?
• Írjon példát a egy karakter sorozat bekérésére.
• Ha egy bejövő szám adatot karaktersorozatként kapunk meg, hogyan tudjuk átkonvertálni szám típussá?

Alapesetben a program forráskódjában az utasítások egymás után sorban hajtódnak végre futtatáskor. Ezt nem mindig szeretnénk. Lesznek olyan utasítások, amelyek végrehajtását bizonyos feltételhez akarjuk majd kötni. Ha feltétel teljesül akkor végrehajtjuk az utasítást vagy utasításokat, ha nem akkor nem teszünk semmit, vagy éppen az utasítások egy másik csoportját akarom végrehajtani.

Vegyünk egy egyszerű iskolapéldát. Szeretném eldönteni egy változóról, hogy kisebb számot tartalmaz-e mint 100. Ha kisebbet, akkor szeretném kiírni, hogy kisebb. Ehhez tennem kell egy állítást. Például, legyen az „a” változó amit vizsgálok. Azt állíthatom például, hogy kisebb:

a < 100

Ez vagy igaz, vagy hamis állítás. Szükségünk van a Java nyelvben egy olyan utasításra, amellyel ezt képesek vagyunk megvizsgálni. Ez lesz az if.

Az if utasítással meg tudjuk vizsgálni, hogy egy állítás igaz, vagy hamis. Az állítást, mindig zárójelek közzé kell tennünk, az if után:

if (feltétel) utasítás;

A zárójel után jöhet az utasítás. Az utasítást persze tehetjük a következő sorba is, ha úgy átláthatóbb:

if (feltétel) 
    utasítás;

Előfordul, hogy nem egy hanem több utasítást akarunk végrehajtani a feltétel teljesülése esetén. Az utasításokat ilyenkor blokk nyitó és blokk záró karakterek közzé teszem:

if (feltétel)
{
    utasítás_1;
    utasítás_2;
    ...
    utasítás_n;
}

A kapcsos zárójel jelzi, hogy a közzé zárt utasításokat együtt szeretném kezelni.

A következő lehetséges eset, hogy ha feltétel nem teljesül, akkor is szeretnék valamilyen utasításokat végrehajtani. Ekkor az utasítás után egy „else” kulcsszó után írom ezeket az utasításokat.

if (feltétel)
    utasítás_1;
else
    utasítás_2;

Ha a feltétel teljesül, akkor az első utasítás hajtódik végre, ha nem, akkor a második, azaz az „else” utáni utasítás.

Ugyanez több utasítással:

  if (feltétel)
  {
      utasítás_1;
      utasítás_2;
      ...
      utasítás_n;
  }
  else
  {
      utasítás_1;
      utasítás_2;
      ...
      utasítás_m;
  }

Eddig az szelekciónak csak a szintaxisát mutattuk be. Álljon itt egy konkrét példa a az if használatára:

Szelekció példa

szel.java

import java.util.*;
class szel
{
        public static void main(String args[])
        {
                Scanner bevitel = new Scanner(System.in);
                System.out.println("Szelekció");
 
		System.out.print("Szám: ");
		int szam = bevitel.nextInt();
 
		if(szam >0)
			System.out.println("Pozitív");
		else
			System.out.println("0 vagy negatív");
 
        }
}

A program bekér egy számot, majd megvizsgálja, hogy pozitív szám, nulla vagy negatív számot írt be a felhasználó. Bekéréshez a Scanner osztályt használtam.

Többágú szelekció else if szerkezettel.

Ha több feltételnek is meg kell feleljünk, akkor egy első if utasítás után else if utasításokat használunk. Általánosan:

if (feltétel_1)
    utasítás_1;
else if (feltétel_2)
    utasítás_2;
else
    utasítás_3;

Egy konkrét példához nézzük egy problémát. A fentebb volt egy feladatunk ahol azt vizsgáltuk, hogy egy szám pozitív vagy más. A program arra már nem volt képes, hogy azt is megvizsgálja, hogy ha nem pozitív, akkor 0 vagy negatív!?! Az „else if” szerkezet lehetőséget ad erre, mert újabb feltételt tudunk beilleszteni.

tobbagu.java

import java.util.Scanner;
class tobbagu
{
	public static void main(String args[])
	{
		Scanner olvaso = new Scanner(System.in);
 
		System.out.print("Szám: ");
		int szam = olvaso.nextInt();
 
		if(szam > 0)
			System.out.println("Pozitív szám");
		else if(szam == 0)
			System.out.println("Nulla");
		else
			System.out.println("Negatív szám");
	}
}

Ugyanaz csak a bekérés más osztályokkal (Kezdőknek akik nem használtak Scanner osztályt.).

tobbagu2.java

import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
class tobbagu2
{
	public static void main(String args[]) throws IOException
	{
		InputStreamReader folyam = new InputStreamReader(System.in);
		BufferedReader olvaso = new BufferedReader(folyam);
 
		System.out.print("Szám: ");
		int szam = Integer.parseInt(olvaso.readLine());
 
		if(szam > 0)
			System.out.println("Pozitív szám");
		else if(szam == 0)
			System.out.println("Nulla");
		else
			System.out.println("Negatív szám");
	}
}

A switch utasítás szintén többágú szelekcióra lett kitalálva.

switch (kifejezés)
{
    case érték1 : utasítások; break;
    case érték2 : utasítások; break;
    ...
    case értékn : utasítások; break;
    default : utasítások; 
}

Switch példa

sw.java

class sw
{
        public static void main(String args[])
        {
                System.out.println("Hi");
		int a = 7;
 
		switch(a)
		{
			case 1 : System.out.println("Egy"); break;
			case 2 : System.out.println("Kettő"); break;
			case 3 : System.out.println("Három"); break;
			case 4 : System.out.println("Négy"); break;
			default : System.out.println("Ismeretlen");
		}				
        }
}

A fenti program megvizsgálja, hogy az „a” változóban milyen szám van. Ha 1 akkor kiírja az „Egy” karaktersorozatot a képernyőre. Ha 2 akkor a „Kettő” karaktersorozatot, stb. Ha egyik sem – mint a példában is – akkor az „Ismeretlen” karaktersorozatot írja ki.

A vizsgált változót a switch utáni zárójelek közzé írjuk. A case után írjuk szóközzel tagolva a feltételezett értékeket. A default után jönnek azok az utasítások, amelyek akkor hajtódnak végre, ha egyik feltétel sem teljesült.

Vegyük észre minden kiírató utasítás után a break utasítást. Mit csinál a break utasítást? A brak utasítás megszakítja az utasítások végrehajtását és újból a switch részhez ugrik. Hogy jobban megértsük változtassuk kissé meg a példánkat. Tegyük az „a” változóba a 2-es értéket. A case 2 : végén lévő break utasítást pedig töröljük:

sw2.java

class sw2
{
        public static void main(String args[])
        {
		int a = 2;
 
		switch(a)
		{
			case 1 : System.out.println("Egy"); break;
			case 2 : System.out.println("Kettő");
			case 3 : System.out.println("Három"); break;
			case 4 : System.out.println("Négy"); break;
			default : System.out.println("Ismeretlen");
		}				
        }
}

Végrehajtás után az eredmény a következő:

Kettő
Három

A következő, azaz a case 3 : utáni utasítás is végrehajtódott. Ez éppen a berak utasítás hiány miatt történt. A szerkezetet pont ilyen esetekre hozták létre. Ha az „a” változó értéke „2” és szeretnénk ebben az esetben „Kettő” és „Három” karaktersorozatot is a képernyőre írni.

A switch utasítás a következő primitív típusokkal működik:

• byte
• short
• char
• int

Használható még a következő felsorolt típusokkal és a primitív típusok wrapper osztályaival Byte, Short, Char, Integer. A Java SE 7-es verziótól használható String osztállyal is.

Általánosan:

állítás ? érték_ha_igaz : érték_ha_hamis

A kifejezés visszaadja az első vagy második értéket, attól függően, hogy az állítás igaz, vagy hamis.

A kapott érték eltárolható egy változóban:

változó = állítás ? érték_ha_igaz : érték_ha_hamis

Program01.java

class Program01
{
	public static void main(String[] args)
	{
		int a = 3;
		String e = (a > 10) ? "Nagyobb" : "Kisebb";
		System.out.println(e);
	}
}

A program egyenértékű a következő if-es megoldással:

Program01.java

class Program01
{
	public static void main(String[] args)
	{
		int a = 35;
		String e = null;
		if (a > 10) 
			e = "Nagyobb";
		else
			e = "Kisebb";
 
		System.out.println(e);
	}
}

• Hányféle szelekciós utasítás van a Java nyelvben?
• Mi az a ternary operátor?
• Egy if szelekció törzs részének elejét és végét mivel jelöljük a Java nyelvben?
• Egy if szerkezetben a kapcsos zárójelek {} kötelezőek a Java nyelvben egy utasítás esetén?
• Egy if szerkezetben mire való az else?
• Az if szerkezetben kötelező az else ág használata?
• A swicth utasításban milyen típusú változókat vizsgálhatunk a Java nyelvben?

Az iteráció vagy ismétlés, amely ciklus néven ismert még.

Lesznek utasítások, amelyeket többször végre akarunk hajtani majd. Egyes esetekben tudni fogjuk hányszor, máskor pedig nem tudjuk hányszor, csak várunk valamilyen esemény bekövetkeztére. Az első eset a növekményes ciklus, a második pedig az „amíg” típusú ciklus.

A for utasítást jellemzően olyan ciklusoknál használjuk, ahol tudjuk meddig kell ismételni, azaz növekményes ciklusok esetén.

for ( kezdeti_érték ; feltétel ; növekmény)
    utasítás;

A for utasításnak három paramétere van. A három paramétert pontosvesszővel (;) választjuk el egymástól. A három paraméter a következő:

• kezdő érték
• feltétel (meddig menjünk)
• növekmény

Ha már számolnunk kell hányszor hajtunk végre az utasításokat, akkor kell egy változó ahol ezt tárolni fogjuk. Gyakran erre a célra az „i” változót használjuk. Az „i” változónevet egy programban csak ciklusváltozóként szoktuk használni. A Java fordító erre nem kötelez, de jó szokás. Ha az „i” foglalt, akkor a következő „j”. Ha ez is foglalt, akkor „k”. Ennél több eset ritka, de van még betű az ábécében.

A következő példában az „i” változót használjuk ciklusváltozónak:

for ( i = 1; i <= 10 ; i++)
    System.out.println("Város");

Az i változót persze valahol deklarálni kell. A Java nyelv megengedi, hogy ezt a ciklus fejrészében (a ciklus zárójelben lévő része) tegyük:

for ( int i = 1; i <= 10 ; i++)
    System.out.println("Város");

Hasonlóan az if szerkezethez, itt is írhatunk több utasítást is a ciklus törzsébe (egy utasítás esetén, maga ez az egy utasítás a törzs, több utasítás esetén a blokk nyitótól a blokk záróig tart.

for ( int i = 1; i <= 10 ; i++)
{
    System.out.println("Város");
    System.out.println("Cím");
}

A fenti példákban a ciklustörzsben lévő utasítás, illetve utasítások 10-szer hajtódnak végre. Ezt a következő fejrésszel értük el:

for ( int i = 1; i <= 10 ; i++)

Ugyanez elérhető így is:

for ( int i = 0; i < 10 ; i++)

Vegyük észre a különbséget. A kezdő érték az utóbbi esetben 0, és addig megy a ciklus amíg kisebb mint 10, tehát 9-ig.

A while ciklus alapvetően „amíg” típusú ciklusok használatára találták ki.

A while ciklus általánosan így épül fel:

while (feltétel)
    utasítás;

Egy konkrét példa

i = 1;
while (i <= 10)
{
    System.out.println("Város");
    i++;
}

A példában szereplő while ciklus ugyanazt csinálja mint a fentebbi programok legtöbbje. Itt is tudjuk meddig megyünk. A while utasítást úgy használtuk mint a for-t. Csak a kezdőértéket a ciklus előtt adtam meg, a növekményt meg a ciklus törzsében.

Ez persze még nem az „amíg” típusú ciklus. Az „amíg” típusú ciklusnál nem tudjuk meddig megyünk. Várunk egy eseményre. A példa kedvéért a felhasználótól számokat kérünk be összeadás céljából. Nem tudjuk mennyit, majd a felhasználó eldönti. Ekkor valahogy biztosítanunk kell, hogy a bevitel végét jelezze. Ha 0 értéket nem vihet be a felhasználó, akkor használhatjuk ezt végjelnek.

Vagyis kérjük be sorra a számokat, amikor a felhasználó 0 számot üt be, akkor nem kérünk több számot. A következő példában a Scanner osztállyal kérünk be számokat 0 végjelig:

vegjelig.java

import java.*;
import java.util.*;
 
class vegjelig
{
	public static void main(String[] argv)
	{
		Scanner bevitel = new Scanner(System.in);
 
		int szam=-1;
		while(szam != 0)
		{
			System.out.print("Kovetkezo szam: ");
			szam = bevitel.nextInt();
		}
	}
}

A példában persze a bekért számokkal még nem csinálunk semmit. Szeretnénk összeadni a bekért számokat:

osszeg.java

import java.*;
import java.util.*;
 
class osszeg
{
	public static void main(String[] argv)
	{
		Scanner bevitel = new Scanner(System.in);
 
		int szam=-1;
                int osszeg = 0;
		while(szam != 0)
		{
			System.out.print("Kovetkezo szam: ");
			szam = bevitel.nextInt();
                        osszeg = osszeg + szam;
		}
                System.out.printf("%d\n", osszeg);
	}
}

Gyakorlásképpen összeadás helyett szorozza össze a bekért számokat. Bekérés közben ne írja ki a részeredményeket. Csak a ciklus végén írja ki a szorzatot.

Az eddigi ciklusok úgynevezett elől tesztelő ciklusok voltak. Ez annyit tesz, hogy előbb megvizsgálták a feltételt, majd ha az igaz volt, végrehajtották a ciklustörzs utasításait. A most következő ciklus hátul tesztelő ciklus. A ciklus törzsében lévő utasítások egyszer mindenképpen végrehajtódnak, a feltétel csak ez után kerül vizsgálatra. Ha a feltétel igaz, akkor az ciklus törzsében lévő utasítások megint végrehajtódnak.

hatul.java

do
{
    utasítások;
}while(feltétel);

Vegyük észre, hogy ezt ciklust végén le kell zárni pontosvesszővel.

Konkrét példa a hátul tesztelésre:

hatul.java

import java.util.*;
class hatul
{
	public static void main(String args[])
	{
		Scanner bevitel = new Scanner(System.in);
		System.out.println("Hátul tesztelő ciklus");
 
		int szam;
		do
		{
			System.out.print("Szám: ");
			szam = bevitel.nextInt();
		}while(szam != 0);
	}
}

A for utasításnak van egy kiterjesztett változata, amely tömbök és kollekciók iterálására lett kitalálva. Angolosan enhanced for néven ismert. A következőben ennek a használatát látjuk.

Program01.java

class Program01
{
	public static void main(String args[])
	{
 
		String[] varos = {"Debrecen", "Nyíregyháza", "Zalaegreszeg", "Pécs", "Szeged"};
 
		for(String str : varos)
			System.out.println(str);
	}
}

A for() ciklus segítségével végtelen ciklust is előállíthatunk ha nem adunk meg paramétert:

for(;;){
   //ciklustörzs
}

• Mit jelent az iteráció?
• Hányféle iterációs utasítást ismert a Java nyelvben?
• A for ciklusban hány alakja van a Java nyelvben?
• Mi a különbség a do-while és while ciklus között?

A tömb azonos típusú értékeket tárolására alkalmas adatszerkezet. A tömböknek beszélünk a kiterjedéséről. Ha a kiterjedés csak egyirányú akkor vektorról beszélünk, ami hasonlít is a matematikában tanult vektorfogalomhoz. Ha a kiterjedés kétirányú akkor mátrixról beszélünk, szintén a matematikában használt mátrixhoz hasonlóan. A tömböknek lehet ennél több kiterjedése is, három, vagy akár több. De ezeket már ritkán szoktuk használni.

Egy tömb akkor vektor, ha egyirányú a kiterjedése. Például egész számokat szeretnénk eltárolni:

A példában öt darab egész számot szeretnénk tárolni.

A tömb egyes elemeivel szeretnénk valamit csinálni, így hivatkozni kell rájuk. Ezt úgy szoktuk megtenni, hogy minden értékhez egy indexet rendelünk. Az első érték indexe nulla, a következőé egy, aztán kettő, stb.

<elemi típus>[] <változó név>;

vagy

<elemi típus>  <változó név>[];

Konkrét példa:

int[] tomb;

vagy

int tomb[];

Kezdőérték adása

int[] tomb = {37, 23, 47, 52, 28};

De lehet így is:

int[] tomb = new int[] {37, 23, 47, 52, 28};

Más típussal:

long[] fizetesek = new long[] {10000, 20000, 30000, 40000};

int[] tomb =  {3, 4, 7, 8};

A Java tömböknek deklaráláskor nincs hely lefoglalva a memóriában. Ez a new kulcsszóval kell megtennünk. Pl.:

tomb.java

class tomb
{
	public static void main(String args[])
	{
		int[] tomb;
 
		tomb = new int[5];
 
		tomb[0]=37;
 
		System.out.println(tomb[0]);
	}
}

tomb2.java

class tomb2
{
	public static void main(String args[])
	{
		int[] tomb = new int[5];
 
		tomb[0]=37;
 
		System.out.println(tomb[0]);
	}
}

Tömb mérete

import java.lang.reflect.*;
...
System.out.println(Array.getLength(tomb));

System.out.println(tomb.length);

Tömb feltöltése:

Program.java

import java.util.*;
 
class Program
{
	public static void main(String[] argv)
	{
		int[] tomb = new int[10];
 
		Arrays.fill(tomb, 5);
 
		for(int i=0; i<tomb.length; i++)
			System.out.print(tomb[i] + " ");
		System.out.println();
 
	}
}

A példában 5-ös számokkal töltjük fel a tömböt.

Integer ars[][] = new Integer[4][3];  // Integer az int burkoló osztálya

int ars[][] = new int[][]{{1,3,3}, {2,4,6}, {3,4,7}, {5,6,7}};

Olyan mint egy 4 x 3 matrix

public class MultiDimensionalArrayExample 
{    
  public static void main(String[] args) 
  {
 
    int ars[][] = new int[][]{{1,2,3}, {2,4,6}, {3,4,7}, {5,6,7}};
 
    for(int i = 0; i < 4; i++) 
        for(int j = 0; j < 3; j++) 
            System.out.println(ars[i][j]);
  }
}