szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[:oktatas:programozás:java|< Java]]

====== A Java nyelv ======

  * **Szerző:** Sallai András
  * Copyright (c) 2009, Sallai András
  * Szerkesztve: 2009-2021
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC BY-SA 4.0]]
  * Web: https://szit.hu

===== Bevezetés =====

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.


^ Java forráskód ^ Java fordító ^ Java bájtkód ^ Java futtató ^ Gépi kód |
| Program.java | javac ^ Program.class | java | 1 és 0 sorozata |

Azonban vannak fordítók, amelyek
gépi kód létrehozására is alkalmasak.
^ Java forráskód ^ Java fordító ^ Gépi kód |
| Program.java | javac | Program.exe |


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

^  Java bájtkód  |
|  Java keretrendszer  |
|  Operációs rendszer  |
|  Hardver  |



===== Helló Világ =====

Készítse el a következő forráskódot a megadott néven, majd mentse, fordítsa és futtassa:
<code java Test.java>
class Test {
    public static void main(String[] args) {
        System.out.println("Java működik a gépeden");
    } 
}
</code>

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 program elemzése ====
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ódus**nak 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ó.

{{:oktatas:programozás:java:argumentumok.png?400|}}


{{:oktatas:programozás:java:osztalyleiras.png?400|}}


{{:oktatas:programozás:java:mainmetodus.png?400|}}




==== Fordítás ====
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. 



==== System osztály ====

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. 



==== Gyakorlás ====

  * 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 [[oktatas:programozas:feladatok:altalanos|á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.
{{:oktatas:programozas:java:prog01.png?400|}}

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

{{:oktatas:programozas:java:prog01_02.png?400|}}

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

{{:oktatas:programozas:java:prog01_03.png?400|}}

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

{{:oktatas:programozas:java:prog01_04.png?400|}}

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

{{:oktatas:programozas:java:prog01_05.png?400|}}

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

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

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

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

</code>

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

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

</code>

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

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

</code>

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

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

</code>


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

<code java 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");		
	}
}

</code>


===== Megjegyzések =====

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:

<code java>
// egy soros megjegyzés
</code>

Több soros megjegyzést a /* és */ karakterek közzé írhatunk:
<code java>
/* ez
   egy
   több
   soros
   megjegyzés */
</code>

==== Gyakorlat ====

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

{{:oktatas:programozas:java:prog01_megjegyzes01.png?400|}}

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

{{:oktatas:programozas:java:prog01_megjegyzes02.png?400|}}


===== Kivitel =====

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:
<code java>
System.out.println("Első");
System.out.println("Második");
</code>


Most írassuk ki a két szót print() metódussal.
<code java>
System.out.print("Első");
System.out.print("Második");
</code>


Nemcsak karaktersorozatokat írathatunk ki, lehet számok és más karakterek is:
<code java>
System.out.println("ElsőMásodik");
</code>


<code java>
System.out.println("1234");
</code>


<code java>
System.out.println("@!+=");
</code>

Ha számokat szeretnénk kiíratni, akkor azokat nem kötelező idézőjelek közzé tenni:
<code java>
System.out.println(1234);
</code>



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. 
<code java>
System.out.println(1234 * 2);
</code>


Esetleg összeadásokat végezhetünk vele:
<code java>
System.out.println(3 + 2);
</code>
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:
<code java>
System.out.println("3 + 2");
</code>

Kimenet:
  3 + 2

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

</code>


===== Különleges karakterek =====

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:
<code java>
\n
</code>
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é:
<code java>
\t
</code>
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: 
<code java Program.java>
class Program {
    public static void main(String[] args) {
        System.out.println("Helló\nVilág");
    }
}
</code>

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

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




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:
<code java>
\"
</code>

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

Az escape szekvenciák tehát egy-egy betű, amelyet ha alkalmazunk visszaperjellel
vezetjük be. Alkalmazhatjuk őket karakterek helyén is.
<code java>
char sortores = '\n';
</code>




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

^ Escape szekvencia ^ Leírás ^
| \uxxxx | Hexadecimális UNICODE karakter (xxxx) |
| \' | Felső vessző |
| \" | Idézőjel |
| <nowiki>\\</nowiki> | Visszaperjel |
| \r | Kocsi vissza (A kiírás a sor elején folytatódik) |
| \n | Új sor |
| \f | Lapdobás |
| \t | Tabulátor |
| \b | Visszatörlés (Előtte lévő karaktert törli) |


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. 

^  Karakter  ^  Kód  ^
|  ©  |  00a9  |
|  ¬  |  00ac  |

A példa kedvéért így íratjuk kia copyright karaktert:
<code java>
System.out.println("\u00a9");
</code>

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:

<code java>
char ch;
char idezojel;

ch = 'a';
idezojel = '\"';
</code>


W7 alatt fok:
  \u0159


===== Adattípusok =====

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ál**ni 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:
<code java>
int szam;
</code>

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:
<code java>
szam = 35;
</code>

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. 

==== Egész típusok ====


| byte  | 1 byte | -128 -- 127 |
| short | 2 bytes | -32 768 -- 32 767 |
| int   | 4 bytes | -2 147 483 648 -- 2 147 483 647 |
| long  | 8 bytes | -9 223 372 036 854 775 808 -- 9 223 372 036 854 775 807 |



Ha nagyobb értéket akarunk elhelyezni egy változóban, mint amire névlegesen megengedett:
<code java>
short a = 32768;
</code>

Fordításkor a következő hibaüzenetet kapjuk:
<code bash>
javac -cp Program.java 
Program.java:6: possible loss of precision
found   : int
required: short
		short a = 32768;
		          ^
1 error
>Exit code: 1
</code>



Az int típus esetén:
<code java>
integer number too large: 2147483648
		int c = 2147483648;
		        ^
</code>


==== Valós típusok ====

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ó:

| double | 8 bytes | 4.9e-324 -- 1.7976931348623157e+308 |
| float  | 4 bytes | 1.4e-45 -- 3.4028235e+38 |

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:
<code java>
double a = 3.4d;
</code>

<code java>
double a = 3.4f;
</code>


A double esetén elhagyható a szám végéről a "d" betűt:
<code java>
double a = 3.4;
</code>




==== Java karakterek ====

| char | 2 byte |

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:
<code java>
char ch; 
ch = 'a';
</code>


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:

<code java 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);
    }
}
</code>

==== Logikai típus ====


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

|  boolean  |  1 byte  |

Használata például:
<code java>
boolean van;
van = true;
</code>


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

==== A float típus ====

<code java>
float a = 3.87;
</code>
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.
<code java>  
float a = 3.87f;
</code>


==== A primitív típusok csomagolóosztályai ====

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

^ Primitív típus ^ Érték ^ Csomagoló osztály ^ Tartomány ^
| boolean | true, false | Boolean | true vagy false |
| char | 16 bit-es Unicode | Character | \u0000 -- \uFFFF |
| byte | 8 bit-es előjeles egész | Byte | -128 -- 127 |
| short | 16 bit-es előjeles egész | Short | -32768 -- 32767 |
| int | 32 bit-es előjeles egész | Integer | -2147483648 -- 2147483647 |
| long | 64 bit-es előjeles egész | Long | -9223372036854775808 -- 9223372036854775807 |
| float | 32 bit-es lebegőpontos | Float | 1.4E-45 -- 3.4028235E+38 |
| double | 64 bit-es lebegőpontos | Double | 439E-324 -- 1.7976931348623157E+308 |


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). 


==== Egyenlőség ====

A következő program true értéket ír a képernyőre, mivel a két változó értéke egyenlő:
<code java>
double a = 3.0;
double b = 3.0;
System.out.println(a == b);
</code>

Ha burkoló osztállyal hozom létre a változókat, az egyenlőség nem igaz:
<code java>
Double a = 3.0;
Double b = 3.0;
System.out.println(a == b);
</code>
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:
<code java>
Double a = 3.0;
Double b = 3.0;
System.out.println(a.equals(b));
</code>

==== Típusok mérete és határa ====
Maximum értékek kiíratása:
<code java>
System.out.println(Byte.MAX_VALUE);			
System.out.println(Short.MAX_VALUE);		
System.out.println(Integer.MAX_VALUE);		
System.out.println(Long.MAX_VALUE);
</code>

Minimum értékek kiíratása:
<code java>
System.out.println(Byte.MIN_VALUE);			
System.out.println(Short.MIN_VALUE);		
System.out.println(Integer.MIN_VALUE);		
System.out.println(Long.MIN_VALUE);
</code>

Hány biten tároljuk az adott típust:		
<code java>
System.out.println(Byte.SIZE);
System.out.println(Short.SIZE);
System.out.println(Integer.SIZE);
System.out.println(Long.SIZE);
</code>
A printf metódussal tizedestört formában is kiírhatók a lebegőpontos számok: 
<code java>
System.out.printf("%f\n\n", Double.MAX_VALUE);
</code>
Írjon programot, amelybe a fenti utasításokat helyettesíti be. 
Például:

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


==== Típusok konverziója szélesítéssel ====

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:
<code java>
byte a = 3;
short b = a;
</code>

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.

{{:oktatas:programozas:java:tipusok_konverzioja_szelesitessel.png|}}

==== Típusok konverziója szűkítéssel ====

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:
<code java>
short a = 3;
byte b  = (byte) a;
</code>

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:
<code java>
double a = 3;
int b = (int)a;
</code>
Az "a" változó értékét kasztoljuk int típussá. 







==== Literális ====

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
<code java>
int a = 3;
</code>
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:
<code java>
char ch = 'a';
</code>

Literális a következő is:
<code java>
String s = "szilva";
</code>


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. 

==== Gyakorlat ====

  * 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!
===== Java változók és állandók =====
==== A változók elnevezése ====

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

<code java>
double fizetes;
double _fizetes;
int fizetes;
int $fizetes;
long fizetes;
boolean kesz;
</code>

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:
<code java>
double fizetes = 70000;
</code>





==== A Java állandói ====



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:

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

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. 

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

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ő. 

==== Kérdések és gyakorlat ====

=== Kérdések ===

  * 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.


=== Gyakorlat ===
  - 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?
  - Az előző programban próbáljon meg mezőket úgy létrehozni, hogy nem ad kezdőértéket.














===== Értékadás =====

Értékadást egy darab <nowiki>(=)</nowiki> 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.

==== Számállandók a jobboldalon ====

<code java>
Float a = 3F;
</code>
vagy kisbetűvel:
<code java>
Float a = 3f;
</code>

Primitív típus egész számmal:
<code java>
float b = 3;
</code>

Valós számmal már szükséges az "f" vagy "F" jelző:
<code java>
float b = 3.0f;
</code>



<code java>
Double c = 3.;
</code>

<code java>
double d = 3;
</code>

Használhatjuk a "d" vagy "D" jelzőt:
<code java>
double d = 3.0d;
</code>


==== Változó a jobboldalon ====
<code java>
float a = b;
</code>

==== Kifejezés a jobboldalon ====
<code java>
float a = (b + c) * 3;
</code>

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: <del>(b + c) * 3 = a;</del>


==== Egész és valós számok ====

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

<code java>
double a = 1 / 2;
System.out.println(a);
</code>

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. 

<code java>
double a = 1 / 2.0;
System.out.println(a);
</code>

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ó:
<code java>
double a = 1 / 2.;
System.out.println(a);
</code>


Használhatjuk a számok után a f vagy a d jelzőt:
<code java>
double a = 1 / 2f;
System.out.println(a);

double b = 1 / 2d;
System.out.println(b);
</code>









==== Gyakorlat ====

  * 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 =====
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:
<code java>
System.out.printf("formátumkód", változó_állandó_vagy_kifejezés);
</code>

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.



==== Argumentum index ====

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:
<code java>
System.out.printf("%d %d\n", 3, 4);
</code>
Így a képernyőre a következő íródik:
<code shell>
3 4
</code>


Az argumentumindext használva a megfordításhoz:
<code java>
System.out.printf("%2$d %1$d\n", 3, 4);
</code>
A következő a kimenet:
<code shell>
4 3
</code>

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

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

<code java>
System.out.printf("%10d\n", 35);
</code>

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.


==== Pontosság ====
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:
<code java>
System.out.printf("%.2f\n", 35.1234567);
</code>


Egyszerre megadható az szám ábrázolásának szélessége és a tizedesjegyek száma is:
<code java>
System.out.printf("%10.2f\n", 35.1234567);
</code>


==== Ezredes elválasztó ====

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:

<code java>
System.out.printf("%,f\n", 32432344842.52334);
</code>


==== Több szám kiíratása ====

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


<code java 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);
	}
}
</code>

==== Változók indexel megadva ====


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


<code java 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);
	}
}
</code>

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. 



<code java 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);
	}
}
</code>

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

==== Jelzők ====
| + | előjel |
| <nowiki>-</nowiki> | balra igazítás (csak szélesség meghatározással, így van értelme) |
| 0 | vezető nullák megjelenítése |
| , | ezredes tagolás |
| # | alternatív formátum megjelenítése (csak o, x és X esetén) |
| ' ' | egy vezető szóköz pozitív számok számára (csak: 'd', 'o', 'x', és 'X' esetén) |
| '(' | negatív számok zárójelbe kerülnek (csak: 'e', 'E', 'f', 'g', és 'G esetén) |



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.





==== Konverziós karakter ====

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. 

^ Konverziós \\ karakter ^ Kategória ^ Leírás ^
| 'b', 'B' | elsődleges | Ha az argumentum null, akkor visszatérés "false". Az argumentum \\ boolden vagy Booldan, akkor a visszatérés String.valueOf(). \\ Ellenkező esetben a vissztérés "false". |
| 'h', 'H' | elsődleges | Ha az argumentum null, akkor a visszatérés is null. Egyébként a \\ visszatérés Integer.toHexString(arg.hashCode(). |
| 's', 'S' | elsődleges | Ha az argumentum null, akkor a visszatérés is null. Ha az argumentum \\ formázást valósít meg akkor a formázás érvényesül. \\ Minden más esetben az argumentumon karaktersorozattá alakul toString() |
| 'c', 'C' | karakter | Visszatér egy Unicode karakterrel |
| 'd' | átalakító | Visszatér egy formázott decimális egésszel. |
| 'o' | átalakító | Visszatér egy formázott oktális egésszel. |
| 'x', 'X' | átalakító | Visszatér egy formázott hexadecimális egésszel. |
| 'e', 'E' | lebegőpontos | Visszatér egy formázott decimális számmal \\ tudományos formában. |
| 'f' | lebegőpontos | Visszatér egy formázott decimális számmal. |
| 'g', 'G' | lebegőpontos | Visszatér egy formázott tudományos formával vagy decimális \\ formával, a kerekítés utáni érték pontosságától függően. |
| 'a', 'A' | lebegőpontos | Visszatér egy formázott hexadecimális lebegőpontos számmal, \\ alappal és a kitevővel. |
| 't', 'T' | idővel kapcsolatos | Dátum és konverziós karakterek előtagja. \\ Lásd a dátum és idő konverziót. |
| '%' | százalék | Visszaad egy '%' literálist '\u0025') |
| 'n' | sorelválasztó | Visszatér egy platformspecifikus sortöréssel. |


==== Példák ====
<code java>
double a = 2,7183;
System.out.printf("Szám: %+10.4f", a);
// " Szám =    +2,7183"

System.out.format("Hatvany: %.2f\n", b);
</code>

==== Idő kiíratás ====

Az óra, perc, másodperc kiíratása:
<code java>
System.out.printf("%tT\n", java.util.Calendar.getInstance());
</code>


Az év kiíratása:
<code java>
System.out.printf("%tY\n", java.util.Calendar.getInstance());
</code>

Az óra kiíratása:
<code java>
System.out.printf("%tH\n", java.util.Calendar.getInstance());
</code>



<code java Program.java>
import java.util.Calendar;

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

Még több példa:
<code java>
      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);
</code>

==== Sortörés ====

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:
<code java>
System.out.format("%f%n%n", 455.3823);
</code>

==== A Formatter osztály használata ====

<code java 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();
    }
}
</code>

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

==== DecimalFormat osztály ====

<code java 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));
	}
}
</code>

==== Console osztály használata ====

<code java Program.java>
import java.io.Console;

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

==== Gyakorlat ====

  * 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?
===== Math osztály =====

==== Használat ====

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.

<code java 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();
    }
}
</code>

==== Abszolút érték ====

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:
<code java>
double abs(double a)
float abs(float a)
int abs(int a)
long abs(long a)
</code>

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:
<code java>
double abs(double a)
</code>

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 ====


Hatvány számítása:

<code java>
double a = Math.pow(3, 2);
</code>

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

<code java>
double b = 1;
</code>



==== Gyökvonás ====

Adott szám gyökével tér vissza.
<code java>
System.out.println(Math.sqrt(9));
</code>

==== Trigonometria ====

<code java> 
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);
</code>

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. 


^  Függvények  ^
|  double sin(double a)  |
|  double tan(double a)  |
|  double cos(double a)  |
|  double asin(double a)  |
|  double acos(double a)  |
|  double atan(double a)  |
|  double atan2(double a)  |

==== Pi ====

<code java>
System.out.println(Math.PI);
</code>

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


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

<code java>
System.out.println(Math.E);
</code>

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

==== max ====

Két szám közzül a nagyobbat adja vissza:
<code java>
System.out.println(Math.max(7,4));
</code>

==== min ====

Két szám közül a kisebbet adja vissza:
<code java>
System.out.println(Math.min(7,4));
</code>

==== round ====
A round a tizedes törtet kerekíti. .4-től lefele, .5-től felfele:
<code java>
System.out.println(Math.round(1.5));
</code>

Eredménye: 2
<code java>
System.out.println(Math.round(1.4));
</code>
Eredménye: 1

==== ceil ====

A ceil függvény a tizedes törtet felfelé kerekíti.
<code java>
System.out.println(Math.ceil(1.0));
</code>
Eredménye: 1

<code java>
System.out.println(Math.ceil(1.1));
</code>
Eredménye: 2


==== floor ====

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

<code java>
double floor(double a)
</code>

Két példa:
<code java>
System.out.println(Math.floor(1.1));
</code>
Eredménye: 1

<code java>
System.out.println(Math.floor(1.9));
</code>
Eredménye: 1

==== toDegrees ====

Radiánfok átszámítása szögfokká.
<code java>
Math.toDegrees(85);
</code>
==== toRadians ====
Szögfok átszámítása radiánfokká. 
<code java>
Math.toRadians(85);
</code>


==== Exponenciális ====


Az exponenciális függvény e<sup>x</sup> 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
<code java>
double exp(double a)
</code>
==== Logaritmus ====


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

=== log(a) ===

<code java>
double log(double a)
</code>
A log() a szám természetes logaritmusát adja. A matematikában ln(x) a jelölése.


=== log10(a) ===

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


=== log1p(x) ===

<code java>
double log1p(double x)
</code>
A log1p a szám és 1 összegének logaritmusát adja. 

==== Gyakorlás ====
  * 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?


===== Véletlen szám generálás =====

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

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:

<code java>
import java.util.Random;
</code>

A Random osztály példányosítása veletlen objektum létrehozásával:
<code java>
Random veletlen = new Random();
</code>

A veletlen objektum használata:
<code java>
int szam = veletlen.nextInt(3);
</code>

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:
<code java>
Random veletlen = new Random();
int dobas = veletlen.nextInt(6) + 1;
</code>


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. 


^  Visszatérés típusa  ^  Hívás  ^  Leírás  ^
|  int i =  |  r.nextInt(int n)  |  int >= 0 és < n közötti véletlen számot ad vissza  |
|  int i =  |  r.nextInt()  |  a teljes int tartományból ad vissza véletlen számot  |
|  long l =  |  r.nextLong()  |  a teljes long tartományból ad vissza véletlen számot  |
|  float f =  |  r.nextFloat()  |  float >= 0.0 és < 1.0 közötti véletlen számot ad vissza  | 
|  double d =  |  r.nextDouble()  |  double >= 0.0 és < 1.0 közötti véletlen számot ad vissza  |
|  boolean b =  |  r.nextBoolean()  |  true vagy false értékkel tér vissza véletlenszerűen  |
|  double d =  |  r.nextGaussian()  |  0.0 és szabályos eltéréssel 1.0 közötti véletlen eltéréssel tér vissza  |


==== Math osztály ====



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



<code java>
double a = Math.random();
System.out.printf("%.20f\n", a);
</code>

A következő kimenetet adja:
<code>
0,509873801078128200000
</code>

Ha négyel szoroztam volna a számot:
<code java>
double a = Math.random();
System.out.printf("%.20f\n", a * 4);
</code>

Kimenet például:
<code>
2,03949520431251270000
</code>

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:
<code java>
double a = 4 * Math.random();
System.out.println(a);
</code>



Ha mindig hozzáadunk 1-t, akkor 1 és 4 közötti számot kapunk:
<code java>
double a = 4 * Math.random() + 1;
System.out.println(a);
</code>




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

<code java>
szam = (int) (10 * Math.random()) + 1;
</code>



==== Gyakorlat ====

  * 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?





===== Java operátorok =====

==== Operátorok ====

=== Értékadó operátor ===

| = | Egyszerű értékadás |


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

<code java>
<változó> = <kifejezés> 
</code>


Lássunk néhány konkrét példát a használatára:
<code java>
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
</code>

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

=== Aritmetikai operátorok ===

| + | összeadás (karaktersorozatok összefűzésére is használjuk |
| <nowiki>-</nowiki> | kivonás |
| * | szorzás |
| / | osztás |
| % | maradékképzés |

=== Egyoperandusú operátorok ===

| + | Unary plusz operator; az értéket adja |
| <nowiki>-</nowiki> | Unary mínusz operator; előjelet vált, vagyis az értéket negálja |
| ++ | inkrementáló operátor; az inkremens értéke: 1 |
| <nowiki>--</nowiki> | dekrementáló operátor; a dekremens értéke: 1 |
| ! | logikai ellentét; a logikai értéke ellentétes értékét adja |

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:
<code java>
System.out.println(true);
System.out.println(!true);

System.out.println(false);
System.out.println(!false);
</code>

=== Összehasonlító operátorok ===

| == | egyenlő |
| != | nem egyenlő |
| > | nagyobb mint |
| >= | nagyobb vagy egyenlő |
| < | kisebb mint |
| <nowiki> <= </nowiki> | kisebb vagy egyenlő |      Less than or equal to

Az egyenlő operátor visszaad egy true vagy false értéket, attól függően igaz-e amit állítunk. 
<code java>
int a = 4;
System.out.println(a == 3);
</code>


A következő program ugyanígy true vagy false értéket ír ki, de most az ellentétére kérdezünk:
<code java>
int a = 4;
System.out.println(a != 3);
</code>


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


=== Logikai operátorok ===


| && | feltételes ÉS |
| <nowiki>||</nowiki> | Feltételes VAGY |

=== Feltételes operátor ===

| ?: | Hármas operátor (az if-then-else rövid változata) |


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:
<code java>
int a = 4;
int b = 4;
System.out.println(a == 3 && b == 4);
</code>

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




=== Típusvizsgáló operátor ===


| instanceof |Egy objektumot egy megadott típushoz hasonlít |


=== Bitmozgató és bitenkénti operátorok ===


| ~ | komplemensképzés bitenként (unary; egyoperandusú) |
| <nowiki> << </nowiki> | előjeles balra mozgatás (shift) |
| <nowiki> >> </nowiki> | előjeles jobbra mozgatás (shift) |
| <nowiki> >>> </nowiki> | előjel nélküli jobbra mozgatás (shift) |
| & | bitenkénti ÉS |
| <nowiki> | </nowiki> | bitenkénti VAGY |
| <nowiki> ^ </nowiki> | bitenkénti Kizáró VAGY |

==== Precedencia ====

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:

| ++ <nowiki>--</nowiki> \\ ! ~ \\ instanceof | (pre- vagy poszt-) inkremens és dekremens, \\ logikai és bitenkénti negálás, \\ típus ellenőrzés |
| * / % | szorzás, osztás, moduló |
| + - | összeadás, kivonás |
| <nowiki><< >> >>></nowiki> | bitenkénti léptetések |
| <nowiki> < > >= <= </nowiki> | összehasonlítások |
| == != | egyenlő, nem egyenlő |
| & | bitenkénti AND |
| <nowiki>^</nowiki> | bitenkénti XOR |
| <nowiki>|</nowiki> | bitenkénti OR |
| && | logikai AND |
| <nowiki>||</nowiki> | logikai OR |
| ? : | feltételes kifejezés |
| <nowiki>= += -= *= /= %= ^=</nowiki> \\ <nowiki>&= |= <<= >>= >>>=</nowiki> | különböző értékadások |

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:
<code java>
int szam = 1 + 2 + 3;
System.out.println(szam);
</code>
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:
<code java>
int szam = 1 + 2 * 3;
System.out.println(szam);
</code>
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:
<code java>
int szam = (1 + 2) * 3;
System.out.println(szam);
</code>

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




==== Az inkrementáló és dekrementáló operátorok ====

Adott a következő Java programrészlet:
<code java>
int a = 3;
b = a++;
</code>

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:

<code java>
int a = 3;
b = ++a;
</code>
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. 



==== Bitműveletekre példa ====


<code java 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));
	}
}
</code>


<code java 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.
</code>


<code java 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));
	}
}
</code>

<code java 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));
	}
}
</code>



==== Feltételes értékadás ====

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.


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

==== Az instanceof operátor ====


<code java Program01.java>
class Program01 {
	public static void main(String[] args) {
		Integer a = 3;
		
		System.out.println(a instanceof Integer);
	}
}
</code>
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.




==== Művelettel kombinált értékadás ====

Legyen egy "a" változó, amelynek értékét szeretnénk 2-vel növelni. Ekkor ezt írnánk:
<code java>
int a = a + 2;
</code>

Ennek van egy rövidebb formája:
<code java>
int a += 2;
</code>

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:
  += -= *= /= %= &= ^= |= <<= >>=

==== Ternary ====

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.



==== Gyakorlat ====

  * 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 <nowiki> >> és a >>> </nowiki>operátor között?
===== Konvertálás =====

==== Sztring egész számmá ====

<code java>
System.out.println(Integer.parseInt("89"));
</code>


<code java>
String s = "25";
int a = Integer.valueOf(s).intValue();
</code>


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()



<code java>
String s = "87";
System.out.println(Integer.parseInt(s));
</code>


Szöveges formában tárolt valós számot alakítunk egésszé.
<code java>
int a = Float.valueOf( "799.87" ).intValue();
</code>


==== Sztring valós számmá ====

<code java>
System.out.println(Double.parseDouble("89.5"));
</code>

<code java>
Double d = Double.valueOf(str).doubleValue();
</code>

<code java>
Float f = Float.valueOf(str).floatValue();
</code>
==== Sztring hosszú egésszé ====

<code java>
  long l = Long.valueOf(str).longValue();

  Long l = Long.parseLong(str);
</code>

==== Egész sztringgé ====

<code java>
System.out.println(Integer.toString(77));
</code>

==== Valós sztringgé ====

<code java>
System.out.println(Float.toString(77.88));
</code>


==== Dupla sztringgé ====

<code java>
System.out.println(Double.toString(77.88));

double a = 3; 
System.out.println(Double.toString(a));
</code>

==== Hosszú egész sztringgé ====

<code java>
Long a = 7L;
String str = Long.toString(a);
</code>


==== Hexadecimális sztring egésszé ====

<code java>
int a = Integer.valueOf("B8DA3", 16).intValue();
</code>

<code java>
int a = Integer.parseInt("B8DA3", 16); 
</code>


A következő sor például a 11-et ír a képernyőre:
<code java>
System.out.println(Integer.parseInt("B", 16));
</code>

==== Karakter sztringgé ====

<code java>
String s = String.valueOf('c');
</code>

==== Karakter ASCII kóddá ====


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


vagy:

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

==== Egész (ASCII kód) karakterré ====


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



==== Sztring ASCII kóddá ====

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

==== Egész logikai típussá ====

<code java>
int a = 2;
boolean b = (a != 0);
</code>

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




==== Logikai típus egésszé ====


<code java>
boolean a = true;
int b = a ? 1 : 0;
</code>


A true és a false a következő módon alakul át:
  * true --> 1
  * false --> 0



==== Illegális karakterkonverzió vizsgálata try/catch mechanizmussal ====

<code java>
try {
    a = Integer.parseInt(str);
} catch(NumberFormatException e) {

}
</code>

==== Sztring bájt formára konvertálása ====

<code java>
String s = "some text here";
byte[] b = s.getBytes("UTF-8");
</code>
==== Bájt Sztring formára konvertálása ====
<code java>
byte[] b = {(byte) 99, (byte)97, (byte)116};
String s = new String(b, "US-ASCII");
</code>
Az US-ASCII helyett lehet "UTF-8" is


==== Valós egészé ====

<code java>
Double a = 3.8;
int b = Double.valueOf(a).intValue();
</code>

<code java>
Float a = 3.8f;		
int b = Float.valueOf(a).intValue();
</code>

<code java>
double a = 3.8;
int b = (int) a;
</code>



==== Egyéb lehetőség ====




=== Decimális binárissá ===

<code java 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();
    }
}
</code>


=== Decimális hexadecimálissá ===
<code java 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();
    }
}
</code>

==== Bináris string számmá ====

<code java>
String s = "1000100010000000";
int a = Integer.parseInt(s, 2);
</code>

==== Gyakorlat ====

  * 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á?


===== Bevitel a billentyűzetről =====

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.




==== Az util csomag használata ====

<note important>
A Netbeans és Maven együttes használata esetén a normál futtatás
hibásan működik. A bekérés szövege csak később jelenik meg.
Használjunk Maven helyett Ant-t.
</note>

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.


=== Egy egész szám bekérése ===

<code java 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);

     }
}
</code>


=== Egy valós szám bekérése ===

<code java 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);
     }
}
</code>


=== Egy karaktersorozat bekérése ===

<code java 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);
     }
}
</code>



=== Egész és valós bekérése ===

<code java 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);
	}
}
</code>

=== Két karakter sorozat bekérése ===

<code java 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);
	}
}
</code>

=== Karakter bekérése ===

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:


<code java 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);
	}
}
</code>

=== Ékezethelyes beolvasás ===

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:
<code java>
Scanner sc = new Scanner(System.in, "852");
</code>


Ha Windows ablakban fut a program, cp1250 bemenet beállítása:
<code java>
Scanner sc = new Scanner(System.in, "cp1250");
</code>


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. 

<code java>
System.out.println(System.getProperty("os.name"));
</code>


Az OS megállapítása:
<code java>
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");
}
</code>

==== Az io csomag használata ====

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.

<code java 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*/
</code>

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. 
<code java>
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*/
</code>





<code java 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);
	}
}
</code>

==== System.console() metódus ====

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. 

<code java 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);
	}
}
</code>

A bekéréssel együtt írhatunk is a képernyőre a bekérés előtt:
<code java 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));
	}
}
</code>

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


==== Console osztály ====

=== Karaktersorozat bekérése ===

<code java 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);		
	}
}
</code>

=== Egész szám bekérése ===

<code java 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);		
	}
}
</code>

==== Karakterek bekérése ====

<code java>
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);
</code>

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:

<code java 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);
	}
}
</code>





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

<code java>
ch = (char) System.console().reader().read(); //Java 6
</code>


A következő megoldás nem hagyja az Entert a billentyűzetpufferben. 
<code java>
ch = (char) new InputStreamReader(System.in).read();
</code>



<code java 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);
	}
}
</code>


Újabb példa:
<code java 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);
	}
}
</code>


==== Gyakorlat ====

  * 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á?




===== Szelekció =====

==== A szelekcióról ====
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.
==== 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:

<code java>
if (feltétel) utasítás;
</code>

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:

<code java>
if (feltétel) 
    utasítás;
</code>


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:


<code java>
if (feltétel)
{
    utasítás_1;
    utasítás_2;
    ...
    utasítás_n;
}
</code>

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. 
<code java>
if (feltétel)
    utasítás_1;
else
    utasítás_2;
</code>

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:

<code java>
  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;
  }
</code>

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

<code java 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");

        }
}
</code>


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.



==== else if ====

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:

<code java>
if (feltétel_1)
    utasítás_1;
else if (feltétel_2)
    utasítás_2;
else
    utasítás_3;
</code>


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. 

<code java 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");
	}
}
</code>


Ugyanaz csak a bekérés más osztályokkal (Kezdőknek akik nem használtak Scanner osztályt.).
<code java 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");
	}
}
</code>






==== switch ====

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

<code java>
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; 
}
</code>

  

Switch példa
<code java 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");
		}				
        }
}
</code>

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:

<code java 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");
		}				
        }
}
</code>

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.


==== Ternary operátor ====

Á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


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

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

<code java 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);
	}
}
</code>

==== Gyakorlat ====

  * 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?




===== Iteráció =====
==== Az iterációról ====

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. 


==== for ====

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. 

<code java>
for ( kezdeti_érték ; feltétel ; növekmény)
    utasítás;
</code>

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:

<code java>
for ( i = 1; i <= 10 ; i++)
    System.out.println("Város");
</code>
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:

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

</code>

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. 
<code java>
for ( int i = 1; i <= 10 ; i++)
{
    System.out.println("Város");
    System.out.println("Cím");
}
</code>

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:

<code java>
for ( int i = 1; i <= 10 ; i++)
</code>

Ugyanez elérhető így is:
<code java>
for ( int i = 0; i < 10 ; i++)
</code>

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. 







==== while ====
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:
<code java>
while (feltétel)
    utasítás;
</code>


Egy konkrét példa

<code java>
i = 1;
while (i <= 10)
{
    System.out.println("Város");
    i++;
}
</code>
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:

<code java 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();
		}
	}
}
</code>

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


<code java 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);
	}
}
</code>

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. 



==== do while ====

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.


<code java hatul.java>
do
{
    utasítások;
}while(feltétel);
</code>

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


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


<code java 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);
	}
}

</code>


==== for újra ====

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.

<code java 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);
	}
}
</code>

A for() ciklus segítségével végtelen ciklust is előállíthatunk ha nem adunk meg paramétert:
<code java>
for(;;){
   //ciklustörzs
}
</code>

==== Gyakorlat ====

  * 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?



===== Tömbök =====

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.


==== Vektorok ====

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

|  37  |  23  |  47  |  52  |  28  |

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. 


^  0  ^  1  ^  2  ^  3  ^  4  ^
|  37  |  23  |  47  |  52  |  28  |






<code java>
<elemi típus>[] <változó név>;
</code>
vagy
<code java>
<elemi típus>  <változó név>[];
</code>

Konkrét példa:
<code java>
int[] tomb;
</code>
vagy
<code java>
int tomb[];
</code>

Kezdőérték adása

<code java>
int[] tomb = {37, 23, 47, 52, 28};
</code>


De lehet így is:
<code java>
int[] tomb = new int[] {37, 23, 47, 52, 28};
</code>


Más típussal:

<code java>
long[] fizetesek = new long[] {10000, 20000, 30000, 40000};
</code>


<code java>
int[] tomb =  {3, 4, 7, 8};
</code>

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

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

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


{{:oktatas:programozás:java:tombegeszekbol.png|}}

Tömb mérete
<code java>
import java.lang.reflect.*;
...
System.out.println(Array.getLength(tomb));
</code>


<code java>
System.out.println(tomb.length);
</code>




Tömb feltöltése:
<code java 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();

	}
}
</code>

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



==== Java többdimenziós tömbök ====

| 1 | 3 | 3 |
| 2 | 4 | 6 |
| 3 | 4 | 7 |
| 5 | 6 | 7 |

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

<code java>
int ars[][] = new int[][]{{1,3,3}, {2,4,6}, {3,4,7}, {5,6,7}};
</code>

Olyan mint egy 4 x 3 matrix

<code java>
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]);
  }
}
</code>

<figure label>
{{:oktatas:programozas:java:valos_tomb.png?300|}}
<caption>Valós számokat tartalmazó tömb</caption>
</figure>






==== Tömb mérete ====
<code java>
int tomb[][] = new int[8][4];
System.out.println(tomb.length);           // 8-at ír ki
System.out.println(tomb[0].length);        // 4-et ír ki
</code>


==== Tömb átméretezése ====
A Java egyszerű tömbjeit nem arra találták ki, hogy később átméretezzük őket. Az átméretezés
azért megoldható:

<code java>
int ujHossz = 20;
int eredetiHossz = tomb.length;
Class componentType = tomb.getClass().getComponentType();
Object tomb2 = Array.newInstance(componentType, ujHossz);				
int vedettHossz = Math.min(eredetiHossz,ujHossz);
if (vedettHossz > 0)
	System.arraycopy(tomb, 0, tomb2, 0,  vedettHossz);		
tomb = (int[]) tomb2;
</code>

A komplett program működés közben:
<code java tombmeret.java>
class tombmeret
{

        private static Object resizeArray (Object oldArray, int newSize)
        {
                int oldSize = java.lang.reflect.Array.getLength(oldArray);
                Class elementType = oldArray.getClass().getComponentType();
                Object newArray = java.lang.reflect.Array.newInstance(
                                          elementType,newSize);
                int preserveLength = Math.min(oldSize,newSize);
                if (preserveLength > 0)
                        System.arraycopy (oldArray,0,newArray,0,preserveLength);
                return newArray;
        }

        public static void main(String[] args)
        {
                int[] tomb = new int[10];

                tomb[0] = 35;
                tomb[1] = 27;
                tomb[2] = 42;

                System.out.println(tomb.length);

                tomb = (int[]) resizeArray(tomb, 20);
                System.out.println(tomb.length);
        }
}
</code>

Látjuk, hogy az ilyen egyszerű tömbök nem méretezhetők át könnyen. Ha méretezhető tömböt 
szeretnénk, akkor használjuk az ArrayList vagy a Vector osztályt, az util 
csomagból. Ezek átméretezése automatikus. 


==== Tömb feltöltése ====

Az Arrays osztály arra való, hogy tömbökön végezzünk néhány műveletet.
Ez lehet annak feltöltése.
<code java>
int[] tomb = new int[10];
java.util.Arrays.fill(tomb, 0);
</code>

==== Tömb paraméterként kezdőértékkel ====

<code>
method(new Object[] { a, b, c});
</code>


==== Egyéb tömbök ====

=== ArrayList ===

Az java.util.ArrayList dinamikus tömböt valósít meg. 

A tömblisták (ArrayList) automatikusan átméreteződnek,
mérete mindig az elemek számától függ.
Az egyes elemeket mindössze fel kell venni vagy törölni. 
Egy ilyen változó (objektum) deklarálásánál meg kell adnunk milyen 
típusú elemet szeretnénk tárolni kisebb-mint és nagyobb-mint
jelek között. A következő példában például karaktersorozatot 
szeretnénk tárolni:


<code java>
ArrayList<String> tomb = new ArrayList<String>();
</code>

Vagy egészek tárolása
<code java>
ArrayList<Integer> tomb = new ArrayList<Integer>();
</code>




Lássuk az alábbi példában egy komplett programot:

<code java Program.java>

import java.util.*;

class Program
{
	public static void main(String[] argv)
	{		
		ArrayList<String> tomb = new ArrayList<String>();
		
		tomb.add("eper");
		tomb.add("málna");
		tomb.add("barack");
		
		System.out.println(tomb.get(2));
	}
}
</code>


Az ArrayList tartalmának kiíratása:
<code java>
ArrayList<String> lista = new ArrayList<>();
lista.add('János');
lista.add('Mihály');
lista.add('Imre');
System.out.println(lista);
</code>


=== Vector ===

Az ArrayList-et egyszálas programokhoz tervezték. A Vectort többszálas programokhoz.
A Vector nem ellenőrzi, ha a kollekciója megváltozik, ami hibákhoz vezethet. 

megváltozhat az iteráció során, viszont a változás nem
ellenőrzött. 

A vektor az ArrayList-hez hasonlóan használható. Meg kell adnunk mit szeretnénk benne tárolni.
A következőben lássunk egy komplett példát a használatára.


<code java Program2.java>
import java.util.*;

class Program2
{
	public static void main(String[] argv)
	{
		
		Vector<String> tomb = new Vector<String>();
		
		tomb.add("eper");
		tomb.add("málna");
		tomb.add("barack");
		
		System.out.println(tomb.get(2));
	}
}
</code>


Elem törlése
<code java>
tomb.remove(1);
</code>

Ha Object típust adok meg akkor különböző típusokat is eltehetek a verembe. 
<code java Program3.java>
import java.util.*;

class Program3
{
	public static void main(String[] argv)
	{
		
		Vector<Object> tomb = new Vector<Object>();
		
		tomb.add("eper");
		tomb.add(25);
		tomb.add("málna");
		tomb.add("barack");
		
		System.out.println(tomb.get(1));
	}
}

</code>


Egyéb metódusok használat közben:
<code java Program4.java>
import java.util.*;

class Program4
{
	public static void main(String[] argv)
	{
		
		Vector<Object> tomb = new Vector<Object>();
		
		tomb.add("eper");
		tomb.add(25);
		tomb.add("malna");
		tomb.add("barack");
		tomb.addElement("korte");
		
		System.out.println(tomb.get(1));
		
		System.out.println(tomb.size());
		System.out.println(tomb.remove(1));
		System.out.println(tomb.size());
		System.out.println(tomb.get(1));
		System.out.println(tomb.elementAt(2));
		System.out.println("Hol talalhato: " + tomb.indexOf("malna"));
		
		tomb.clear();
		System.out.println(tomb.size());
		
		tomb.addElement(new Integer(1)); 
		tomb.addElement(new Integer(2)); 
		System.out.println("Utolso: " + tomb.lastElement());
		System.out.println("Elso: " + tomb.firstElement());
		
		
		tomb.removeAllElements();
		tomb.addElement("Valami");
		tomb.addElement("Masik");	
		
		//Konverziók:		
		Object[] tomb2 = tomb.toArray();

		String[] tomb3  = new String[10];
		tomb3 = (String []) tomb.toArray(tomb3);
		//Itt gond, ha a vektor nem string típusú elemet tartalmaz
                //Olyankor Object típusba lehet konvertálni.
		
		Enumeration e = tomb.elements();
	}
}
</code>




Ha Vector és hasonló listák esetén, ha számot akarunk tárolni akkor nem 
használhatjuk a primitív típust, helyette a burkolóosztályt kell használnunk.
Ugyanakkor a for ciklusnak használhatjuk egy újabb változatát a lista kiíratására.

A következő példa ezt mutatja be:

<code java Program.java>
import java.util.Scanner;
import java.util.Vector;

class Program
{
	public static void main(String args[])
	{
		Vector<Integer> szamok = new Vector<Integer>();
	
		szamok.add(37);
		szamok.add(52);
		szamok.add(48);
		szamok.add(87);
		szamok.add(23);
		
		for(Integer szam : szamok)
			System.out.print(szam + " ");
		System.out.println();
	}
}
</code>

Vegyük észre az "Integer"-t az "int" helyett, a for ciklus 
fejrészében pedig "Integer szam : szamok". Utóbbi azt jelenti, hogy
veszem a szamok list minden elemét. Az elemeket a szam változóban kapom meg
minden ciklusban, ameddig a lista elemei el nem fogynak.




=== List ===

A List egy Interfész, ezért példányt nem lehet belőle létrehozni.
A konstruktorként az előző osztályok valamelyikét használhatjuk. 
A következő példában a Vector<> osztályt használjuk konstruktorként. 

<code java Program5.java>
import java.util.*;

class Program5
{
	public static void main(String[] argv)
	{		
		List<String> tomb = new Vector<String>();
		
		tomb.add("eper");
		tomb.add("málna");
		tomb.add("barack");		
		
		System.out.println(tomb.get(1));
	}
}
</code>

Használható <Object> típussal egyszerre több típus.

=== Set ===

A Set egy interface, nem osztály.
Ezért nincs is konstruktora. Helyette a TreeSet vagy HashSet osztályok konstruktorát 
használjuk. Egy halmazt határozhatunk meg vele, amelyen a szokásos halmazműveletek 
használhatók.


<code java Program6.java>
import java.util.*;

class Program6
{
	public static void main(String[] argv)
	{	
		//Set<String> halmaz = new TreeSet<String>();		
		Set<String> halmaz = new HashSet<String>();
		
		halmaz.add("eper");
		halmaz.add("málna");
		halmaz.add("barack");		
		
		System.out.println(halmaz.size());
		System.out.println(halmaz.contains("eper"));
		
		Iterator it = halmaz.iterator();
		while(it.hasNext())
		{
			Object elem = it.next();
		}
	}
}
</code>


=== Iterátor ===

<code java Program01.java>
import java.util.Iterator;
import java.util.Vector;

public class Program02
{
	public static void main(String args[])
	{
		Vector<String> v = new Vector<String>();
		v.add("alma");
		v.add("körte");
		v.add("barack");
		v.add("szilva");

		Iterator<String> i = v.iterator();
		while (i.hasNext())
		{
			System.out.println(i.next());
		}
	}
}
</code>


=== ArrayList kezdőérték ===

<code java Program01.java>
import java.util.ArrayList;
import java.util.Arrays;
class Program01
{
	public static void main(String args[])
	{
		Integer[] t = {45, 37, 29, 82, 34, 56};
		ArrayList<Integer> v = new ArrayList<Integer>(Arrays.asList(t));
		
		for(Integer a : v)
			System.out.println(a);		
	}
}
</code>

=== ArrayList listák összefűzése ===

<code java>
List<String> list = new ArrayList<String>();
list.addAll(list1);
list.addAll(list2);
</code>

==== Gyakorlat ====


  - Mondjon olyan típust vagy osztályt, amely azonos típusú elemek felvétele során automatikusan nő annak mérete.
  - Milyen osztállyal tudunk feltölteni egy tömböt?
  - Mi a vektor?
  - Mi a mátrix?
  - Hogyan deklarálunk egy mátrixot Java nyelven?




===== Különböző típusú adatok egy adatszerkezetben =====

A C nyelvben ezt struct, míg Pascal nyelvben ez a record. 
A Java nyelvben ezek egyike sem használható, helyette 
osztályt használhatunk a már meglévő osztályon belül.

<code java Program01.java>
import java.io.*;

class Program01
{
	public static void main(String args[]) throws IOException
	{

		class Dolgozo
		{
			int kor;
			double fizetes;						
		}				

		
		Dolgozo Joska  = new Dolgozo();
		Joska.kor = 23;
		Joska.fizetes = 370000;
				
		System.out.printf("%f\n", Joska.fizetes);
				
		System.out.println("Folytatáshoz nyomjon egy billentyűt");
		System.in.read();
	}
}
</code>

vagy

<code java Program01.java>
import java.io.*;

class Program01
{
	static class Dolgozo
	{
		int kor;
		double fizetes;						
	}
	public static void main(String args[]) throws IOException
	{
		Dolgozo Joska  = new Dolgozo();
		Joska.kor = 23;
		Joska.fizetes = 370000;
		
		System.out.printf("%f\n", Joska.fizetes);
		
		System.out.println("Folytatáshoz nyomjon egy billentyűt");
		System.in.read();
	}
}
</code>



==== Osztály tömbként ====

Sokszor előfordulhat, hogy több különböző adatot szeretnénk tárolni de nem csak egy dologról vagy személyről hanem többről.

Például szeretnénk dolgozók adatait tárolni:


<code java Osztalytomb.java>
import java.io.*;

class Osztalytomb {
        public static void main(String[] args) throws IOException {
                Dolgozo[] munkas = new Dolgozo[3];
                munkas[0] = new Dolgozo("Nagy Béla", 350000);
                munkas[1] = new Dolgozo("Kis János", 750000);
                munkas[2] = new Dolgozo("Rózsa Sándor", 380000);

                for (int i = 0; i < 3; i++)
                        munkas[i].print();
				
		System.in.read();
        }
}

class Dolgozo {
        private String nev;

        private double fizetes;

        public Dolgozo(String n, double s) {
                nev = n;
                fizetes = s;
        }

        public void print() {
                System.out.println(nev + "\t" + fizetes);
        }
}
</code>


Újabb példa:

<code java Program01.java>
class Program01 {
	static class Dolgozo
	{
		String nev;
		int kor;
		double fizetes;
	}	
	public static void main(String[] args) {
		Dolgozo[] munkas = new Dolgozo[3];
		
		for(int i=0; i<3;i++)
			munkas[i] = new Dolgozo();
		
		munkas[0].nev = "Nagy István";
		munkas[0].kor = 25;
		munkas[0].fizu = 285600.0;
		
		munkas[1].nev = "Kis Béla";
		munkas[1].kor = 32;
		munkas[1].fizu = "Kis Béla";

		munkas[2].nev = "Be Kornél";
		munkas[2].kor = 22;
		munkas[2].fizu = "Erős Lajos";
	}
}
</code>


Harmadik példa
<code java Program01.java>
/* Több tulajdonság tárolása listában  */
import java.util.ArrayList;

public class Program02 {
	public static void main(String[] a) {
		ArrayList<Dolgozok> dolgozok = new ArrayList<Dolgozok>();
		dolgozok.add(new Dolgozok("Nagy", "József"));
		dolgozok.add(new Dolgozok("Rezeg", "István"));
		dolgozok.add(new Dolgozok("Kékedi", "János"));

		System.out.println(dolgozok);

		Dolgozok d = dolgozok.get(1);
		d.beallitVezNev("Erős");

		System.out.println(dolgozok);
		
		Dolgozok d2 = dolgozok.get(1);
		System.out.println(d2.lekerVezNev());
	}
}

class Cim {
}

class Dolgozok {
	private String vezNev;

	private String kerNev;

	private Double fizetes;

	public Cim cim;

	public Dolgozok(String vezNev, String kerNev) {
		this.vezNev = vezNev;
		this.kerNev = kerNev;
		this.cim = new Cim();

	}

	public String lekerVezNev() {
		return this.vezNev;
	}

	public void beallitVezNev(String vezNev) {
		this.vezNev = vezNev;
	}

	public String lekerKerNev() {
		return this.kerNev;
	}

	public void beallitKerNev(String kerNev) {
		this.kerNev = kerNev;
	}

	public double lekerFizetes() {
		return this.fizetes;
	}

	public void beallitFizetes(double fizetes) {
		this.fizetes = fizetes;
	}
}
</code>

Egy példa automatikus feltöltéssel: 

<code java Program01.java>
class Szemely {
	private String nev;
	private int szuletesEve;
	Szemely(String nev, int szuletesEve) {
		this.nev = nev;
		this.szuletesEve = szuletesEve;
	}
	@Override
	public String toString() {
		return nev + ":" + szuletesEve;
	}
}

class Program01 {
	public static void main(String args[]) {
		Szemely[] szemelyek = new Szemely[5];
		for(int i=0;i<5;i++) {
			szemelyek[i] = new Szemely("Névtelen" + i, 0);
		}
		System.out.println(szemelyek[1].toString());
	}
}
</code>

{{:oktatas:programozás:java:tombszemelyosztalybol.png|}}


Ha HashSet osztályba szeretnénk például egy Dolgozo osztály példányait tárolni, néhány dolog nem fog működni alapértelmezetten.
Ha például felveszem kétszer ugyanazt az adatot, mindkét adat tárolásra kerül, pedig halmazról lévén szó ennek nem lenne szabad
bekövetkeznie. Ha egy HashSet objektumba, amely például Integer értékeket tartalmaz, a 22 értéket kétszer adom hozzá az add()
metódussal, az csak egyszer fog tárolódni. 

Visszatérve a Dolgozo osztályunkhoz, hasonló probléma lép fel, ha meg akarom vizsgálni, hogy egy adott dolgozó szerepel-e már a halmazban.
Ezt a contains() metódussal szoktuk vizsgálni. Ha a HashSet halmazunkban a Dolgozo osztály példányai vannak a contains() metódus mindig hamis értéket fogunk kapni, vagyis nem tudjuk megvizsgálni vele, hogy egy adott dolgozó szerepel-e egy halmazban.  

Természetesen a probléma megoldható, csak felül kell írnunk a hashCode() és a equals() metódust. A következő programban 
erre látunk példát:


<code java Program01.java>
import java.util.HashSet;

class Dolgozo {
	String nev;
	int kor;
	double fiz;
	Dolgozo(String nev, int kor, double fiz) {
		this.nev = nev;
		this.kor = kor;
		this.fiz = fiz;
	}
	
	@Override
	public boolean equals(Object o) {
		if(this == o) return true;
		Dolgozo dolgozo = (Dolgozo) o;
		if(!dolgozo.nev.equals(this.nev)) return false;
		if(dolgozo.kor!=(this.kor)) return false;
		if(dolgozo.fiz!=(this.fiz)) return false;
		return true;
	}	
	@Override
	public int hashCode() {
		int nevHash = this.nev.hashCode();
		int korHash = this.kor;
		int fizHash = (new Double(this.fiz)).hashCode();		
		int res = nevHash + korHash + fizHash;
		return res;
	}
}

class Program01 {
	public static void main(String args[]) {
		HashSet<Dolgozo> h = new HashSet<Dolgozo>();		
		h.add(new Dolgozo("Nagy József", 35, 350000));		
		h.add(new Dolgozo("Nagy József", 35, 350000));		
		
		System.out.println(h.contains(new Dolgozo("Nagy József", 35, 350000)));
		System.out.println(h.size());

	}
}
</code>

===== Enum típusok =====

Az enum típus egy speciális típus, amellyel a nevesített állandókhoz hasonló 
típusok jönnek létre. Egy ilyen típus több nevet tartalmaz. Értéket azonban nem adunk nekik, csak a nevükkel hivatkozunk rájuk. Használatával **olvashatóbb kódot** kapunk. 

<code java>
enum Egtaj {
	ESZAK, DEL, KELET, NYUGAT
}
</code>

<code java>
enum Os { 
	LINUX, WINDOWS, MACOSX
}
</code>


<code java Program.java>
class Program
{

	enum Nap {
		HETFO, KEDD, SZERDA, CSUTORTOK, 
		PENTEK, SZOMBAT, VASARNAP
	}	
	public static void main(String[] args)
	{
		Nap a = Nap.HETFO;
		System.out.println(a);
	}
}
</code>




==== Dolgozók státusza ====

Legyen egy példa, ahol dolgozók adatait tároljuk, köztük a dolgozó státuszát. A státusz lehet aktív, próbaidős, szabadságos, beteg, megszüntetés alatt.

A státuszok nyilvántartására készítünk egy enum típust:

<code java Status.java>
public enum Status {
    TRIAL,
    ACTIVE,
    HOLIDAY,
    SICK,
    TERMINATE
}
</code>

A dolgozók tárolásánál ezt használjuk:

<code java Employee.java>
public class Employee {
    int id;
    String name;
    String city;
    double salry;
    Status status;
}
</code>

Dolgozó státuszának beállítása:

<code java App.java>
public class App {
    public static void main(String[] args) throws Exception {
        handleEmp();
    }
    public static void handleEmp() {        
        Employee emp = new Employee();
        emp.status = Status.ACTIVE;

        System.out.println(emp.status);
    }
}
</code>

A lehetséges kimenet:
  ACTIVE


A dolgozók státuszát tárolhattuk volna String típusban is, de amikor értéket kell adni neki:
<code java>
emp.status = "active";
</code>
El kell gondolkodnunk, hogy most akkor mit kell pontosan írni? Acitve, active, aktív, ACTIVE, esetleg working vagy más?

Ha enum típust használunk a fordító vagy maga a fejlesztő eszköz szól, ha elírtuk.

==== Még több ====


További lehetséges enum típusok

Még több:
<code java>
enum Day {SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
	THURSDAY, FRIDAY, SATURDAY 
}
enum Nap {HETFO, KEDD, SZERDA, CSUTORTOK, PENTEK, SZOMBAT, VASARNAP} ;
enum MovieType {ACTION, HORROR, COMEDY};
enum Gender {MALE, FEMALE};
enum WeekDay { MON, TUE, WED, THU, FRI, SAT, SUN };
enum Grade { A, B, C, D, F, INCOMPLETE }; //Ertekeles
enum Tank { EMPTY, HALF, FULL };
//Penny =1 centes, Nickel=5 centes, Dime=10 centes, Quarter=25 centes ; Amerika
enum Currency {PENNY, NICKLE, DIME, QUARTER};
enum Color {WHITE, BLACK, RED, YELLOW, BLUE };
enum Planet {
    MERCURY, VENUS, EARTH, ARS,
    JUPITER, SATURN, URANUS, NEPTUNE};
    
//sugár km, tömeg kg.
enum Bolygo {
	MERKUR (2439.7, 3.302E+23),
	VENUSZ (6051.8, 4.8685E+24),
	FOLD (6378.137, 5.9736E+24),
	MARS (3402.5, 6.4185E+23),
	JUPITER (71492.0, 1.899E+27),
	SZATURNUSZ (60268, 5.6846e+26),
	URANUSZ (25559, 8.6832e+25),
	NEPTUNUSZ (24764, 1.0243e+26);
	private final double radius;
	private final double mass;
	Bolygo(double radius, double mass){
		this.radius = radius;
		this.mass = mass;
	}
	private double getRadius() { return radius;}
	private double getMass() { return mass;}
}
</code>


===== Karakterkezelés =====
==== ASCII ====

A char típus egy karakter tárolására való. Igaz a Java Unicode karaktereket
tárol, de az angol ábécé betűi az UTF-8 megvalósítás esetén
kompatibilisek az [[:oktatas:számítástechnika:ascii_tábla|ASCII]] kódtáblával.

Ha tudjuk, hogy az ASCII kódtáblában a nagy "A" és a kis "a" közötti
különbség 32, akkor egyszerűen alakíthatjuk a nagybetűs karaktereket
kisbetűssé és fordítva:

<code java>
class ascii
{
    public static void main(String args[])
    {
        char ch = 'A';      
        System.out.printf("%c\n", ch + 32);
    }
}
</code>

A példában a nagy "A" karaktert kis "a" karakterré alakítjuk.


Rendelkezésre állnak a Character osztály metódusai is:

Kisbetűssé alakítása
<code java>
char ch = Character.toLowerCase('A');
</code>

Szám, karakterként kezelése továbbiakban:
<code java>
int a = 65;
char ch = (char) a;
</code>

A Character osztály további metódusai:
| boolean  isDigit(char ch)  |
| boolean  isLetter(char ch)  | 
| boolean  isLetterOrDigit(char ch)  |
| boolean  isWhitespace(char ch)  |
| boolean  isLowerCase(char ch)  |
| boolean  isUpperCase(char ch)  |
| String  toString()  |
| String  toString(char c)  |
| char  toUpperCase(char ch)  |


<code java Program01.java>
class Program01 {
    public static void main(String args[]) {
        System.out.println(Character.toChars(97)); // a
        System.out.println(Character.toChars(369)); // ű
        System.out.println((char)97); // a
        System.out.println((char)369); // ű
    }
}
</code>

==== ASCII kód ====

A következő programban szeretnénk az "a" karakter ASCII kódját megkapni:

<code java Program01.java>
class Program01 {
    public static void main(String args[]) {
        char ch = 'a';      
        System.out.printf("%d\n", (int) ch);
    }
}
</code>

Itt pedig van egy ASCII kódunk és szeretnénk kiíratni a hozzátartozó karaktert:

<code java Program01.java>
class Program01 {
    public static void main(String args[])  {
        int a = 65;
        System.out.printf("%c\n", a);
    }
}
</code>

Az "a" karaktert tárolhatjuk eleve **int típusban**:

<code java Program01.java>
class Program01
{
    public static void main(String args[])
    {
        int a = 'a';
        System.out.printf("%d\n", a);       
    }
}
</code>


Kódpontok kiíratása:

<code java Program01.java>
class Program01 {
    public static void main(String args[]) {        
        System.out.println(Character.codePointAt("a", 0)); // 97
        System.out.println(Character.codePointAt("é", 0)); // 233
        System.out.println(Character.codePointAt("ű", 0)); // 369
    }
}
</code>
==== Összehasonlítás, egyenlőség vizsgálat ====

Összehasonlításhoz használhatjuk a "==" az egyenlőségjeleket vagy ha burkolóosztályt használtunk, akkor equals() függvényt is.

<code java Program01.java>
class Program01 {
    public static void main(String args[]) {
        Character ch = 'a';
        char ch2 = 'b';
        
        System.out.println(ch.equals('a')); // true
        System.out.println(ch == 'a');  // true
        System.out.println(ch2 == 'b');  // true
    }
}
</code>


<code java Program01.java>
class Program01 {
    public static void main(String args[]) {
        char ch1 = 'a';
        char ch2 = 'a';
        char ch3 = 'c';
        
        System.out.println(Character.compare(ch1, ch2)); // 0               
        System.out.println(Character.compare(ch1, ch3)); // -2
        System.out.println(Character.compare(ch3, ch1)); // 2       
    }
}
</code>


==== Karakter bekérés példa1 ====

A Scanner osztállyal közvetlenül nem kérhető be karakter. De bekérhetünk egy sztringet, 
aminek vesszük az első karakterét.

<code java App.java>
import java.util.*;

class App {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);        

        System.out.print("Karakter: ");
        String str = sc.next();
        
        char ch = str.charAt(0);
        
        System.out.println(ch);
        sc.close();
    }
}
</code>

A next() metódus helyett használható a nextLine() metódus is.

==== Példa 2 ====


<code java App.java>
import java.io.*;

class App {
    public static void main(String args[]) throws IOException {        
        System.out.print("Karakter: ");
        char ch = (char) System.in.read();
        System.out.println(ch);
    }
}
</code>

==== Példa 3 ====

<code java Pel.java>
import java.io.*;

class Pel {
    public static void main(String args[]) throws IOException {
        InputStreamReader folyam = new InputStreamReader(System.in);
        BufferedReader olvaso = new BufferedReader(folyam);
        
        System.out.print("Karakter: ");
                
        String str = olvaso.readLine();
        char ch = str.charAt(0);
        
        System.out.println(ch);             
    }
}
</code>

==== Sztring és karakter hasonlítása ====

<code java Program01.java>
class Program01 {
    public static void main(String args[]) {
        if(Character.toString('a').equals("a"))
            System.out.println("Egyenlő");
        else
            System.out.println("Nem egyenlő");
    }
}
</code>

==== Karaktertömb sztringgé ====

<code java Program01.java>
class Program01 {
    public static void main(String args[]) {
        //char tömb sztringgé 1:
        char[] t = {'a', 'b', 'c'};
        String s = new String(t);
        System.out.println(s);
        
        //char tömb sztringgé 2:
        String s2 = String.copyValueOf(t);
        System.out.println(s2);
    }
}

</code>

===== Sztring kezelés =====

==== String osztály ====


Stringeket a String osztállyal hozhatunk létre. Nincs string primitív típus. 

<code java>
String s;
s = "alma";
</code>

A Java nyelvben a sztringváltozónak értékadással is adhatunk értéket. 
A String osztály statikus, vagyis használható példányosítás nélkül. 

A legnagyobb beírható string hossza: 65534

<code java>
import java.io.*;
class Szoveg {
    public static void main(String args[]) throws IOException {
        String s;           
        s = "alma";
        System.out.println(s.length()); 
        System.in.read();
    }
}
</code>


Egyenlőség vizsgálat

<code java>
String gyumolcs = "körte";
if (gyumolcs.equals("alma"))
    System.out.println("A gyümölcs alma");
</code>

==== String osztály metódusai ====

=== length() ===

A karaktersorozat hosszát adja vissza.

<code>
int hossz = s.length();
</code>


=== concat() ===

Karaktersorozatok összefűzésére való. 

<code java>
String s = "egyik";
s.concat(" másik");
</code>

Az s változót kiíratva ezek után ezt kapjuk:
<code>
egyik másik
</code>

=== replace() ===

Egy karaktersorozatban egy adott karaktersor cseréje egy másikra. 

Általános szintaxis:
<code java>
replace(mitCserél, mireCserél)
</code>

Egy konkrét példa:
<code java>
String s = new String("Nagy kő esett le a szívemről tegnap");
System.out.print(s.replace("szívemről", "egy kocsiról"));
</code>




=== replaceAll() ===

Egy karaktersorozatban a megtalált mintát minden helyen kicseréli.

<code java>
str.replaceAll("\\s+", "\t"); //Szóközök tabulátorra cserélése
</code>



=== toLowerCase() ===
Kisbetűssé alakít minden karaktert.

<code java>
toLowerCase()
</code>

<code java>
String str = "SziLVa";
String kisbetus = str.toLowerCase();
</code>


 
=== toUpperCase() ===

Nagybetűssé alakít minden karaktert.

<code java>
toUpperCase()
</code>


<code java>
String str = "SziLVa";
String nagybetus = str.toUpperCase();
</code>


===  trim() ===
A trim() a szöveg elejéről és a végéről eltávolítja a whitespace karaktereket.

<code java>
String s = "   alma   ";
System.out.println(s.trim());
</code>



=== split() ===
A karaktersorozatot feldarabolja a megadott szeparátor alapján.

<code java>
str.split("\\s+"); //Egy vagy több szóköz
</code>

Szeparátorként megadható szabályos kifejezés.
A split() függvény egy String[] típus ad vissza.


=== isEmpty() ===

Megvizsgáljuk, hogy a karaktersorozat-változó üres-e.

Példa:
<code java>
boolean ures = str.isEmpty();
</code>


=== További példák ===

<code java>
class Str {
    public static void main(String args[]) {
        System.out.println("Szövegkezelés Java nyelven");

        String szoveg = "alma";
                
        System.out.println(szoveg.equals("almaa")); // true értéket ad, ha egyezik, vagy false
        System.out.println(szoveg.compareTo("alma")); // 0-át kapunk, ha egyezik
        System.out.println(szoveg.indexOf("alma")); // -1 ha nem található; 
        // Ha szoveg változóban van ilyen annak a kezdő indexét kapjuk meg
        // Esetünkben 0
                
        //Szöveg darabolása
        String sor ="alma:körte:barack:szilva";
        String[] tomb = sor.split(":");
        System.out.println(tomb[1]);

        String mondat = "Ha megint ezért üzen";
        System.out.println(mondat.substring(4)); //Kezdő indextől szeretném a karaktereket
        System.out.println(mondat.substring(4, 6));  //Kezdő index és vég index közötti karakterek
    }
}
</code>


==== char[] és String ====

A Sztring típusú objektum egy karakterére nem hivatkozhatunk a Java nyelven
szögletes zárójelekkel, mint egy tömbnél.
Sztring esetén a charAt() metódust használhatjuk.

Karakter tömb esetén a hivatkozás:
<code java>
char[] tomb = {'a', 'b', 'c'};
System.out.println(tomb[1]);
</code>

Sztring esetén csak így:
<code java>
String tomb = "abc";
System.out.println(tomb.charAt(1));
</code>


Esetleg, használjunk String() konstruktort:
<code java>
char[] adat = {'a', 'b', 'c'};
String adat2 = new String(adat);
System.out.println(adat2.charAt(1));
</code>


==== Pufferelt sztringek ====


A string osztállyal létrehozott változó valójában nem változtatható meg. 
Ha ilyen műveletet végzünk a háttérben valójában egy új példány jön létre. 

<code java>
String str = "szilva";
str = "barack";
</code>

A fenti példa második sorában a egy új str objektum jön létre a memóriában.



=== StringBuilder ===

Ugyanaz mint a StringBuffer, de a Stringek nincsenek szinkronizálva. Ezért használatát 
egy szálas programokhoz találták ki. 

<code java>
StringBuilder defString = new StringBuilder();  // 16 karakter méret beállítása
StringBuilder nulString = new StringBuilder(6); // pontos méret megadása
StringBuilder aString = new StringBuilder("kezdőérték"); // kezdőérték megadása
</code>

Hozzátartozó metódusok: 
  capacity(), length(), charAt(i), indexOf(g), lastIndexOf(g)

Módosító metódusok: 
  append(g), delete(i1, i2), insert(iPosn, g), getChars(i), setCharAt(iposn, c), 
  substring(), replace(i1,i2,gvalue), reverse(), trimToSize(g ), toString(g)


Összehasonlítás String típussal:
<code>
if(strb.toString().equals("hasonlítószöveg"))
    //Mit tegyünk
</code>


=== StringBuffer ===



<code java>
StringBuffer s;
</code>

A StringBuffer osztállyal olyan sztringeket hozhatunk létre, amit meg is tudunk változtatni. 



<code java>
StringBuffer defString = new StringBuffer(); // 16 karakter méret beállítása
StringBuffer nulString = new StringBuffer(6); // pontos méret megadása
StringBuffer aString = new StringBuffer("kezdőérték"); // kezdőérték megadása
</code>

Hozzátartozó metódusok: 
  capacity(), charAt(i), length(), substring(iStart [,iEndIndex)])

Módosító metódusok: 
  append(g), delete(i1, i2), deleteCharAt(i), ensureCapacity(), 
  getChars(srcBeg, srcEnd, target[], targetBeg), insert(iPosn, g), 
  replace(i1,i2,gvalue), reverse(), setCharAt(iposn, c), 
  setLength(),toString(g)





==== Sztring formázás ====
Az alábbi sorok a Calander típusú objektum tartalmát teszik olvashatóvá:
<code java>
java.util.Calendar c = java.util.Calendar.getInstance();
String s = String.format("Születésnap: %1$tY-%1$tm-%1$te", c);
</code>

Valós szám kiíratása:
<code java>
double a = 3.7;
System.out.println(String.format("%.2f\n", a));
</code>







==== Összefűzés ====

<code java>
String s1 = "Egyik";
String s2 = s1 + "Másik";
</code>

==== Sztring hossza ====
<code java>
int hossz = s2.length();
</code>

==== Számok sztringgé ====

<code java>
int szam1 = 4;
double szam2 = 3.5;
  
String szamegy = String.valueOf(szam1);
String szamketto = String.valueOf(szam2);
</code>

==== Sztringek számmá ====
<code java>
String s1 = "3.5";
String s2 = "34";

double szam1;
int szam2;

szam1 = Double.valueOf(s1).doubleValue();
szam2 = Integer.alueOf(s2).intValue();
</code>

==== Összehasonlítás ====

<code java>
String gyumolcs = "alma";
if (gyumolcs.equals("körte"))
    System.out.println("A gyümölcs: körte");
</code>


Lexikográfiai összehasonlítás. 0-át kapunk ha azonos, 0-nál kisebb értéket ha 
a második kisebb (lexikográfialilag), illetve 0-nál nagyobb értéket ha
nagyobb. 

<code java>
String abc = "abc";
Stirng def = "xyz";

if (abc.compareTo(def) < 0)   // 'a' kisebb mint 'x'
if (abc.compareTo(abc) == 0)  // ez is igaz
</code>


==== Egy adott karakter első előfordulása ====
<code java>
String s = "Finomabb";
int kezdet;
kezdet = s.indexOf('b')
</code>


==== Egy adott sztring első előfordulása ====
<code java>
String s = "Finomabb";
int kezdet;
kezdet = s.indexOf("nom")
</code>



==== Rész sztring ====

<code java>
String s = "Finomabb";
String resz;
resz = s.substring(2,4);
</code>

Az első paraméter a kezdet, a második a vég.





==== Sztring karaktertömbbé ====

<code java>
String s = "barack";
char[] t = s.toCharArray();
System.out.println(t[0]);
</code>

Iterálással:
<code java Program01.java>
class Program01 {
	public static void main(String[] args) {
		String str = "almakörte";
		
		char[] ca = str.toCharArray();
		
		for(char ch : ca) {
			System.out.println(ch);
		}
	}
}
</code>

==== Sztring darabolása ====

<code java>
String s = "barack:körte:alma";
String[] ts = s.split(":");
System.out.println(ts[1]);
</code>


A "|" szeparátorral nem működik. A Szeparátor lehet reguláris kifejezés is.

==== Gyakorlás ====

  * Milyen osztályokkal deklarálhatunk karaktersorozatot tárolni képes változót, illetve objektumot?
  * Hogyan kérdezhetjük le egy karaktersorozat hosszát?
  * Hivatkozhatok-e egy karaktersorozat adott elemére a szögletes zárójelekkel, a tömbökhöz hasonlóan?
  * Hogyan tudom egy szöveg egy részét venni?
  * Hogyan tudom megvizsgálni, hogy egy karaktersorozat egyenlő-e egy másik karaktersorozattal?




===== Kivételkezelés =====

==== A kivételkezelésről ====


A kivételkezelést a program futtatása során fellépő abnormális állapotok kezelésére találták ki. 
Abnormális állapot esetén a programok kivételt dobnak. Például, egy nemlétező állományra
hivatkozunk, vagy írni akarunk állományba, de nincs hozzá jogunk. Esetleg nullával próbáltunk
meg osztani. 

Ha egy program dobott egy kivétel, mi két dolgot tehetünk. Eldobjuk vagy kezeljük. 
Az eldobás a throws utasítással lehetséges. Az elkapás a try-catch utasítás párral. 



==== Osztás nullával ====

<code java>
import java.io.*;
import java.util.*;
class program
{
	public static void main(String args[]) throws IOException
	{
		Scanner be =new Scanner(System.in);
		double c=0;		
		
		int a = be.nextInt();
		try {
				c =  50 / a;
		} catch (Exception e) {
 			if (e instanceof ArithmeticException)
				System.out.println("Osztás nullával");
		}
		System.out.printf("%f\n", c);

		System.out.println("Folytatáshoz nyomj egy billentyűt!");
		System.in.read();
	}
}

</code>


<code java Program01.java>

try{

   //utasítások

}catch(IOException e) {
    System.err.println("Kivétel törént - Hogy miért? Lásd itt: ");
    e.printStackTrace();
    System.exit(-1);
}
</code>

A kivétel eldobása:
<code java Program01.java>
import java.io.IOException;

class Program01
{
	public static void main(String[] args) throws IOException
	{
		System.out.println("Folytatáshoz nyomjon Entert");
		
		System.in.read();
	}
}

</code>

==== Osztás 0-val lebegőpontos számokkal ====

Ha lebegőpontos számokkal dolgozunk és 0-val osztunk, akkor az nem hiba.
Ez csak egész számok esetén hiba. Valós számok esetén az eredmény végtelen. 

<code java Program01.java>
class Program01 {
	public static void main(String[] args) {
		double a = 1/0.;
		if(a == Double.POSITIVE_INFINITY) {			          
			System.out.println("Végtelen");
		} else {
			System.out.println("Valami más");
		}
	}
}
</code>

==== Néhány kivétel ====


  * ArithmeticException - Például osztás nullával
  * InputMismatchException - java.util.Scanner osztállyal pl. számot várunk szöveget kapunk


==== Gyakorlat ====

  * Mikor használjuk a kivételkezelést?
  * Milyen utasítással alkalmazzuk a Java nyelvben a kivételkezelést?




===== Fájl műveletek =====

==== Műveletek fájlokkal ====

Fájl létezésének ellenőrzése:
<code java>
import java.io.*;

public class ap
{
    public static void main(String[] args)
    {
         File f = new File("adat.txt");
         System.out.println(f.exists());
    }
}
</code>

További metódusok:
  * exists() -- Ha a fájl létezik true, ha nem false
  * getName() -- A fájl neve String-ként
  * length() -- A fájl mérete long-ként
  * createNewFile() -- Azonos nevű fájl létrehozása, ha még nem létezik
  * delete() -- A fájl törlése, ha létezik
  * renameTo(Fájl) -- A fájl átnevezése a paraméterben megadott File objektumot használva.

A fájl objektum könyvtárakat is jelölhet. 

Ha egy File objektum könyvtárat jelöl akkor hívható a következő metódus:
  * listFiles()


==== Olvasás fájlból ====


=== Egyszerűen ===

<code java Program2.java>
import java.io.*;

class Program2 {
	public static void main(String args[]) throws IOException {
		
		FileReader olvaso = new FileReader("adat.txt");
		
		StringBuilder strb = new StringBuilder();
		
		char ch;
		while(olvaso.ready()) {
			ch = (char)olvaso.read();
			strb.append(ch);
		}
		olvaso.close();
		
		System.out.println(strb);
	}
}
</code>


=== BufferedReader használata ===


<code java>
import java.io.*;
class readfile
{
    public static void main(String[] argv) throws IOException
    {

	FileReader folyam = new FileReader("adat.txt");
	BufferedReader fileolvaso = new BufferedReader(folyam); 
			
	String sor;
			
	while ((sor = fileolvaso.readLine()) != null)
	{
		System.out.println(sor);
	}
			
	fileolvaso.close();
			
	}
}

</code>



=== Három osztály használata ===

<code java>
import java.io.*;

public class ap {
    public static void main(String[] args) throws IOException {
      File f = new File("adat.txt");
      FileReader fr = new FileReader(f);
      BufferedReader bemenet = new BufferedReader(fr);

      boolean vege = false;
      String s;

      while(!vege) {
          s = bemenet.readLine();
          if (s != null) 
              System.out.println(s);
          else
              vege = true;
      }
      bemenet.close();
    }
}
</code>

=== Olvasás Scanner osztállyal ===

<code java>
import java.io.*;
import java.util.*;
class readfile2
{
    public static void main(String[] argv) throws IOException
    {

	Scanner olvaso = new Scanner(new FileReader("adat.txt"));

	while(olvaso.hasNextLine())
	{
		System.out.println(olvaso.nextLine());
	}
    }
}

</code>


=== Újabb példa ===


<code java>

import java.io.*;
class readfile
{
        public static void main(String[] argv) throws IOException
	{

		FileReader folyam = new FileReader("adat.txt");
		BufferedReader fileolvaso = new BufferedReader(folyam); 
			
		String sor = null;
			
		do
		{
			sor = fileolvaso.readLine();
			System.out.println(sor);
		}while (sor != null);
			
		fileolvaso.close();
			
	}
}
</code>


=== A File és a Scanner osztály használata ===

<code java Program01.java>
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
class Program01
{
	public static void main(String[] args) throws FileNotFoundException
	{
		File f = new File("adat.txt");
		Scanner bef = new Scanner(f);
		
		while(bef.hasNextLine())
		{
			System.out.println(Integer.parseInt(bef.nextLine()));
		}
	}
}

</code>


=== Fájl olvasása kivételkezelésével ===

A kivételek kezelését sokan a úgy oldják meg, hogy 
a fájlkezelő utasításokat egy try..catch szerkezetbe ágyazzák. 
Például így:

<code java Program01.java>
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

class Program01 {
	public static void main(String[] args) {
		File f = new File("adat.txt");
		try {
			Scanner fin = new Scanner(f);
		
			while(fin.hasNextLine()) {
				System.out.println(Integer.parseInt(fin.nextLine()));
			}
		} catch (FileNotFoundException ex) {
			ex.printStackTrace();
		}
	}
}
</code>

A kivétel elkapásának persze akkor van értelme, ha magunk akarunk
valamilyen szöveges üzenetet megjeleníteni. Ekkor a szöveges
üzenet a catch() { } blokkba kerül. 


=== Fájlbeolvasás korrekt kivételkezeléssel ===

A fenti kivételkezeléses példában a fájlkezelő utasításokat
a try..catch szerkezetbe ágyaztuk. Ez nem valami elegáns,
ráadásul átláthatatlanná teszik a szépen megírt 
fájlkezelő blokkunkat. A következő példában a kivételt 
eldobjuk a fájlkezelő részben, és mellette létrehozunk
egy hasonló nevű függvényt, amelynek a feladata csak
a kivétel kezelése. 

<code java FileBeolvas.java>
import java.io.FileNotFoundException;
import java.io.File;
import java.util.Scanner;

public class FileBeolvas {
    public static void beolvas() {
        try {
            tryBeolvas();
        }catch(FileNotFoundException ex) {
            System.err.println("A fájl nem található");            
        }
    }
    
    public static void tryBeolvas() throws FileNotFoundException {
        File f = new File("adat.txt");
	Scanner olvaso = new Scanner(f); 
	while(olvaso.hasNextLine()) {
		System.out.println(olvaso.nextLine());
	}        
    }    
    
    public static void main(String[] args) {        
        beolvas();
    }    
}
</code>

Vegyük észre a fájlkezelő metódus, amelynek a neve beolvas() volt fentebb, 
most át lett nevezve tryBeolvas()-ra. A hibakezelő metódus kapta a 
beolvas() nevet. A hibakezelő metódusból hívjuk meg a tryBeolvas() metódust. 


==== Fájlba írás ====
=== Egyszerű fájlba írás ===

<code java Program.java>
import java.io.*;

class Program
{
	public static void main(String args[]) throws IOException
	{
		
		FileWriter iro = new FileWriter("adat.txt", true);
		
		iro.write("joska:titok:gazdasag:Szolnok\n");	
		
		iro.flush();
		iro.close();
		
		System.out.println("Kiírva");
	}
}
</code>

A konstruktorban a második paraméter true, azt jelenti hozzáfűzünk az állományhoz.
Ez a paraméter nem kötelező. Ha nem adjuk meg alapértelmezetten felülírjuk az állományt.


=== BufferedWriter használata ===

<code java Program3.java>
import java.io.*;

class Program3
{
	public static void main(String args[]) throws IOException
	{
		FileWriter firo = new FileWriter("adat2.txt", true);		
		BufferedWriter iro = new BufferedWriter(firo);
		
		iro.write("Valai");
		
		iro.close();
		firo.close();
		
		System.out.println("Kiírva");
	}
}
</code>

=== PrintWriter használata ===

<code java Program4.java>
import java.io.*;

class Program4
{
	public static void main(String args[]) throws IOException
	{
		FileWriter firo = new FileWriter("adat2.txt", true);		
		PrintWriter iro = new PrintWriter(firo);
		
		iro.println("Valai");
		firo.close();		
		
		System.out.println("Kiírva");
	}
}
</code>


=== Összetettebb fájlba írás ===

<code java ap.java>
import java.io.*;

public class ap
{
    public static void main(String[] args) throws IOException
    {
        File f = new File("adat.txt");
        FileWriter kifolyam = new FileWriter(f); // Ha hozzáfűzni akarunk akkor FileWriter(f, true);
        PrintWriter kimenet = new PrintWriter(kifolyam);

        kimenet.println("alma");
        kimenet.println("körte");
        kimenet.println("szilva");
        kimenet.println("barack");

        kimenet.close();
    }
}
</code>

==== Fájl sorainak olvasása darabolással ====
<code java>
import java.io.*;
import java.util.*;

public class ap
{
    public static void main(String[] args) throws IOException
    {
        File f = new File("adat.txt");
        FileReader bemenet_folyam = new FileReader(f);

        BufferedReader bemenet = new BufferedReader(bemenet_folyam);

        boolean vege = false;
        String s, gyumolcs;
        int sorszam, suly;
        while(!vege)
        {
            s = bemenet.readLine();
            if (s != null)
            {
                StringTokenizer Tokenek = new StringTokenizer(s);
                sorszam = Integer.valueOf(Tokenek.nextToken()).intValue();
                suly = Integer.valueOf(Tokenek.nextToken()).intValue();
                gyumolcs = Tokenek.nextToken();
                System.out.println(sorszam + " " + suly + " " + gyumolcs);
            }
            else
                vege = true;
        }
        bemenet.close();
    }
}
</code>


==== Fájl olvasása karakterenként ====

<code java>
InputStream in = new FileInputStream("adat.txt");
Reader r = new InputStreamReader(in, "US-ASCII");

int intch;

while ((intch = r.read()) != -1) 
{
  char ch = (char) intch;
  //...
}

</code>

==== Az util csomag használata ====


<code java Program.java>
import java.io.*;
import java.util.*;

class Program {

	private static String fajlOlvas(String path) {
		File file = new File(path);
		Scanner olvaso = null;
		StringBuilder strb = new StringBuilder((int)file.length());
		try {
			olvaso = new Scanner(file);
		} catch(IOException e) {
			e.printStackTrace();
		}
		
		String sorTores = System.getProperty("line.separator");

		try {
			while(olvaso.hasNextLine()) 
				strb.append(olvaso.nextLine() + sorTores);
			return strb.toString();
		} finally {
			olvaso.close();
		}
	}
	public static void main(String[] args) {
		String str = fajlOlvas("adat.txt");
		System.out.println(str.replace("m", "g"));
	}
}
</code>


Egy rövid példa:
<code java Program.java>
import java.util.Scanner;
import java.io.File;
import java.io.IOException;
class Program {
	public static void main(String[] args) throws IOException {
		File file = new File("adat.txt");
		Scanner olvaso = new Scanner(file);			
		
		System.out.println(olvaso.nextLine());
		System.out.println(olvaso.nextLine());
	}	
}
</code>
Vegyük észre, hogy itt nem olvasunk a fájl végéig.


A fájl végéig olvasáshoz:
  while(olvaso.hasNextLine()) 
      strb.append(olvaso.nextLine() + sorTores);


==== Olvasás byte tömbbe ====

<code java Program.java>
import java.io.*;
import java.util.*;
class Program {
        private static String readFileAsString(String filePath) throws IOException {
                byte[] buffer = new byte[(int) new File(filePath).length()];
                FileInputStream f = new FileInputStream(filePath);
                f.read(buffer);
                return new String(buffer);
        }
        public static void main(String[] args) throws IOException {
		String str = readFileAsString("adat.txt");
                System.out.println(str);
        }
}
</code>

==== Karakterkódolás beállítása ====

Néhány megadható kódolás:
  * UTF-8
  * ISO-8859-1
  * Windows-1252
  * US-ASCII

További kódokat, a java.nio.charset.Charset osztály dokumentációja biztosít.

UTF-8 kódolással, Linuxon és Windowson is helyesen látszanak az ékezetek.


<code java>
Scanner nFile = new Scanner(new File(fileName), "UTF-8");
</code>

vagy:

<code java>
try {
	String fileName = "adat.txt";				
	Reader r = null;
	try {
		InputStream in = new FileInputStream(fileName);
		//US-ASCII
		r = new InputStreamReader(in, "UTF-8");
	} catch(UnsupportedEncodingException e) {}
		
	Scanner nFile = new Scanner(r);

	while(nFile.hasNextLine()) {
		String str = nFile.nextLine();
		System.out.println(str);
	}
	nFile.close();
} catch(FileNotFoundException e) {
	System.err.println("Hiba a fájlból olvasás során");
}
</code>

Stream osztállyokkal:

<code java>
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.BufferedReader;

class Program01 {
	public static void main(String args[]) throws IOException {
		
		OutputStreamWriter fout = new OutputStreamWriter(new FileOutputStream("adat.txt"), "UTF-8");
		
		fout.write("almaáűé");
		fout.flush();
		fout.close();
		System.out.println("Kiírva");
		
		InputStreamReader fin = new InputStreamReader(new FileInputStream("adat.txt"), "UTF-8");
		BufferedReader in = new BufferedReader(fin);
		System.out.println(in.readLine());
	}
}
</code>


Karakterkódolás a Scanner osztállyal:
<code java Program01.java>
import java.util.Scanner;
import java.io.FileNotFoundException;
import java.io.File;
class Program01 {
	public static void main(String[] args) {
		Scanner nFile = null;
		try {
			nFile = new Scanner(new File("adat.txt"), "UTF-8");
		} catch(FileNotFoundException ex) {
			System.err.println("Nemlétező fájl");
		}
		
		String str = nFile.nextLine();
		System.out.println(str);
		nFile.close();
	}
}
</code>


A hibakeresés leválasztása, karakterkódolás beállítása fájlba írás közben:
<code java Solution.java>
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Solution {
  public void writeFile() {
      try {
          tryWriteFile();
      }catch(IOException e) {
          System.err.println("Hiba! A kiírás sikertelen!");
          System.err.println(e.getMessage());    
      }
  }

  public void tryWriteFile() throws IOException {
      try(
        FileOutputStream fos = new FileOutputStream("data.txt", true);
        OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8")
      ) {
        osw.write("aaaa");
        osw.write(":bbbb");
        osw.write("\n");
      }      
  }
}
</code>


==== Típusos fájl ====

<code java Program01.java>
import java.io.BufferedOutputStream;
import java.io.BufferedInputStream;
import java.io.DataOutputStream;
import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.FileInputStream;

class Program01 {
	public static void main(String[] argv) throws Exception {
		FileOutputStream fileOut = new FileOutputStream("data.txt");
		BufferedOutputStream bufferOut = new BufferedOutputStream(fileOut);
		DataOutputStream dataOut = new DataOutputStream(bufferOut);
		dataOut.writeUTF("árvíztűrő");
		dataOut.writeLong(34L);
		dataOut.writeInt(44);
		dataOut.writeDouble(32.343);
		dataOut.writeBoolean(true);		
		dataOut.close();
		bufferOut.close();
		fileOut.close();
		
		FileInputStream fileIn = new FileInputStream("data.txt");
		BufferedInputStream bufferIn = new BufferedInputStream(fileIn);
		DataInputStream dataIn = new DataInputStream(bufferIn);
		System.out.println(dataIn.readUTF());
		System.out.println(dataIn.readLong());
		System.out.println(dataIn.readInt());
		System.out.println(dataIn.readDouble());
		System.out.println(dataIn.readBoolean());
		dataIn.close();
		bufferIn.close();
		fileIn.close();
	}
}
</code>

A sorrendet tartani kell.
==== Véletlen hozzáférésű fájlok ====

=== Írás fájlba ===

<code java Program01.java>
import java.io.*;
class Program01 {
	public static void main(String args[]) throws IOException{
		System.out.println("Hi");

		RandomAccessFile file = new RandomAccessFile("adat.txt", "rw");
		file.seek(12);
		file.write("Hello World".getBytes());
		file.close();

	}
}
</code>
A seek() metódussal a 12-es helyre állítom a fájlmutatót.
Ha üres a 12 pozíció előtt a fájl, akkor NUL értékekkel tölti fel.
=== UTF karakterek írása és olvasása ===

<code java Program01.java>
import java.io.*;
class Program01 {
	public void kiir() throws IOException {
		System.out.println("Kiírás");
		RandomAccessFile file = new RandomAccessFile("adat.txt", "rw");
		file.seek(20);		
		file.writeUTF("alma");
		file.seek(40);
		file.writeUTF("körte");
		file.seek(60);
		file.writeUTF("barack");
		file.seek(80);
		file.writeUTF("szilva");
		
		file.close();
		
	}
	public void olvas() throws IOException {
		RandomAccessFile file = new RandomAccessFile("adat.txt", "r");
		file.seek(40);
		System.out.println(file.readUTF());
		file.seek(60);
		System.out.println(file.readUTF());		
		file.close();
		
	}
	
	public static void main(String args[]) throws IOException{
		new Program04().kiir();
		new Program04().olvas();
	}
}
</code>
==== Gyakorlat ====

  * Sorolja fel, milyen osztályok használata jöhet szóba fájlkezelés esetén.
  * Mondjon egy osztály, amellyel egy állomány végéhez fűzhetünk sorokat.
  * Milyen osztályok használata esetén adhatjuk meg a karakterkódolást is fájlból olvasás során?


===== Típus ellenőrzés =====

==== Kivételek használata ====



Ellenőrizi szeretnénk, hogy valóban szabályosan valós szám lett beírva:
<code java>
try {
	double a = be.nextDouble();
} catch (Exception e) {
	System.out.println("Nem valós szám!");
}
</code>

Ha nem így történt, hibaüzenetet küldünk. 

Ügyeljünk arra, hogy a forrásban ugyan tizedes pontot használunk, de a bekérésnél tizedes vesszőt vár a java.



Ugyanez egész számmal:
<code java>
try {
	int a = be.nextInt();
} catch (Exception e) {
	System.out.println("Nem egész szám!");
}
</code>


Teljes példa a Scanner osztály használatára: 
<code java Tip.java>
import java.io.*;
import java.util.*;

class Tip {
	public static void main(String args[]) throws IOException {
		System.out.println("Típusellenőrzés");
		
		Scanner be = new Scanner(System.in);
	
		System.out.print("Szám: ");
		try {
			int a = be.nextInt();
		} catch (Exception e) {
			System.out.println("Nem egész szám");
		}

		System.in.read();
	}
}
</code>





Teljes példa BufferedReader osztály használata esetén
<code java Tip.java>
import java.io.*;

class Tip {
	public static void main(String args[]) throws IOException {
		System.out.println("Típusellenőrzés");
		
		InputStreamReader befolyam = new InputStreamReader(System.in);
		BufferedReader be = new BufferedReader(befolyam);
		
		String s;
		int szam;

		System.out.print("Szám: ");
		s = be.readLine();
		try {
			szam = Integer.valueOf(s).intValue();
		} catch(Exception e) {
			System.out.println("Gond van konverzióval");
		}

		System.in.read();
	}
}
</code>


Konverziónál, használhatjuk a NumberFormatException kivételt is:
<code java>
try {
    szam = Integer.valueOf(s).intValue();
} catch(NumberFormatException e) {
    System.out.println("Gond van konverzióval");
}
</code>

==== Függvény megírásával ====


<code java Tipusv.java>
import java.io.*;

class Tipusv {
	public static void main(String args[]) throws IOException {
		System.out.println("Hi");
			
		InputStreamReader befolyam = new InputStreamReader(System.in);
		BufferedReader be = new BufferedReader(befolyam);
		
		String s = be.readLine();
		
		if (isInteger(s))
			System.out.println("Egész szám");
		else
			System.out.println("Nem egész szám");


		System.in.read();
	}

	static public boolean isInteger(String bemenet) {
		try {
			Integer.parseInt(bemenet);
			return true;
		} catch(Exception e) {
			return false;
		}		
	} /* isInteger */
}
</code>

==== Reguláris kifejezések használata ====

<code java Tipusv.java>
import java.io.*;

class Tipusv {
	public static void main(String args[]) throws IOException {
		System.out.println("Hi");
			
		InputStreamReader befolyam = new InputStreamReader(System.in);
		BufferedReader be = new BufferedReader(befolyam);
		
		String s = be.readLine();
		
		if(s.matches("((-|\\+)?[0-9]+(\\.[0-9]+)?)+")) 
			System.out.println("Szám");
		else
			System.out.println("Ez nem szám");


		System.in.read();
	}
}
</code>

Ez a kódrész elfogad előjeleket és tizedespontot is.

==== text csomag ====


<code java Tipusv>

import java.io.*;
import java.text.*;

class Tipusv {
	public static void main(String args[]) throws IOException {
		System.out.println("Hi");
			
		InputStreamReader befolyam = new InputStreamReader(System.in);
		BufferedReader be = new BufferedReader(befolyam);
		
		String s = be.readLine();

		DecimalFormat df = new DecimalFormat("#%");	
		Number a = 0;
		
		try {
			a = df.parse(s);
			System.out.println("Szám: " + a.doubleValue());
		} catch(Exception e) {
			System.out.println("Nem megfelelő formátum" );
		}

		System.in.read();
	}
}
</code>

Példaformátum leírás:
  "#,##0.00%"

  "#,##0.00"

A Number típusú objektum metódusai. 
|  byte  |  byteValue()  | Az adott szám bájt értékével tér vissza  |
|  abstract  double  | 	doubleValue()  |  Az adott számot doulbe-ként adja vissza  |
|  abstract  float  |  floatValue()  |  Az adott számot float-ként adja vissza  |
|  abstract  int  |  intValue()  |  Az adott számot int-ként adja vissza  |
|  abstract  long  |  longValue()  |  Az adott számot long-ként adja vissza  |
|  short  |  shortValue()  |  Az adott számot short-ként adja vissza  |

          
<code java Tipusv>
import java.io.*;
import java.text.*;

class Tipusv {
	public static void main(String args[]) throws IOException {
		System.out.println("Hi");
			
		InputStreamReader befolyam = new InputStreamReader(System.in);
		BufferedReader be = new BufferedReader(befolyam);
		
		String s = be.readLine();

		NumberFormat df = NumberFormat.getInstance();
		Number a = 0;
		
		try {
			a = df.parse(s);
			System.out.println("Szám: " + a.doubleValue());
		} catch(Exception e) {
			System.out.println("Nem megfelelő formátum" );
		}

		System.in.read();
	}
}
</code>

===== Metódusok létrehozása =====

==== Statikus metódusok ====


Ha már nagyon sok utasításunk van, azokat csoportosítani szoktuk,
adunk neki egy nevet, majd a nevével hivatkozva hívjuk meg 
az összes utasítást. Például szeretnénk egy névjegykártyát 
kiíratni, amelyen szerepel a nevünk, címünk, telefonszámunk,
e-mail címünk, weblapunk. 

<code java Program.java>


class Program {	
	static void nevjegy() {
		System.out.println("Nagy József");
		System.out.println("Budapest");
		System.out.println("Tél u. 3.");
		System.out.println("+36 (30) 123-4567");
		System.out.println("nagy@valaholdomain.hu");
		System.out.println("http://valaholdomain.hu");
	}
	
	public static void main(String[] args) {
		nevjegy();
	}
}
</code>


A fenti példában a metódus fej része így néz ki:
<code java>
static void nevjegy()
</code>

  * ( )
    * A név után tettünk egy nyitó és egy bezáró zárójelet. 
  * static
    * A static egy módosító, amely megmondja, hogy a metódust akkor is használhatjuk, ha nem hoztunk létre az osztályból példányt. 
  * void
    * A void a visszatérés típusát mondja meg. A void azt jelenti nem térünk vissza semmivel.
  * { }
    * Az utasításokat a kapcsos zárójelekkel fogom össze egyetlen blokká.







Néha a metódusainknak szeretnénk bemenő paramétereket megadni. 
Például, szeretnénk egy szám négyzetét venni. Ekkor a metódusnak
paraméterkén megadhatjuk mi legyen ez a szám. 

<code java Program.java>
class Program {	
	static void negyzet(double szam) {
		System.out.println(szam * szam);
	}
	public static void main(String[] args) {
		negyzet(3.5);

	}
}
</code>


Előfordulhat, hogy a kapott számot nem képernyőre szeretném
íratni, hanem szeretném azt megkapni, továbbszámolás céljára.
Ekkor a metódust úgy kell megírni, hogy adja vissza a
kért értéket. Maradva a fenti négyzetszámító programnál,
alakítsuk úgy át a programot, hogy adja vissza az
adott szám értékét. 

<code java Program.java>
class Program {	
	static double negyzet(double szam) {
		return szam * szam;
	}
	public static void main(String[] args) {
		System.out.println(negyzet(3.5)+2);
	}
}
</code>

Vegyük észre, hogy a metódusainkat az osztályon belül hoztuk létre, 
static kulcsszóval láttuk el, ennek hatására az osztály példányosítása nélkül
tudjuk azokat használni. 

A metódusoknak egész sorozatát hozhatjuk létre:

<code java Program.java>
class Program {
	static double dupla(double szam) {
		return 2 * szam;
	}
	static double negyzet(double szam) {
		return szam * szam;
	}
	static double felez(double szam) {
		return szam / 2;
	}
	public static void main(String[] args) {		
		System.out.println(Program.negyzet(3.0));
		System.out.println(Program.dupla(3.0));
		System.out.println(Program.felez(3.0));
	}
}
</code>

==== Példánymetódus ====

Az alábbi példában a metódust a static kulcsszó 
nélkül hozzuk létre. A használata ebben az esetben csak példányosítással lehetséges.

<code java Program.java>
class Program {
	double negyzet(double szam) {
		return szam * szam;
	}
	
	public static void main(String[] args) {
		Program program = new Program();
		System.out.println(program.negyzet(3.5)+2);
	}
}
</code>



Metódusok egész sorozata:

<code java Program.java>
class Program {
	double dupla(double szam) {
		return 2 * szam;
	}
	
	double negyzet(double szam) {
		return szam * szam;
	}
	double felez(double szam) {
		return szam / 2;
	}
	
	public static void main(String[] args) {
		Program program = new Program();
		
		System.out.println(program.negyzet(3.0));
		System.out.println(program.dupla(3.0));
		System.out.println(program.felez(3.0));
	}
}
</code>

==== Metódusok külön osztályban ====


<code java Program.java>
class Szamitas {
	double dupla(double szam) {
		return 2 * szam;
	}	
	double negyzet(double szam) {
		return szam * szam;
	}
	double felez(double szam) {
		return szam / 2;
	}	
}

class Program {
	public static void main(String[] args) {
		Szamitas szamitas = new Szamitas();
		
		System.out.println(szamitas.negyzet(3.0));
		System.out.println(szamitas.dupla(3.0));
		System.out.println(szamitas.felez(3.0));
	}
}
</code>


==== Paraméterátadás ====

Ha készítek egy metódust, a bemenő paramétereket **formális paraméternek** is nevezzük.
Ezzel szemben az **aktuális paraméter**, a metódus hívásának helyén behelyettesített
változók.

A Java nyelvben a paraméterek **érték szerint** kerülnek átadásra. Másként szólva, ha
egy metóduson belül megváltoztatom egy formális paraméter értéket, ez nem érinti az
aktuális paraméter értékét.

Ha nem alaptípusokat használunk paraméterként az átadás már nem érték szerint történik.

A következő példában egyszerű típust adunk át paraméterként:
<code java Program01.java>
class Program01 {
	public static void szamol(Integer szam) {
		szam = szam * 2;
		System.out.println(szam);
	}	
	public static void main(String[] args) {
		
		Integer szam = 4;
		szamol(szam);
		System.out.println(szam);
	}
}
</code>

Eredmény:
  8
  4

A következő példában referencia típus adunk át:
<code java Program01.java>
class Dolog {
	int szam = 1;
}
class Program01 {	
	public static void szamol(Dolog dolog) {
		dolog.szam = dolog.szam * 2;
		System.out.println(dolog.szam);
	}
	
	public static void main(String[] args) {
		Dolog dolog = new Dolog();
		dolog.szam = 4;
		szamol(dolog);
		System.out.println(dolog.szam);
	}
}
</code>

Eredmény:
  8
  8


Az utóbbival egyező eredményt kapunk tömbökkel, mivel azok is referenciák:

<code java Program01.java>
class Program01 {
	public static void szamol(int[] t) {
		t[0] = t[0] * 2;
		System.out.println(t[0]);
	}	
	public static void main(String[] args) {
		
		int[] t = new int[2];
		t[0] = 4;
		t[1] = 10;
		szamol(t);
		System.out.println(t[0]);
	}
}
</code>

Eredmény: 
  8
  8


===== Több fájl =====
Ha már sok osztályunk van érdemes azokat külön állományban tárolnunk.


A következő két fájl egyszerűen egy könyvtárban használom. 

<code java Program01.java>
class Program01 {
	public static void main(String args[]) {
		Program02 prog = new Program02();
		prog.kiir();
	}
}
</code>

<code java Program02.java>
class Program02 {
	public void kiir() {
		System.out.println("Másik osztály");
	}
}
</code>

===== Saját osztályaink "becsomagolása" =====

Ha még több saját osztályunk van azokat külön állományokba rakjuk és becsomagoljuk.

Abban a fájlban ahol az osztályaink el vannak helyezve, az állomány
elején egy package Csomagnév; utasítást kell elhelyeznünk. 

Egy osztály importálása  egy csomagból az import utasítás után 
megadott csomagnév.Osztály; formában történhet. Ilyen formában:
  import csomagnév.Osztály;
Ha "*" karaktert használunk, akkor a csomag összes osztályát 
használatba vettük. 

Minden csomag számára saját könyvtárat kell létrehozni. 
A csomag osztályainak .class állományait ide be kell
másolni.

<code java Program01.java>
import sajat.*;

class Program01 {
	public static void main(String args[]) {		
		Program02 ketto = new Program02();
		ketto.kikuld();

		Program03 harom = new Program03();
		harom.kikuld();
	}
}
</code>

<code java sajat/Program02.java>
package sajat;
public class Program02 {
	public void kikuld() {
		System.out.println("Második");
	}
}
</code>

<code java sajat/Program03.java>
package sajat;
public class Program03 {
	public void kikuld() {
		System.out.println("Harmadik");
	}
}
</code>