http://java2.uw.hu/
A JAVA programozásban megtalálhatók a változók, ciklusok, és a main eljárás is. A JAVA-ban az általunk létrehozott programokat osztályokban alkotjuk meg. Ezeket a "public class Osztalynev" paranccsal tudjuk megalkotni. Ahol a public a láthatóságot, a class az osztály típust adja meg. Az Osztalynev név tetszőlegesen módosítható. Pár alapvető szabályra kell odafigyelni. Mindig nagy betűvel kezdődik, az angol ábécé betűit lehet használni, és nem lehet az osztálynévben szóköz. A láthatóság a mi szempontunkból nem igazán lényeges. Ha minden esetben public-ot használunk nem lesz belőle gond. A JAVA-ban a while, do while és for ciklusok ugyanúgy működnek, mint a C-ben szóval azokra nem térek ki külön. A main annyiban különbözik a C-hez képest, hogy megköveteli a láthatóságot a statikusságot és a void visszatérési típust. A main megadása mindig a példaprogramban látható módon történik, kötelezően.
1.feladat: A Fibonacci számsor első 10 elemének kiíratása for ciklus segítségével. Az első két elemet ki lehet íratni a cikluson kívül is, de a többit már csak cikluson belül.
public class Fibonacci { // osztály létrehozása.
public static void main(String[] args) { //main eljárás létrehozása
int a, b; // egy a és egy b int(egész) típusú változó deklarálása
a=0; // a 0 értéket adja meg az "a" nevű változónak.
b=1; // az 1 értéket adja meg a "b" nevű változónak.
System.out.println(a);// kiírja az "a" értékét.
System.out.println(b);// kiírja a "b" értékét.
for(int i=0;i<4;i++){ // 4-szer lefutó for ciklus blokkjának kezdete.
a=a+b; // a értékét módosítja a+b-re
System.out.println(a);// kiírja az a aktuális értékét.
b=a+b; // b értékét módosítja a módosított a+b értékére.
System.out.println(b); //kiírja b aktuális értékét.
} //for ciklus blokkjának vége
} //main eljárás vége
} //osztály bezárása
2.
Eljárások
A JAVA-ban az eljárások egy előre meghatározott utasítássorozatot hajtanak végre úgy, hogy a main-en kívül megírjuk az eljárást, majd a main-en belül meghívjuk azt a nevén keresztül az aktuális paramétereivel, amennyiben vannak neki. Hasonlóan, mint a C nyelvben. Fontos tudni az eljárásokról, hogy a generálásukkor a visszatérési típusok mindig void és az utasítássorozat végén nem tartalmaznak return sort, tehát technikailag nem adnak vissza semmilyen értéket.
1.feladat: A program tartalmazzon 4 eljárást, melyek egyenként 2-2 bemeneti paraméterrel rendelkeznek és ezeken végzik el a 4 matematikai alapműveletet, aminek az eredményét ki is írják a képernyőre. (Tehát kell egy összeadás, egy kivonás, egy szorzás és egy osztás eljárás.) Végül pedig a main eljárásban hívjuk meg ezeket az eljárásokat, lehetőleg olyan értékellek, amelyeknek az eredménye fejben is könnyen kiszámolható. Valamint figyeljünk arra, hogy az osztásnál tizedes tört legyen az eredmény.
public class Muveletek{ // osztály létrehozása.
public static void ossze(int a,int b){ //statikus eljárás, üres visszatérési típussal. rendelkezik két int típusú bemenő paraméterrel.
int x; // x deklarálása.
x=a+b; // x értékének megadása a+b-vel (a két bemenő paraméterrel).
System.out.println(x); // kiírja x aktuális értékét.
}
public static void kivon(int c,int d){ //statikus eljárás, üres visszatérési típussal. rendelkezik két int típusú bemenő paraméterrel.
int y; // y deklarálása.
y=c-d; // y értékének megadása úgy, hogy c bemenő paraméter értékéből kivonja d bemenő paraméter értékét.
System.out.println(y); // kiírja y aktuális értékét.
}
public static void szorzas(int e,int f){ //statikus eljárás, üres visszatérési típussal. rendelkezik két int típusú bemenő paraméterrel.
int z; // z deklarálása.
z=e*f; // z értékének megadása úgy, hogy e paraméter értékét megszorozza az f bemenő paraméter értékével.
System.out.println(z); // kiírja z aktuális értékét.
}
public static void osztas(double g,double h){ //statikus eljárás, üres visszatérési típussal. rendelkezik két double (lebegőpontos) típusú bemenő paraméterrel.
double u; // u deklarálása.
u=g/h; // u értékének megadása úgy, hogy g bemenő paraméter értékét elosztja a h bemenő paraméter értékével.
System.out.println(u); // kiírja az u aktuális értékét.
}
public static void main(String [] args){ //main eljárás.
ossze(4,5); // az ossze nevű eljárás meghívása, a zárójelben a két bemenő paraméter.
System.out.println(""); // üres sort ír ki.
kivon(4,5); // a kivon nevű eljárás meghívása, a zárójelben a két bemenő paraméter.
System.out.println(""); // üres sort ír ki.
szorzas(4,5); // a szorzas nevű eljárás meghívása, a zárójelben a két bemenő paraméter.
System.out.println(""); // üres sort ír ki.
osztas(3.0,2.0); // az osztas nevű eljárás meghívása, a zárójelben a két bemenő paraméter.
}
}
2.feladat: Az előző heti Fibonacci feladat megvalósítása eljárás használatával.
public class Fibonacci2 { // osztály létrehozása.
public static void fibonacci() { // létrehoz egy statikus eljárást bemenő paraméter nélkül, üres visszatérési típussal. Azért statikus, hogy kommunikáljon a statikus main-el.
int a, b; // deklarálja a-t, és b-t.
a=0; // a-nak 0 kezdőértéket ad.
b=1; // b-nek 0 kezdőértéket ad.
System.out.println(a); // kiírja a aktuális értékét.
System.out.println(b); // kiírja b aktuális értékét.
for(int i=0;i<4;i++){ // for ciklus, mely 4-szer fut le.
a=a+b; // a értékét módosítja a+b-re.
System.out.println(a); // kiírja a aktuális értékét.
b=a+b; // b értékét módosítja a+b-re.
System.out.println(b); // kiírja b aktuális értékét.
}
}
public static void main(String[] args) { // main eljárás
fibonacci(); // meghívjuk az fentebb létrehozott eljárást.
}
}
3.
Függvények, Globális változók
A függvények annyiban térnek el az eljárásoktól, hogy a visszatérési típusok nem void hanem valamilyen adatot tárolni képes típus ()pl.: int, char, double...), valamint a függvények utolsó sora mindig a return sor, amivel egy adott értéket vagy egy változó tartalmát adja vissza a main-nek. A függvényeket mindig úgy hívjuk meg a main-ben, hogy valamilyen változóban letároljuk annak a visszaadott eredményét.
A globális változók olynba változók, melyeket a main kívül hozunk létre láthatósági és statikus tulajdonsággal. Annyiban térnek el a mainben létrehozott változóktól, hogy azok a változók, amiket a mainben hoztunk létre, csak a meinben lehet használni, de a globális változókat a JAVA programon belül akárhol lehet használni. Olvasni vagy akár módosítani is az értéküket.
1.feladat: Hozzunk létre egy programot, amely tartalmaz egy globális változót (pl x), egy eljárást, ami két bemenő paraméterrel rendelkezik (pl a és b) és azt csinálja, hogy egy számsorozatot ír ki, úgy, hogy "a"-val osztható számokból "b" darabot. Ezt az eljárást hívjuk meg a main-ben legalább kétszer úgy, hogy a darabszámhoz mind a kétszer az x változót adjuk meg bemeneti paraméterként. (Kicsit egyszerűbben megfogalmazva. Két számsorozatot kell kiíratni úgy, hogy ha egy helyen módosítom a darabszámot, mind a két sorozat reagáljon rá!)
+1.feladat: Az előző feladat megvalósítása függvény használatával. Szükséges módosítások elvégzésével a mainben.
+2.feladat: Hozzunk létre két globális változót és két eljárást! Az egyik eljárással értékeket adunk a változóknak bemenő paraméterekkel(ezek az értékek 1 vezeték és 1 keresztnév), a másikkal pedig kiíratjuk ezeket az értékeket. Hívjuk meg ezt a két eljárást a mainben legalább két példány segítségével.
public class Sorozatok { // osztály létrehozása.
public static int x=10; // globális statikus változó deklarálása, melynek értéke 10. a program bármely részében elérhető és módosítható
public static void oszthatosag(int a, int b) { // oszthatosag eljárás létrehozása két bemenő paraméterrel.
int h=0; // h változó deklarálása, melynek értéke 0.
for(int i=0;i// for ciklus, mely b-szer fut le.
h=h+a; // h értékének megadása úgy, hogy h-hoz hozzáadjuk a értékét.
System.out.println(h); // kiírja h aktuális értékét.
}
}
public static void main(String[] args) { // main eljárás
System.out.println("A 3mmal oszthato elso x szam"); // kiírja ezt a szöveget: "A 3mmal oszthato elso x szam"
oszthatosag(3,x); // meghívja az oszthatosag eljárást, melynek segítségével kiírja a 3-al osztható számokat. Az x a fentebb megadott globális változó értéke lesz, azaz 10. Tehát 10 db 3-al osztható számot fog kiírni.
System.out.println(""); // üres sort ír ki.
System.out.println("5ttel oszthato elso x szam"); // kiírja ezt a szöveget: "5ttel oszthato elso x szam"
oszthatosag(5,x); // meghívja az oszthatosag eljárást, melynek segítségével kiírja az 5-el osztható számokat. Az x a fentebb megadott globális változó értéke lesz, azaz 10. Tehét 10 db 5-el osztható számot fog kiírni.
}
}
Példányosítás, Öröklődés
A példányosítást ha megfogható alakra akarjuk hozni úgy kell elképzelnünk, mint a klónozást. Megalkotunk egy olyan programot, ami megfelel az elvárásainknak és ha többször akarjuk egymás után végrehajtani a lépéseket úgy, hogy Mindegyik változatnak megmaradjanak az eredményei, akkor nem kell a különböző változónevek kiötlésével bajlódnunk, csak csinálunk egy újabb példányt(klónt), aminek a memóriacímére hivatkozva könnyen megnézhetjük a számunkra szükséges adatokat. Fontos különbség, hogy példányosításnál a változók, eljárások és függvények deklarálásánál nem kell használni a static tulajdonságot. A példányosításkor lehet konstruktorfüggvényeket megalkotni. Ez a függvény fogja tartalmazni azokat a lépéseket, amiknek már a példány megalkotásakor végbe kell mennie.
Az Öröklődés lényege, hogy a programokat lehet egymásból leszármaztatni. A leszármazott osztályok öröklik a szülőosztály minden mezőjét és metódusát (azonban a konstruktorfüggvényeket nem!). Az osztályokban a mezők mellett célszerű mindazokat a metódusokat definiálni, amelyekkel a mezőkön műveleteket végezhetünk. Ha az összes szükséges metódust létrehoztuk, a mezőkre nem kell közvetlenül hivatkoznunk, mivel a metódusokon keresztül minden szükséges művelet elvégezhető rajtuk (ez az ún. zártság vagy egységbezárás elve).
Egy leszármazott osztálynak lehetnek további leszármazottjai, így egy öröklési hierarchiához jutunk. Az öröklési hierarchiában egyes metódusokat átdefiniálhatunk, ilyenkor többalakúságról (polimorfizmusról) beszélünk. A polimorf metódusok neve és típusa, valamint szignatúrája (a formális paraméterek száma, típusa és sorrendje) megegyezik, de definíciójuk eltér (például azért, mert az öröklési hierarchia különböző pontjain más adatmezők érhetőek el, és ezekre a metódusok hivatkoznak).
Egy osztályon belül létezhetnek azonos nevű, de különböző szignatúrájú metódusok. Ilyenkor a metódusnév túlterheléséről beszélünk. A túlterhelt metódusok típusa különböző is lehet, valamint vegyesen előfordulhatnak közöttük osztály- és példányszintű metódusok is.
Hozzunk létre egy programot, amely tartalmaz 3 globális változót és három mező szintű eljárást. Az első eljárás egy számot vár bemenő paraméterként és azt a számot letárolja az egyik globális változóban. A másik eljárás egy vezetéknevet és egy keresztnevet vár bemenő paraméternek, melyeket értékül ad a másik két globális változóban. A harmadik eljárásnak nincs bemenő paramétere és azt csinálja, hogy kiíratja a következő szövet: "Helló 22 éves Nagy Gergő!" (Természetesen a név és a szám annak felel meg, ami a bemenő paraméter volt az előző két eljárásban.) Hozzunk létre a main-ben két példányt és hívjuk meg velük mindhárom eljárást!
public class Udv{ // osztály létrehozása.
public int x; // x-et deklarálja, globális változó.
public String vnev,knev; // String típusú változókat deklarál, mely segítségével karakterláncokat hozhatunk létre. Ezek is globális változók.
public void ev(int a){ // mező szintű eljárás, mely egy int bemenő paramétert vár.
x=a; // a bemenő paramétert ( az a-t) letárolja az x, globális változóban.
}
public void nev(String a,String b){ // mező szintű eljárás, amely két String típusú változót vár bemenő paraméterként.
vnev=a; // az "a" bemenő paramétert letárolja a vnev nevű globális változóban.
knev=b; // a "b" bemenő paramétert letárolja a knev nevű globális változóban.
}
public void kiir(){ // létrehoz egy kiir nevű, mező szintű eljárást
System.out.println("Hello "+x+" eves "+vnev+" "+knev+"!"); // kiírja a megadott paraméterek alapján a szöveget.
}
public static void main(String[]args){ // main eljárás.
Udv p1=new Udv(); // új példány létrehozása.
p1.nev("Nagy","Sandor"); // a p1 példány címére hivatkozva meghívjuk a nev eljárást.
p1.ev(23); // a p1 példány címére hivatkozva meghívjuk az ev eljárást.
p1.kiir(); // a p1 példány címére hivatkozva meghívjuk a kiir eljárást.
Udv p2=new Udv(); // új példány létrehozása.
p2.nev("Hoki","Gyuri"); // a p2 példány címére hivatkozva meghívjuk a nev eljárást.
p2.ev(26); // a p2 példány címére hivatkozva meghívjuk az ev eljárást.
p2.kiir(); // a p2 példány címére hivatkozva meghívjuk a kiir eljárást.
}
}
Az előző feladatban megírt programból származtassunk le egy új programot! (Öröklődés) Írjátok meg a névadó eljárást úgy, hogy egy sorszámnév is kerüljön bele római számmal bemenő paraméterként! (pl.: III. Török Szulejmán) Valamint a kiírató eljárást is írjátok meg újra úgy, hogy azt írja ki: "Üdvözöllek III. Török Szulejmán, aki 40 éves!" Természetesen itt is a bemenő paraméterekből kell megkapni ezt az eredményt. Fontos, hogy az ősosztályban és a leszármazott osztályban ugyanaz legyen a neve az értékadó és a kiírató eljárásoknak. Majd a mainben hozzatok létre egy példányt az ős osztályból, valamint a leszármazott osztályból és hívjátok meg a hozzájuk tartozó eljárásokat!
public class Uralkodoi extends Udv{ // az "extends"-el a származtatott osztály (Uralkodoi) örökli az ősosztály (Udv) összes adattagját és metódusát.
public String v; // String típusú, globális változó deklarálása.
public void nev(String a,String b,String c){ // mező szintű eljárás, mely 3 String típusú bemenő paramétert vár.
vnev=a; // az "a" bemenő paramétert letárolja a vnev változóban.
knev=b; // a "b" bemenő paramétert letárolja a knev változóban.
v=c; // a "c" bemenő paramétert letárolja a c változóban.
}
public void kiir(){ // kiir nevű eljárás létrehozása.
System.out.println("Udvozollek "+v+" "+vnev+" "+knev+" aki "+x+" eves!"); // a megadott paraméterek alapján kiírja a szöveget.
}
public static void main(String[]args){ // main eljárás
Udv p1=new Udv(); // példány létrehozása az ősosztályból.
p1.nev("Nagy","Sandor"); // a p1 példány címére hivatkozva meghívjuk az ősosztály nev eljárást.
p1.ev(23); // a p1 példány címére hivatkozva meghívjuk az ősosztály ev eljárást.
p1.kiir(); // a p1 példány címére hivatkozva meghívjuk az ősosztály kiir eljárást.
Uralkodoi q1=new Uralkodoi(); // példány létrehozása az aktuális osztályból.
q1.nev("Nagy","Sandor","II."); // a q1 példány címére hivatkozva meghívjuk a leszármazott osztály nev eljárását.
q1.ev(23); // a q1 példány címére hivatkozva meghívjuk az ősosztály ev eljárását.
q1.kiir(); // a q1 példány címére hivatkozva meghívjuk a leszármazott osztály kiir eljárását.
}
}
Vezérlési szerkezetek, Hibakezelés
A JAVA-ban a vezértlési szerkezetek, tehát az if és a switch teljesen azonosan működnek a C nyelvben tanultakkal.
A hibakezeléssel a JAVA-ban lehetőségünk van arra, hogy bizonyos specifikus hibákat megkeressünk a programban és arra, önmagunknak vagy a későbbi felhasználók számára egyértelmű és könnyebben érthető hibaüzeneteket közöljünk, mint a fordító. A try{} blokkban szereplő programrészletben fogja keresni a hibákat. A catch{} blokkokban pedig megírhatjuk, hogy bizonyos hibák esetén mit tegyen a program.
Hozzunk létre egy programot, amelyben létrehozunk egy függvényt, ami két bemenő paraméterrel rendelkezik! Az első paraméter legyen a hatványozás alapja, a második pedig a kitevő! Végeztessük el a műveletet a függvénnyel és a visszatérési érték legyen a művelet eredménye! (Nem ér használni a Math.pow() függvényt!) Hozzunk létre egy eljárást, ami kiírja szövegesen, hogy "szám alap a szám kitevőn: eredmény." (Pl.: 2 alap a 3 kitevőn: 8)! Hívjuk meg ezt a függvényt és az eljárást a mainben! A hatványozáshoz szükséges értékeket a parancssorról (billentyűzetről) kapjuk.
public class Hatvanybe{
public static int a, k, e; // a, k és e int típusú statikus globális változók deklarálása.
public static int hatvany(int alap, int kitevo){ // függvény létrehozása, két bemenő paraméterrel, int visszatérési értékkel. Az első a hatványozás alapja, a másik pedig a kitevő.
int c=1; // 1 értékül adása a c-nek.
for (int i=0;i// for ciklus, mely addig fut le, míg az i értéke kisebb, mint a kitevő értéke)
c=c*alap; // c értékének megadása úgy, hogy c-t megszorozza alap-pal.
}
return c; // visszatérési érték, mely az előző művelet eredménye.
}
public static void kiiras(int alap, int kitevo,int c){ // kiiras eljárás, mely az alap, a kitevő és c bemenő paraméterekkel rendelkezik.
System.out.println(alap+" alap a "+kitevo+ " kitevon: "+c+"."); // kiírja a megadott szöveget a megadott paraméterekkel.
}
public static void main (String[]args){
if(args.length<2) { // a bemenő paramétereket parancssori paraméterekből veszi. Ha a bemenő paraméterek száma kisebb 2-nél
System.out.println("Irj be ket szamot legkozelebb!");// akkor ezt a szöveget írja ki: "Irj be ket szamot legkozelebb!
System.exit(1); // ezt követően kilép az eljárásból.
}
a=Integer.parseInt(args[0]); // az első parancssori paraméter intté alakításával adja meg az a értékét.
k=Integer.parseInt(args[1]); // a második parancssori paraméter intté alakításával adja meg a k értékét.
e=hatvany(a,k); // kiszámolja a hatvány fv-ben megadott művelet alapján az eredményt és letárolja az e változóban.
kiiras(a,k,e); // kiírja az alap, a kitevő, és az érték eredményét.
}
}
Hozzunk létre egy osztályt, amiben példányosítás segítségével egy bibliográfiát fogunk csinálni! Állítsuk be eljárás(ok) segítségével (mindenkire rábízom, hogy mennyivel oldja meg), hogy mi a cím és ki a szerző, valamint legyen feltüntetve még egy kiadási év is! Valamint készítsetek egy kiírató eljárást is, ami a következőt írja ki: "Cím/Szerző. - kiadév"! (Pl.:Első és egyetlen/Dan Abnett. - 2001) Hozzunk létre legalább 3 példányt/rekordot!
public class Biblio{
public String szerzo,cim; // String típusú globális változók deklarálása.
public int kiadas; // int típusú globális változó deklarálása.
public void nevado(String a, String b, int c){ // nevado eljárás létrehozása, 3 bemenő paraméterrel.
szerzo=a; // az "a" bemenő paramétert letárolja a szerzo változóban.
cim=b; // a "b" bemenő paramétert letárolja a cim változóban.
kiadas=c; // a "c" bemenő paramétert letárolja a kiadas változóban.
}
public void kiir(){ // kiir nevű eljárás létrehozása.
System.out.println(cim+"/"+szerzo+". - "+kiadas); // Kiírja a fentebb megadott bemenő paramétereket.
}
public static void main(String[]args){ // main eljárás létrehozása.
Biblio p1=new Biblio(); // példányosítás.
p1.nevado("Andrzej SapBibliowski","Az utolso kivansag",1993); // eljárás meghívása.
p1.kiir(); // kiírás.
Biblio p2=new Biblio(); // példányosítás.
p2.nevado("Drew Karpyshyn","A pusztitas utja",2006); // eljárás meghívása.
p2.kiir(); // kiíratás.
Biblio p3=new Biblio(); // példányosítás.
p3.nevado("John Scalzi","Venek haboruja",2005); // eljárás meghívása.
p3.kiir(); // kiíratás.
}
}
Hozzunk létre egy programot, ami egy parancssori paramétert vár! Ez a parancssori paraméter egy betű legyen! A program csinálja azt, hogy valamilyen olyan keresztnevet írjon ki, ami a megadott betűvel kezdődik. Csak, hogy ne kelljen végig írni az egész ábécét, elég ha mondjuk g-ig lekezelitek a betűket. Az összes többi esetben pedig azt írja ki, hogy "Az adatbázis csak G-ig tartalmaz neveket" vagy valami hasonlót. A feladat megoldásához kötelezően használjatok IF-et. Megjegyzés: Stringekre nem működik az = =, szóval ilyenekkel ne is próbálkozzatok, hogy 'betu=="a";', mert nem fog lefutni. Helyette a '.equals();' szövegfüggvényt alkalmazzátok! Ha pl az "a" betűt akarjátok behasonlítani, akkor az úgy néz ki, hogy: if(valtozonev.equals("a"));.
public class Nevek{
public static void main(String[] args) {
if(args.length<1) { // ha nincs parancssori paraméter, akkor az alatta lévő kiírás teljesül
System.out.println("Irj mar be egy betut!"); // ha igaz volt az előző feltétel, akkor ezt a szöveget írja ki: Irj mar be egy betut!
System.exit(1); // megszakítja a program futását.
}
String s="Az adabazis csak g-ig van feltoltve"; // deklarál egy s nevű, String típusú változót.
String j=args[0]; // a j változóba beleteszi az első parancssori paraméter értékét.
if(j.equals("a")){s="Aladar";} // a Stringeknél nem működik értékek egyenlőségének vizsgálatra az "==" parancs, helyette a .equals() utasítást kell használni úgy hogy a vizsgálandó változó neve után írjuk. Ha j tartalma egyenlő az a Stringgel, akkor s-be belekerül az Aladar érték.
else if(j.equals("b")){s="Bela";} // Az else if akkor lép életbe, ha az előző if ágban megadott feltételek nem teljesülnek. Ha az else if ágból bármely else if igaz, akkor az utána következő else if és else ágakat már nem vizsgálja meg. Ha az else if-ben teljesül a feltétel. Ha j tartalma egyenlő a b Stringgel, akkor s-be belekerül a Bela érték.
else if(j.equals("c")){s="Cezar";} // Ha j tartalma egyenlő a c Stringgel, akkor s-be belekerül a Cezar név.
else if(j.equals("e")){s="Elemer";} // Ha j tartalma egyenlő az e Stringgel, akkor s-be belekerül az Elemer név.
else if(j.equals("f")){s="Ferenc";} // Ha j tartalma egyenlő az f Stringgel, akkor s-be belekerül a Ferenc keresztnév.
else if(j.equals("g")){s="Gergo";} // Ha j tartalma egyenlő a g Stringgel, akkor s-be belekerül a Gergo keresztnév.
System.out.println(s); // Kiíratódik a megadott betű alapján behasonlított keresztnév.
}
}
Hozzunk létre egy osztályt a Vez2 kettő mintájára, ami szintén egy parancssori paramétert vár. Ha a parancssori paraméter 0 és 3 illetve 5 és 9 közé esik, akkor írassuk ki a megfelelő ETO főosztályt! A többi esetre pedig végezzük el a szükséges hibakezeléseket!
public class Eto {
public static void main(String[] args) {
try { // a hibakezelési blokk kezdete. Hibakezelés csak mainben lehetséges.
String s; // String típusú változó deklarálása.
int j=Integer.parseInt(args[0]); // deklarálja az int típusú j változót, és ebben tárolja le az első parancssori paramétert, int típussá alakítva.
switch(j) { // a switch blokk kezdete a j változóra vonatkozóan.
case 0:s="Altalanos muvek";break; // a "case" kezeli a változó értékét. Ha j=0, akkor a String típusú s változóba az "Altalanos muvek" érték töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 1:s="Filozofia, pszichologia";break; // Ha j=1, akkor a String s-be a "Filozofia, pszichologia" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 2:s="Vallas";break; // Ha j=2, akkor a String s-be a "Vallas" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 3:s="Tarsadalomtudomanyok";break; // Ha j=3, akkor a Strig s-be a "Tarsadalomtudomanyok" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 5:s="Matematika, természettudományok";break; // Ha j=5, akkor a String s-be a "Matematika, természettudományok" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 6:s="Alkalmazott tudomanyok";break; // Ha j=6, akkor a String s-be az "Alkalmazott tudományok" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 7:s="Muveszetek, jatek, sport,";break; // Ha j=7, akkor a String s-be a "Muveszetek, jatek, sport" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 8:s="Nyelveszet, irodalom";break; // Ha j=8, akkor a String s-be a "Nyelveszet, irodalom" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 9:s="Regeszet, foldrajz, eletrajz, tortenelem";break; // Ha j=9, akkor a String s-be, a "Regeszet, foldajz, eletrajz, tortenelem" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
default:s="Nincs. Probalkozz 0 es 9 kozt, a 4 kivetelevel."; // A default akkor lép működésbe, ha az eddigi feltételek közül egyik sem volt igaz.
}
System.out.println("A szamhoz tartozo foosztaly: "+s); // Kiírja a megadott szöveget: "A szamhoz tartozo foosztaly: " majd az s segítségével a megadott számhoz tartozó String típusú változó értékébe betöltött szöveget.
}
catch(NumberFormatException e) { // A catch segítségével "elkapja" azokat a hibákat, amikor nem számot adunk meg értékként.
System.out.println("Szamot kerek fiam!"); // Ha a nem megfelelő formátumot adtuk meg, kiír egy általunk megadott hiba üzenetet, jelen esetben: Szamot kerek fiam!
}
catch(ArrayIndexOutOfBoundsException e){ //olyan hibákat kap el, amikor az az elem, amire hivatkoztunk az nem létezik a tömbben, illetve a tömbön kívüli elemre hivatkozunk.
System.out.println("Nem létező paraméter"); //Ha nem létező paraméterre hivatkozunk kiírja az általunk megadott hibaüzenetet.
}
catch(Exception e) { // Elkapja az összes hibát.
System.out.println("Irj be valamit, lehetoleg szamot!"); // Kiírja az általunk megadott szöveget, jelen esetben: Irj be valamit, lehetoleg szamot!
}
}
}
Típusok
A JAVA nyelvben különböző típusú változókat lehet deklarálni, melyekbe különböző formátumú adatokat lehet letárolni. A fontosabb típusok: byte: -128 és 127 között tárol értéket.
short: -32768 és 32767 között tárol értéket.
int: -2 a 31.-en és 2 a 31.-en-1 között tárol értéket.
long: -2 a 63.-on és 2 a 63.-on-1 között tárol értéket.
char: karaktereket tud tárolni.
boolean: igaz vagy hamis értéket tud tárolni.
float és double: különböző intervallumon képesen tizedes törteket tárolni.
String: Karaktersorozatot képes tárolni.
Hozzunk létre egy programot, amelyben az alábbi számokat (78 97 32 108 97 116 111 100 44 32 109 101 103 121 32 101 122 33) szigorúan ebben a sorrendben karakter típussá konvertáljuk majd kiíratjuk őket úgy, hogy vízszintesen egy darab értelmes mondat legyen olvasható! A feladat megoldásához használjunk tömböt!
public class Hf015 {
public static void main(String[] args) {
int tomb[]={78,97,32,108,97,116,111,100,44,32,109,101,103,121,32,101,122,33}; // int típusú tömb deklarálása és feltöltése a megadott számokkal.
for(int i=0;i<18;i++) { // for ciklus, mely 18-szor fut le, pont annyiszor ahány db számot megadtunk a tömbben.
System.out.print((char)tomb[i]); // karakter típussá konvertálja a tömbben megadott számokat, majd egy vízszintes sorban kiírja őket, és egy értelmes mondatot kapunk.
}
}
}
Tömbök, Véletlen szám generálás
A JAVA-ban a tömböket úgy kell elképzelni, mint egy nagy szekrényt sok-sok fiókkal. Ezek a fiókok mind fel vannak címkézve egy indexszel. Ezek a számok 0-tól a tömb mérete-1-ig vannak kiosztva. Így jön ki a tömb mérete. Minden egyes fiókban csak 1 elemet lehet tárolni. Ha a töb valamelyik elemére vagyunk kíváncsiak, akkor csak a megfelelő indexű tömbelemre kell hivatkoznunk.
ha véletlen számokat akarunk generálni egy adott intervallumon, akkor azt úgy tehetjük meg, hogy (int)(Math.random()*(felső intervallum-alsó intervallum)+1).
Hozzunk létre egy programot, amelyben két darab int típust tárolni képes, 10 férőhelyes tömböt töltünk fel véletlen számokkal! A véletlen számok generálásához az intervallum felső határát a parancssori paraméterről kérjük be! Ha megvannak a véletlen számok, akkor hozzunk létre egy harmadik, ezúttal 20 férőhelyes tömböt, majd az előző két tömb tartalmát másoljuk át bele egyetlen ciklussal! A szükséges sorrend: a[0] b[0] a[1] b[1]....a[9] b[9].
public class Hf016{
public static void main(String[] args){
int tomb1[]=new int[10];int tomb2[]=new int[10];int tomb3[]=new int[20]; // deklarálunk 3 tömböt, melyeknek megadjuk, hogy hány db számot tudnak tárolni. A tomb1 10, a tomb2 szintén 10, a tomb 3 20 férőhelyes tömb.
try{ // hibakezelés kezdete
int felso=Integer.parseInt(args[0]); // parancssori paraméter segítségével adjuk meg a felső határt.
for(int i=0;i<10;i++){ // for ciklus, mely 10-szer fut le.
System.out.print((tomb1[i]=(int)(((Math.random())*felso)+1))+" ");} // Egy lépésben tölti fel a tömböt 1 és a felső határ között generált számokkal, valamint ezeket ki is íratja.
System.out.println(""); // üres sor.
for(int i=0;i<10;i++){ // for ciklus, mely 10-szer fut le.
System.out.print((tomb2[i]=(int)(((Math.random())*felso)+1))+" "); // Egy lépésben tölti fel a tömböt 1 és a felső határ között generált számokkal, valamint ezeket ki is íratja.
}
System.out.println(""); // üres sor.
int j=0; // deklarál egy int típusú j változót, melynek kezdőértéke 0.
for(int i=0;i<20;i=i+2){ // ciklus ami 10-szer fut le, mert az i értékét nem egyesével hanem kettesével léptetjük.
System.out.print((tomb3[i]=tomb1[j])+" "+(tomb3[i+1]=tomb2[j])+" "); // a tömb3-ba belerak egy elemet a tömb1 és tömb2 tömbökből, majd kiírja ezt a két elemet.
j++;}}
catch(Exception e){System.out.println("Hiba");} // Elkapja az összes hibát, és ha talál, akkor kiírja a "Hiba" szöveget.
}
}
Egy parancssori paraméterről érkező Stringet tároljunk le karakterenként egy tömbbe, ami pontosan olyan hosszú, mint a String, majd írassuk ki a karaktereket egymás mellé szóközzel elválasztva! ( Tipp: .length() .charAt(index) ).
public class Hf017 {
public static void main(String[] args){
char[] tomb=new char[args[0].length()]; // karakter típusú tömb deklarálása, ami parancssori paraméterről érkező String hosszával megegyező számú elemet tud tárolni és tárol le karakterenként ebbe a tömbbe.
for(int i=0;i// for ciklus, ami addig nem lép ki, annyiszor nem futott le, mint a String karaktereinek a száma.
System.out.print((tomb[i]=args[0].charAt(i))+" ");} // Kiírja a tömbben letárolt karaktereket egymás mellé szóközökkel elválasztva.
}
}
Math osztály, Szövegfüggvények
A JAVA-ban a különböző, leggyakrabban használt matematikai függvények előre le vannak generálva és csak meg kell hívnunk őket a MAth osztály megfelelő függvényére hivatkozva. A legfontosabb függvények:
Math.round(): egészre kerekít.
Math.abs(): Abszolút értéket ad meg.
Integer.toBinaryString(): Egy egész decimális számot bináris számmá alakít és letárolja a karaktersorozatot Stringbe.
Integer.parseInt("1011",2): Egy megadott Stringet (első paraméter) átalakít decimális számmá a megadott számrendszer szerinti értelmezés alapján (második paraméter).
Math.sqrt(): Gyökvonás.
Math.pow(2,15): Hatványozás. Alap, kitevő paraméterekkel.
Math.random(): Véletlen szám generátor. Az alapérték 0-1 közötti érték, de az 1-et sohasem generálja le. Double típust generál.
Math.PI: A PI értékét tartalmazza. 3,14............
Math.E: Az e értékét tartalmazza.
Math.toRadians(): Fokban megadott számot radiánná alakít.
Math.sin(): Szinusz függvény.
Math.cos(): Koszinusz függvény.
Math.tan(): Tangens függvény.
Math.toDegrees(): Radiánt fokká alakít.
Math.log(): Logaritmus függvény.
A JAVA-ban a String típusú változókon speciális műveleteket tudunk végrehajtani bizonyos szövegfüggvények segítségével. Ezeket az adott változónév után írva tudjuk meghívni. A legfontosabbak:
.length(): Megmondja hány karakter hosszú az adott String. Fontos különbség a tömböknél vett .length-hez képest, hogy itt a függvény végére kell a ().
.charAt(): String egy megadott sorszámú karakterét adja vissza.
.trim(): Levágja a String elejéről és végéről a fölösleges whitespace-eket.
.indexOf(' ',i1): Adott karakter indexét adja vissza a Stringben. Az első paraméter az, hogy melyik karaktert keressük, a második pedig az, hogy hányadik karaktertől kell kezdeni a keresést.
Hozzunk létre egy programot, aminek van egy bemenő paramétere, ami egy szám (decimális)! Ezt a számot írjuk ki 8-as számrendszerben! (Tilos használni az Integer.toOctalString() parancsot!)A következő parancsokat érdemes használni: konvertálás és szövegfüggvények.
public class OktalisSZs{
public static void main(String[]args){
if(args.length<1){ // ha az ifben lévő feltétel teljesül - azaz a parancssori paraméterek száma kisebb, mint 1 - akkor belép az elágazásba.
System.out.println("Keves parameter"); // Ha teljesül a feltétel, kiírja a megadott szöveget: "Keves parameter"
System.exit(1); // megszakítja a program futását.
}
int a=Integer.parseInt(args[0]); // int típusú, a változóba a parancssori paraméterről kér értéket.
String s=Integer.toBinaryString(a); // String típusú s változóban tárolja le az a-ban megadott értéket, amelyet átalakít bináris számmá.
int db,i1,i2; // deklarál int típusú db, i1 és i2 változókat.
if(s.length()%3==0){db=(int)(s.length()/3);} // ha az s változó karaktereinek a hossza 3-mal való osztása után a maradék nulla, akkor a db változóba betöltődik az egész típusúvá kényszertett 3-mal való osztás eredménye.
else db=(int)(s.length()/3+1); // egyéb esetben a db értékbe az int típusúvá kényszerített 3-al való osztás eredménye +1.
System.out.println("A szam decimalisan: "+a); // Kiírja a számot decimálisan
System.out.println("A szam binarisan: "+s); // Kiírja a számot binárisan
System.out.println("Az okalis szam hossza "+db);// Kiírja az oktális szám hosszát.
int[] okt=new int[10]; // létrehoz egy 10 elemű, int típusú tömböt.
i1=s.length(); // az i1 értéke az s-ben letárolt bináris számmá alakított szám hosszát.
i2=i1-3; // i2 értéke: i1-ből kivonunk 3-at.
for(int i=db-1;i>=0;i--){ // for ciklus, ahol i az oktális szám karaktereinek száma-1-ről indul és 0-ig megy.
if(i2<0){i2=0;okt[i]=Integer.parseInt(s.substring(i2,i1),2);break;} // ha i2 értéke kisebb, mint 0, akkor az i2=0, és az okt tömbben betölti a parancssori paraméterről megadott változó i2 és i1 közötti alkaraktersorozat 2-es számrendszerből 10-es számrendszerbe való átalakítását.
else if(i1>i2){okt[i]=Integer.parseInt(s.substring(i2,i1),2);} // egyébként ha i1 nagyobb, mint i2, akkor is ugyanezt csinálja, mint az előző sorba csak nem írja felül i2-t 0-ra.
i1=i2; // i1-be betölti i2 értékét.
i2=i1-3; // i2-be betölti azt a számot, amit az i1-3 művelettel kapunk meg.
}
System.out.print("A szam oktalisan: "); // kiírja a megadott szöveget.
for(int i=0;i// for ciklus, mely db-vel megegyező értékszer fut le.
System.out.print(okt[i]); // kiírja az okt tömb elemeit.
}
System.out.println(""); // üres sor.
}
}
Hozzunk létre egy programot, ami három parancssori paramétert vár, ami 3 darab szám előjellel együtt (pl:a,b,c)! Ezek segítségével írassuk ki az "ax*xbxc=0" karaktersorozatot/másodfokú egyenletet! Majd hozzunk létre egy eljárást, ami kiszámítja az adott egyenlet megoldásait!
public class Egyenlet1SZs{
public static void main(String[]args){
if(args.length<3){ // Ha a parancssori paraméterek száma kisebb, mint 3, akkor belép a feltételbe.
System.out.println("Keves bemenet!"); // Kiírja, hogy "Keves bemenet!"
System.exit(1); // Kilép a ciklusból.
}
int a=Integer.parseInt(args[0]); // int típusú a változót deklarál, melynek értékét az első parancssori paraméter.
int b=Integer.parseInt(args[1]); // int típusú b változót deklarál, melynek értékét a második parancssori paraméter.
int c=Integer.parseInt(args[2]); // int típusú c változót deklarál, melynek értékét a harmadik parancssori paraméter.
int x1,x2; // int típusú x1 és x2 változót deklarált.
if(b>0 && c>0){System.out.println("Az egyenlet: "+a+"x*x"+"+"+b+"x"+"+"+c+"=0");} // ha az if-ben megadott feltétel teljesül - azaz b nagyobb mint nulla és c is nagyobb mint nulla, akkor kiírja a megadott szöveget.
else if(b>0 && c<0){System.out.println("Az egyenlet: "+a+"x*x"+"+"+b+"x"+c+"=0");} // ha nem teljesül az if-ben megadott feltétel, rálép az else if ágra, ahol ha a megadott feltétel teljesül - azaz b kisebb mint nulla és c nagyobb mint nulla - akkor kiírja a megadott szöveget.
else if(b<0 && c>0){System.out.println("Az egyenlet: "+a+"x*x"+b+"x"+"+"+c+"=0");} // ha nem teljesül az előző ágban a feltétel, rálép a második else if ágra, ahol ha a megadott feltétel teljesül - azaz b kisebb mint nulla és c nagyobb mint nulla - akkor kiírja a megadott szöveget.
else System.out.println("Az egyenlet: "+a+"x*x"+b+"x"+c+"=0"); // ha egyik előző feltétel sem teljesül, akkor az else ágban kiírja a megadott szöveget.
if((Math.pow(b,2)-4*a*c)<0){ // ha bnégyzet mínusz 4*a*c kisebb mint nulla, akkor belép a feltételbe
System.out.println("Az egyenletnek nincs megoldasa"); // kiírja, hogy "Az egyenletnek nincs megoldása"
System.exit(1); // kilép a programból.
}
x1=(int)(-b+(Math.sqrt(Math.pow(b,2)-4*a*c)))/(2*a); // a fentebb deklarált x1-be értékül adja a matematikai gyökfüggvény (Math.sqrt) és a négyzetre emelés (Math.pow) segítségével kiszámolt másodfokú egyenlet egyik eredményét.
x2=(int)(-b-(Math.sqrt(Math.pow(b,2)-4*a*c)))/(2*a); // ugyan azt csinálja, mint az x1-ben, csak itt a -b után a számítás értékét nem hozzáadja, hanem kivonja.
System.out.println("x1= "+x1); // kiírja az x1 értékét.
System.out.println("x2= "+x2); // kiírja az x2 értékét.
}
}
Szövegfüggvények és matematika függvények gyakorlása
1.feladat: Hozzunk létre egy programot, ami egy Stringet vár parancssori paraméterről! Feladat, hogy ennek a Stringnek a karaktereit fordított sorrendben jelenítsük meg. (pl alma->amla)
public class Hf021 {
public static void main(String[] args){
char[] tomb=new char[args[0].length()]; // karakter típusú tömb deklarálása, mely az első parancssori paraméter hosszával megegyező számú elemet képes letárolni.
for(int i=args[0].length()-1;i>=0;i--){ // for ciklus, amely anyiszor fut le, amilyen hosszú az első parancssori paraméter.
System.out.print((tomb[i]=args[0].charAt(i)));} // A tomb i-ik értékébe berakja az első parancssori paraméter i-ik karakterét.
System.out.println(); // üres sor
System.out.println(); // üres sor.
for(int t=0;t// for ciklus, amely anyiszor fut le, amilyen hosszú az első parancssori paraméter.
System.out.print(tomb[t]); // kiírja a tömb t elemét.
}
System.out.println(); // üres sor.
System.out.println(); // üres sor.
for(int i=args[0].length()-1;i>=0;i--){ // for ciklus, amely anyiszor fut le, amilyen hosszú az első parancssori paraméter.
System.out.print((tomb[i]=args[0].charAt(args[0].length()-i-1)));} //kiíratja és értékül adja a tomb i-ik érétkének azt a karaktert, ami a parancssori paraméternek annyiadik karaktere, mint a parancssori paraméter hosszából kivonva az i-t és még 1-et.
System.out.println(); // üres sor.
System.out.println(); // üres sor.
for(int p=0;p// for ciklus, amely anyiszor fut le, amilyen hosszú az első parancssori paraméter.
System.out.print(tomb[p]); // kiíratjuk a tömb tartalmát.
}
}
}
Hozzunk létre egy programot, ami egy Stringet vár parancssori paraméterről! Vizsgáljuk meg karakterenként az adott Stringet és a mássalhangzókat cseréljük benne nagy betűkre!
public class Hf022 {
public static void main(String[] args){
char[] tomb=new char[args[0].length()]; // karakter típusú tömb deklarálása, mely az első parancssori paraméter hosszával megegyező számú elemet képes letárolni.
for(int i=0;i// belép a for ciklusba addig, amíg i kisebb mint a bemenő parancssori paraméter hossza
tomb[i]=args[0].charAt(i); // a tomb-öt feltölti a parancssori paraméter karaktereivel.
if("aeiou".indexOf(tomb[i])<0){ // megkeresi az aeiou karakterek előfordulását a tömbön belül, és ha az kisebb, mint nulla, akkor
tomb[i] = Character.toUpperCase(tomb[i]);} // e sor segítségével a mássalhangzókat kisbetűről nagybetűre írja át.
System.out.print(tomb[i]);} // kiírja a tömbben megadott karakterláncot az átalakított formában.
}
}
3.feladat: Hozzunk létre egy programot, ami egy Stringet vár parancssori paraméterről! Vizsgáljuk meg, hogy az adott karaktersorozat átalakítható-e 16-os számrendszerbe! (Csak 0-9-ig és a-f-ig tartalmaz karaktereket.) Majd ha lehetséges, konvertáljuk is át, ha nem, akkor írassunk ki valami ezzel kapcsolatos szöveget!
public class Hf023 {
public static void main(String[] args){
try{ // hibakezelő blokk kezdete
for(int i=0;i// for ciklus kezdete
if(Character.isDigit(args[0].charAt(i))||!("abcdef".indexOf(args[0].charAt(i))<0)){ //ha a kapott karakter szám vagy valamilyen abcdef karakter, akkor lehetséges az átkonvertálás
System.out.print("atalakithato, az erteke " + Integer.parseInt(args[0],16)+" ");} //kiírja a megadott szöveget és kiírja az egész típusú számmá kényszerített értéket 16-os számrendszerben.
else System.out.println("nem atalakithato");break;}} // ha nem teljesül az ifben megadott feltétel, akkor kiírja, hogy nem atalakithato és kilép a break-el.
catch(Exception e){ // hibakezelés
System.out.println(e);} // kiírja a hibát.
}
}
4.feladat: Hozzunk létre egy programot, amiben egy 10 elemű, csupa 0-val feltöltött tömböt generálunk! A parancssorról egy számot(x) várunk 1 és 10 között. Feladat, hogy kicseréljünk x darab számot 0 és x között generált véletlen számokkal!
public class Hf024 {
public static void main(String[] args){
int tomb[]=new int[10]; // int típusú tömb legenerálása ,amely 10 elemet képes tárolni.
for(int i=0;i<10;i++){ // for ciklus, mely 10-szer fut le
tomb[i]=0;} // a tömb feltöltése a 0-val.
try{ // hibakezelés kezdete
int x=Integer.parseInt(args[0]); // int típusú x változó deklarálása, melynek értéket a parancssori paraméterről kapunk.
if(x<1||x>10){ // akkor lép a program az elágazásba, ha teljesül az a feltétel, hogy x kisebb, mint 1, vagy x nagyobb, mint 10.
System.out.println("1 es 10 kozotti szamot adj."); // ha az előző feltétel teljesül, akkor kiírja, hogy "1 és 10 kozotti szamot adj."
System.exit(1);} // majd kilép a programból.
for(int i=0;i// for ciklus kezdete, mely x-szer fut le.
System.out.print("kicsereltuk a "+i+". helyen: "+tomb[i]+"-t "); // kiírja, hogy hányadik helyen, melyik számot cseréljük majd ki.
tomb[i]=(int)(Math.random()*x)+1; // a tömbnek értékül adja az int - azaz egész - típussá konvertált random számot, amit a 1-x intervallumon generáltunk.
System.out.println(tomb[i]+"-re.");}} // kiírja, hogy mire cseréltük ki a fentebb megadott értéket.
catch(Exception e){ // elkapja az összes hibát.
System.out.println(e);}} // kiírja a talált hibát.
}
Rendezések, Keresések
A JAVA-ban is használnak különböző keresési és rendezési algoritmusokat. Ezekkel sajnos nem lehet mást tenni csak szóról szóra-sorról sorra megtanulni őket.
Hozzunk létre egy programot, amivel egy parancssori paraméterről érkező String elemeit karakterenként letároljuk egy tömbbe! Ezt követően rendezzük a karaktereket növekvő sorrendben! Tipp: Számmá konvertálás és vissza.
public class Hf025 {
public static void main (String[] args){
char[] str = new char[args[0].length()]; // karakter típusú tömb deklarálása, mely az első parancssori paraméter hosszával megegyező számú elemet képes letárolni.
int[] str1 = new int[args[0].length()]; // int típusú tömb deklarálása, mely az első parancssori paraméter hosszával megegyező számú elemet képes letárolni.
for(int i=0;i// for ciklus kezdete
str[i]=args[0].charAt(i); // a str tömb értékét karakterré alakítja át.
str1[i]=(int)str[i]; // típuskényszerítéssel intté alakítja át a str tömb elemeit.
System.out.print(str[i]);} // kiírja a str tömb elemeit.
System.out.println(); // üres sort ír ki.
int j; // deklarál egy int típusú j változót.
for(int i=0;i// for ciklus ami a parancssori paraméter-1-szer fut le
for(int k=i+1;k// for ciklus ami a parancssori paraméter-1-szer fut le
if(str1[i]>str1[k]){ // ha a tömb i.-ik elem kisebb, mint a k.-ik akkor belép az elágazásba
j=str1[k];str1[k]=str1[i];str1[i]=j;}}} // megcseréli a két elem értékét
for(int i=0;i// for ciklus ami a parancssori paraméterszer fut le
System.out.print(str[i]=(char)str1[i]);} // kiírja az értékeket karakterré kényszerítve
Hozzunk létre egy programot, amivel feltöltünk egy 15 elemű tömböt 1 és 10 közötti számokkal véletlenszerűen. Számoljuk meg és írassuk ki, hogy melyik számból mennyi van a tömbben!
public class Hf026 {
public static void main(String[] args){
int[] tomb = new int[15]; // int típusú tömb deklarálása, mely 15 elemet képes tárolni
for(int i=0;i<15;i++){ // for ciklus, mely 15ször fut le.
System.out.print((tomb[i]=(int)(Math.random()*10)+1)+" ");} // Kiírja az int típusúvá kényszerített random számot, amit 1-10 intervallumon generáltunk.
System.out.println(); // üres sor.
for(int i=1;i<=10;i++){ // for ciklus, mely 10szer lefut.
int x=0; // int típusú x elem deklarálása, melynek értéke 0.
for(int j=0;j<15;j++) // for ciklus, mely 15ször fut le.
if(i==tomb[j]) x++; // ha i egyenlő j értékével, akkor növeli x értékét egyel.
System.out.println(x+" db " +i );} // kiírja, hogy x db van i számból.
}
}
Rendezések, Beolvasás billentyűzetről
JAVA-ban a LineNumberReader segítségével lehetőségünk van rá, hogy futás közben a billentyűzetről értékeket olvassunk be.
1.feladat: Hozzunk létre egy programot, amelyben a readLine() segítségével beolvasunk 5 számot! Ezeket a számokat tároljuk le egy tömbbe, majd írassuk ki a tömb tartalmát. (int típusú tömböt használjunk)
import java.io.*; // importáljuk a java.io csomagot.
public class Laoms3{
public static void main(String[] args) throws IOException { //létrehozzuk a main-t, de figyelmen kívül hagyunk minden lehetséges IO hibát.
LineNumberReader in=new LineNumberReader(new InputStreamReader(System.in)); // ez a sor kötelező, ha sorokat akarok bevinni a billentyűzetről.
System.out.print("? "); // kiírja a kérdőjelet.
String s=in.readLine(); // string típusú s változó deklarálása, melynek értéke a sorból van megadva.
int[] szamok=new int[5]; // int típusú szamok tömb létrehozása, melynek öt eleme van.
for(int i=0;i<5;i++){ // for ciklus, mely ötször fut le.
szamok[i]=Integer.parseInt(s); // szamok tömb, melyben a string típusú s értékét intté kényszerít át.
System.out.print("? "); // kérdőjelet ír ki.
s=in.readLine(); // s-nek értéket ad, mely a megadott sorból van.
}
System.out.println("A beolvasott szamok: "); // kiírja a megadott szöveget
for(int i=0;i<5;i++){
System.out.print("\t"+szamok[i]); // kiírja a szamok tömb tartalmát
}
}
}
Hozzunk létre egy programot, amelyben két változót feltöltünk 0 és 50 közötti véletlen generált számokkal! Töltsünk fel egy tíz elemű tömböt úgy, hogy random segítségével döntsük el, melyik kerül be az adott indexre! (0-1 intervallumon generáljunk számokat a tömbbe! Ha 0, akkor az első szám, ha 1, akkor a második kerüljön az adott indexre!)
public class Laoms4{
public static void main(String[]args){
int a=(int)(Math.random()*51); // int típusú random szám generálása 0 és 50 között, az int típusú a változóba.
int b=(int)(Math.random()*51); // int típusú random szám generálása 0 és 50 között, az int típusú b változóba.
int[] tomb=new int[10]; // 10 elemű, int típusú tömb deklarálása.
System.out.println("a="+a); // kiírja az a értékét.
System.out.println("b="+b); // kiírja a b értékét.
for(int i=0;i<10;i++){ // for ciklus, mely 10szer fut le.
tomb[i]=(int)(Math.random()*2); // int típusú random számok generálása, 0-1 intervallumon.
}
for(int i=0;i<10;i++){ // for ciklus, mely 10szer fut le.
System.out.print("tomb["+i+"]="+tomb[i]+"\t"); // kiírja a tömb tartalmát.
}
System.out.println(""); // üres sor
System.out.println(""); // üres sor
for(int i=0;i<10;i++){ // for ciklus, mely 10szer fut le.
if(tomb[i]==0){tomb[i]=a;} // ha a tömb eleme egyenlő nullával, akkor a tömb értéke egyenlő lesz a értékével.
else{tomb[i]=b;} // egyébként a tömb eleme egyenlő lesz a b értékével.
}
for(int i=0;i<10;i++){
System.out.print("tomb["+i+"]="+tomb[i]+"\t"); // kiírja, hogy az adott szám melyik indexre kerül be.
}
}
}
Fájlkezelés, Stringek rendezése
JAVA-ban képesek vagyunk fájlok tartalmát is kiolvasni a LineNumberReader-rel.
A Stringek rendezésére speciális függvényt hívünk segítségül. A .compareTo()-t. Egy String típusú változóra tudjuk meghívni egy másik típusú változóval paraméterként. Ha a forrás változó kisebb, mint a paraméterben megadott szöveg, akkor negatív eredményt ad vissza. Fordított esetben pozitívat.
1.fealdat: Hozzunk létre egy programot, amivel kiolvassuk egy txt tartalmát és soronként visszaadjuk.
import java.io.*;
public class Fajl{
public static void main(String[] args) throws IOException {
LineNumberReader in=new LineNumberReader(new InputStreamReader(new FileInputStream("szoveg.txt"))); //Az adott nevű és kiterjesztésű fájlból kiolvassa a biteket, majd bináris kóddá alakítja, majd szöveggé.
String s; //s változó deklarálása
s=in.readLine(); //string típusú s változó deklarálása, melynek értéke a sorból van megadva.
while(s!=null) { //ha s nem üres, akkor
System.out.println("\t"+in.getLineNumber()+". sor = "+(s.length()>0?s:"(ures sor)")); //lekéri az adott sor számát. Ha van benne szöveg kiírja a tartalmát, ha nem akkor azt hogy üres sor.
s=in.readLine(); //s értékét felülírja a következő soréval.
}
in.close(); //bezárja a megnyitott fájlt.
}
}
Hozzunk létre egy programot, amiben a parancssori paraméterről kérünk három Stringet és ezeket rendezett sorrendben kiírja azokat.
public class String4 {
public static String min(String s,String t) {
return (s.compareTo(t)<0 ? s : t);
}
public static String max(String s,String t) {
return (s.compareTo(t)>0 ? s : t);
}
public static void main(String[] args) {
if (args.length<=2) {
System.out.println("Maskor adjon meg harom parancssori parametert!");
System.exit(1);
}
String s,t,u;
s=min(args[0],args[1]);
t=max(args[0],args[1]);
u=args[2];
System.out.println("A legkisebb parameter: "+min(s,u));
System.out.println("A legnagyobb parameter: "+max(t,u));
}
}
Karakterkészlet
A program forrásszövegének legkisebb alkotórészei a karakterek.
Az UNICODE 16 bites kódtáblára épül, ahol betű minden nyelv betűje lehet. Tartalmazza az összes nemzetközi abc-t. Megkülönbözteti a kis-és nagybetűt.
Kategóriák:
· betűk (minden nyelv betűje)
· számjegyek (0-9 decimális számjegy)
· egyéb karakterek (műveleti jelek, elhatároló jelek, írás jelek, speciális karakterek)
Szimbolikus nevek
Azonosító
Olyan karaktersorozat, amely betűvel kezdődik, és betűvel vagy számjeggyel folytatódhat. Arra használjuk, hogy a programozói eszközeinket megnevezzük vele, és ezután bárhol a program szövegében hivatkozhassunk rá. Betűnként nem csak a nemzeti karaktereket, hanem az _ és $ jelet is használhatjuk.
Azonosító képzési szabályok:
· Az azonosító bármilyen hosszú Javában használható unikód karaktersorozat lehet
· Egy azonosító nem kezdődhet számjeggyel, nem lehet kulcsszó, és nem lehet a nyelv egy előre definiált konstansa (true, false vagy null).
· Két azonosító csak akkor egyezik meg, ha unikód karaktereik rendre megegyeznek.
Példák az azonosítóra:
Szabályos Java azonosítók:
Nem azonosítók:
x
x+y
ár x*y+3
diak_kod
12öt
Néhány gyakorlati hasznos tanács az azonosítók készítéséhez:
· Próbáljunk meg jól olvasható, beszédes azonosítókat választani! (minSebesseg, karakterekSzama)
· Az osztályok azonosítóját nagybetűvel kezdjük. (Emberek,Diákok)
· A változók és metódusok azonosítóját kisbetűvel kezdjük. (szám, darab)
· A konstansokat csupa nagybetűvel írjuk. (ALAPAR)
· Az azonosítókat úgy tagoljuk, hogy az összetett szavak kezdőbetűit nagybetűvel, a többit kisbetűvel írjuk. (maxSebessegHatar)
Kulcsszó
Olyan karaktersorozat, amelynek az adott nyelv tulajdonít jelentést, és ez a jelentés a programozó által nem megváltoztatható.
A java kulcsszavai a következők:
abstract
default
if
package
transient
boolean
do
implements
private
try
break
double
import
protected
void
byte
else
instanceof
public
volatile
case
extends
int
return
while
catch
final
interface
short
synchronized
char
finally
long
static
this
class
float
native
super
throw
continue
for
new
switch
throws
A const és a goto szintén foglalt szó, de nincs implementálva, egyik sem használatos.
Címke
A végrehajtható utasítások megjelölésére szolgál, bármely végrehajtható utasítás megcímkézhető. Azért alkalmazzuk, hogy a program egy másik pontjáról hivatkozni tudjunk rá.
A címke egy azonosító, az utasítás előtt áll kettősponttal elválasztva.
Szintaktika:
cimke: { }, vagy cimke: utasítás
A címkét a break vagy a continue paranccsal együtt használjuk úgy, hogy megadjuk a parancs után azt, hogy melyik egységre vonatkozik.
Példa:
Megjegyzések
A megjegyzés olyan programozási eszköz, amely arra szolgál, hogy a program írója a kód olvasójának valamilyen információt szolgáltasson.
A megjegyzést a forrásszövegben háromféle módon helyezhetjük el:
· //-től sorvégig megjegyzés.
· /* */ zárójelek között tetszőleges hosszan.
· /** */ dokumentációs megjegyzés. A fejlesztőkörnyezet segítségével automatikusan lehet generálni hypertext (HTML) dokumentációt, ami felhasználja a dokumentációs megjegyzéseket is. (Run > Generate Javadoc (Projekt név))
Példa a megjegyzésekre:
Literálok
A literál olyan programozási eszköz, amelynek segítségével fix, explicit értékek építhetők be a program szövegébe. Két komponense van: típus és érték.
Fajtái:
· egész: egy pozitív vagy negatív egész szám, vagy nulla.(pl. +200, -3, 1256987)
· valós: egy tizedesekkel leírható szám. Két formában adható meg: tizedes forma és lebegőpontos forma (pl. 6.32, 100.0, 0.0006, 6.3E2, 5E-4)
· logikai: két logikai konstans létezik, a true (igaz) és a false (hamis).
· karakter: egy unicode karakter (szimpla aposztrófok közé tesszük). (pl. 'a', 'B')
· szöveg: akármilyen hosszú, unicode karakterekből álló sorozat (idézőjelek közé tesszük).
(pl. "Szia")
· null
Változó
A programok adatokon végeznek különféle manipulációkat, ezek az adatok a program futása alatt változtatják értéküket. A kezdeti adatokat a program eltárolja a változókba, az értékek az algoritmusnak megfelelően módosulnak a program futása folyamán. Az algoritmus végén a változó a végeredmény értékével rendelkezik.
A változó olyan adatelem, amely azonosítóval van ellátva. Az egyik legfontosabb programozási eszközünk.
A változókat használat előtt deklarálni kell. Ez azt jelenti, hogy meg kell adni a típusát, nevét, esetleg értékét is. Amikor egy változónak kezdeti értéket adunk, akkor a változót inicializáljuk.
pl. byte a; int x = 0;
Egy változót a program tetszőleges részén deklarálhatunk.
A változó érvényességi tartománya a programnak az a része, ahol a változó használható. A változódeklaráció helye határozza meg az érvényességi tartományt.
A változó lehet (A deklarálás helyétől függően.):
· tagváltozó: Az osztály vagy objektum része, az osztály egészében látható (alkalmazható). Az osztály változók deklarálásánál a static kulcsszót kell használni.
· lokális változó: Egy kódblokkon belül alkalmazzuk. A láthatósága a deklaráció helyétől az őt körülvevő blokk végéig tart.
· A metódusok formális paraméterei az egész metóduson belül láthatók.
· A kivételkezelő paraméterek hasonlók a formális paraméterekhez.
Példa a változókra:
A változót lehet véglegesen is deklarálni (konstans változó), a végleges változó értékét nem lehet megváltoztatni az inicializálás után.
A végleges változók deklarációnál a final kulcsszót kell használni:
pl. final int aKonstans = 0;
Kifejezések (operandusok és operátorok)
A kifejezések szintaktikai eszközök, arra valók, hogy a program egy adott pontján ismert értékekből új értékeket határozzunk meg. Két komponense van típus és érték.
Alapvetően kétféle feladata van: végrehajtani a számításokat, és visszaadni a számítás végeredményét.
Összetevők:
· Operandusok: Az értéket képviselik. Lehet literál, nevesített konstans, változó vagy függvényhívás az operandus.
· Operátorok: Műveleti jelek (pl. *, /, +, -).
· Kerek zárójelek: A műveletek végrehajtási sorrendjét befolyásolják.
Példa a kifejezésre:
a
+
sin(0)
Operandus
Operátor
Operandus
Attól függően, hogy egy operátor hány operandussal végez műveletet, beszélhetünk:
· egyoperandusú (unáris pl. (+2)),
· kétoperandusú (bináris pl. (2+3)) vagy
· háromoperandusú (ternáris pl. (a*b*c)) operátorokról.
Operátorok:
(Az operanduson hajtanak végre egy műveletet.)
Aritmetikai operátorok: Alapvető matematikai műveletek végzésére használjuk őket.
+ (összeadás),
- (kivonás),
* (szorzás),
/ (osztás),
% (maradékképzés).
Példa az aritmetikai operátorok használatára:
Implicit konverzió: Amikor egy aritmetikai operátor egyik operandusa egész a másik pedig lebegőpontos, akkor az eredmény is lebegőpontos lesz. Az egész érték implicit módon lebegőpontossá konvertálódik, mielőtt a művelet végrehajtódna.
Példa: Egy egész számot osztunk egy valós számmal, a végeredmény automatikusan valós lesz.
A konverziót ki is "kényszeríthetjük" explicit konverzióval. A programozó ebben az esetben a kifejezés értékére "ráerőltet" egy típust.
Szintaxis:
(<típus>) <kifejezés>
Példa:
6/4 >> eredmény: 1 (Itt két egész számot osztottunk egymással.)
(double) 6/4 >> eredmény: 1.5
Relációs operátorok: Összehasonlítanak két értéket, és meghatározzák a köztük lévő kapcsolatot.
> (nagyobb),
>= (nagyobb vagy egyenlő),
< (kisebb),
<= (kisebb vagy egyenlő),
= = (egyenlő),
! = (nem egyenlő).
Példa a relációs operátorok használatára:
Logikai operátorok:
&& (logikai és),
|| (logikai vagy),
! (logikai nem),
& (bitenkénti és),
| (bitenkénti vagy),
^ (bitenkénti nem),
~ (Bitenkénti tagadás (negáció)).
Példa a logikai operátorok használatára:
Léptető operátorok: A léptető operátorok bitműveleteket végeznek, a kifejezés első operandusának bitjeit jobbra, vagy balra léptetik.
<< (op1 << op2; op1 bitjeit op2 értékével balra lépteti, jobbról nullákkal tölti fel)
>> (op1 >> op2; op1 bitjeit op2 értékével jobbra lépteti, balról a legnagyobb helyértékű bitet tölt fel)
>>> (op1 >>> op2; op1 bitjeit op2 értékével jobbra lépteti, balról nullákkal tölt fel)
Értékadó operátorok
= Alap értékadó operátor, arra használjuk, hogy egy változóhoz értéket rendeljünk.
Rövidített értékadó operátorok: + =, - =, * =, / =, % =, & =, | =, ^ =, << =, >> =, >>> = (pl. i = i + 1; rövidítve: i + = 1;)
Példa az értékadó operátorok használatára:
Egyéb operátorok:
? : Feltételes operátor.
[ ] Tömbképző operátor.
. Minősített hivatkozás.
new Új objektum létrehozása.
A kifejezés alakja lehet:
· prefix: Az operátor az operandusok előtt áll (* 2 5).
· infix: Az operátor az operandusok között áll (2 * 5).
· postfix: Az operator az operandusok mögött áll (2 5 *).
Azt a folyamatot, amikor a kifejezés értéke és típusa meghatározódik, a kifejezés kiértékelésének nevezzük. A kiértékelés során adott sorrendben elvégezzük a műveleteket, előáll az érték, és hozzárendelődik a típus.
A Javában a következő módon megy végbe a kiértékelés:
· Zárójelezéssel meghatározhatjuk, hogy egy kifejezés hogyan értékelődjön ki.
pl. (x + y) / 2 Először a zárójelben szereplő kifejezés hajtódik végre.
· Ha nem jelezzük, hogy milyen sorrendben akarjuk, az összetett kifejezést kiértékelni, akkor a sorrendet az operátorok precedenciája fogja meghatározni. A magasabb precedenciával rendelkező operátorok hajtódnak végre elsőként.
· pl. x + y / 2 Ebben a kifejezésben, mivel az osztás precedenciája magasabb mint az összeadásé, ezért először ez hajtódik végre, majd az összeadás következik. A következő kifejezés egyenértékű vele:
x + (y / 2).
Operátor precedencia szintek:
postfix expr++ expr--
unáris ++expr --expr +expr -expr ~ !
multiplikatív * / %
additív + -
léptetés << >> >>>
relációs < > <= >= instanceof
egyenlőség = = !=
bitenkénti és &
bitenkénti kizáró vagy ^
bitenkénti vagy |
logikai és & &
logikai vagy | |
feltételes ? :
értékadás = += -= *= /= %= &= ^= |= <<= >>= >>>=
A táblázat a Java platformon használt operátorok precedencia szintjeit mutatja be. Az operátorok precedencia szint szerint vannak rendezve, mégpedig úgy, hogy legfelül a legnagyobb precedenciájú, legalol a legkisebb precedenciájú található. Az azonos szinten elhelyezkedő operátorok azonos precedenciával rendelkeznek. Ha azonos precedenciájú operátorok szerepelnek egy kifejezésben, akkor balról jobbra történik a végrehajtás, kivéve az értékadó operátorokat, amelyek jobbról balra hajtódnak végre.
Azt a kifejezést, amelynek értéke fordítási időben eldől konstans kifejezésnek nevezzük. Létrehozására a final módosítót használjuk, így érjük el, hogy az adattag értékét nem változtathatja meg senki.
pl. final double PI: Pi értékét jelenti.
Deklarációs és végrehajtható utasítások
A deklarációs utasítások mögött nem áll tárgykód. A programozó a névvel rendelkező saját programozási eszközeit tudja deklarálni.
pl. int i=10;
A végrehajtható utasításokból generálja a fordító a tárgykódot.
Melyek ezek?
· Üres utasítás (pl. ;)
· Kifejezés utasítás (pl. 8; a = b;)
· Vezérlő utasítások (szekvencia, feltételes utasítás, többszörös elágaztatás, ciklusok, vezérlésátadó utasítások)
· Módszerhívások (metódushívások)
· Objektumot létrehozó kifejezések
Alprogramok
A programot célszerű kisebb egységekre (alprogram) bontani, melyeket a program bizonyos pontjairól aktivizálhatunk. Így áttekinthetőbbé, olvashatóbbá válik a forrásprogram, valamint a többször előforduló tevékenységeket elegendő egyszer megírni (elkészíteni).
A Javaban metódusnak nevezzük az alprogramot. A metódus utasítások összessége, melyet meghívhatunk a metódus nevére való hivatkozással.
Egy metódus lehet eljárás vagy függvény aszerint, hogy van-e visszatérési értéke.
Eljárás
Az eljárásnál nincsen visszatérési érték, egyszerűen végrehajtódik az eljárás nevére való hivatkozással. A végrehajtás után a program azzal az utasítással folytatódik, amelyik az eljárást meghívó utasítást követi. Az eljárás visszatérési típusa void (semleges), ami azt jelenti , hogy a visszatérési típus nincs definiálva.
Példa az eljárásra:
(Az eljárás egy vonalat "rajzol" a képernyőre.)
Függvény
A függvénynél van visszatérési érték. A függvényt is egyszerűen a nevére való hivatkozással hívunk meg, de visszaad egy értéket, melyet a függvény neve képvisel.
Példa a függvényre:
(A függvény megduplázza az x változó értékét.)
Blokk
A blokk nulla vagy több utasítás kapcsos zárójelek között, amely használható bárhol, ahol az önálló utasítások megengedettek.
Jellemzői:
· { } zárójelek között szerepel.
· Címkézhető.
· Tetszőleges mélységben egymásba skatulyázható.
· A változó a blokk lokális változójaként deklarálható.
· A blokkon belül tetszőleges a deklarációs- és végrehajtható utasítások sorrendje.
A JAVA programozásban megtalálhatók a változók, ciklusok, és a main eljárás is. A JAVA-ban az általunk létrehozott programokat osztályokban alkotjuk meg. Ezeket a "public class Osztalynev" paranccsal tudjuk megalkotni. Ahol a public a láthatóságot, a class az osztály típust adja meg. Az Osztalynev név tetszőlegesen módosítható. Pár alapvető szabályra kell odafigyelni. Mindig nagy betűvel kezdődik, az angol ábécé betűit lehet használni, és nem lehet az osztálynévben szóköz. A láthatóság a mi szempontunkból nem igazán lényeges. Ha minden esetben public-ot használunk nem lesz belőle gond. A JAVA-ban a while, do while és for ciklusok ugyanúgy működnek, mint a C-ben szóval azokra nem térek ki külön. A main annyiban különbözik a C-hez képest, hogy megköveteli a láthatóságot a statikusságot és a void visszatérési típust. A main megadása mindig a példaprogramban látható módon történik, kötelezően.
1.feladat: A Fibonacci számsor első 10 elemének kiíratása for ciklus segítségével. Az első két elemet ki lehet íratni a cikluson kívül is, de a többit már csak cikluson belül.
public class Fibonacci { // osztály létrehozása.
public static void main(String[] args) { //main eljárás létrehozása
int a, b; // egy a és egy b int(egész) típusú változó deklarálása
a=0; // a 0 értéket adja meg az "a" nevű változónak.
b=1; // az 1 értéket adja meg a "b" nevű változónak.
System.out.println(a);// kiírja az "a" értékét.
System.out.println(b);// kiírja a "b" értékét.
for(int i=0;i<4;i++){ // 4-szer lefutó for ciklus blokkjának kezdete.
a=a+b; // a értékét módosítja a+b-re
System.out.println(a);// kiírja az a aktuális értékét.
b=a+b; // b értékét módosítja a módosított a+b értékére.
System.out.println(b); //kiírja b aktuális értékét.
} //for ciklus blokkjának vége
} //main eljárás vége
} //osztály bezárása
2.
Eljárások
A JAVA-ban az eljárások egy előre meghatározott utasítássorozatot hajtanak végre úgy, hogy a main-en kívül megírjuk az eljárást, majd a main-en belül meghívjuk azt a nevén keresztül az aktuális paramétereivel, amennyiben vannak neki. Hasonlóan, mint a C nyelvben. Fontos tudni az eljárásokról, hogy a generálásukkor a visszatérési típusok mindig void és az utasítássorozat végén nem tartalmaznak return sort, tehát technikailag nem adnak vissza semmilyen értéket.
1.feladat: A program tartalmazzon 4 eljárást, melyek egyenként 2-2 bemeneti paraméterrel rendelkeznek és ezeken végzik el a 4 matematikai alapműveletet, aminek az eredményét ki is írják a képernyőre. (Tehát kell egy összeadás, egy kivonás, egy szorzás és egy osztás eljárás.) Végül pedig a main eljárásban hívjuk meg ezeket az eljárásokat, lehetőleg olyan értékellek, amelyeknek az eredménye fejben is könnyen kiszámolható. Valamint figyeljünk arra, hogy az osztásnál tizedes tört legyen az eredmény.
public class Muveletek{ // osztály létrehozása.
public static void ossze(int a,int b){ //statikus eljárás, üres visszatérési típussal. rendelkezik két int típusú bemenő paraméterrel.
int x; // x deklarálása.
x=a+b; // x értékének megadása a+b-vel (a két bemenő paraméterrel).
System.out.println(x); // kiírja x aktuális értékét.
}
public static void kivon(int c,int d){ //statikus eljárás, üres visszatérési típussal. rendelkezik két int típusú bemenő paraméterrel.
int y; // y deklarálása.
y=c-d; // y értékének megadása úgy, hogy c bemenő paraméter értékéből kivonja d bemenő paraméter értékét.
System.out.println(y); // kiírja y aktuális értékét.
}
public static void szorzas(int e,int f){ //statikus eljárás, üres visszatérési típussal. rendelkezik két int típusú bemenő paraméterrel.
int z; // z deklarálása.
z=e*f; // z értékének megadása úgy, hogy e paraméter értékét megszorozza az f bemenő paraméter értékével.
System.out.println(z); // kiírja z aktuális értékét.
}
public static void osztas(double g,double h){ //statikus eljárás, üres visszatérési típussal. rendelkezik két double (lebegőpontos) típusú bemenő paraméterrel.
double u; // u deklarálása.
u=g/h; // u értékének megadása úgy, hogy g bemenő paraméter értékét elosztja a h bemenő paraméter értékével.
System.out.println(u); // kiírja az u aktuális értékét.
}
public static void main(String [] args){ //main eljárás.
ossze(4,5); // az ossze nevű eljárás meghívása, a zárójelben a két bemenő paraméter.
System.out.println(""); // üres sort ír ki.
kivon(4,5); // a kivon nevű eljárás meghívása, a zárójelben a két bemenő paraméter.
System.out.println(""); // üres sort ír ki.
szorzas(4,5); // a szorzas nevű eljárás meghívása, a zárójelben a két bemenő paraméter.
System.out.println(""); // üres sort ír ki.
osztas(3.0,2.0); // az osztas nevű eljárás meghívása, a zárójelben a két bemenő paraméter.
}
}
2.feladat: Az előző heti Fibonacci feladat megvalósítása eljárás használatával.
public class Fibonacci2 { // osztály létrehozása.
public static void fibonacci() { // létrehoz egy statikus eljárást bemenő paraméter nélkül, üres visszatérési típussal. Azért statikus, hogy kommunikáljon a statikus main-el.
int a, b; // deklarálja a-t, és b-t.
a=0; // a-nak 0 kezdőértéket ad.
b=1; // b-nek 0 kezdőértéket ad.
System.out.println(a); // kiírja a aktuális értékét.
System.out.println(b); // kiírja b aktuális értékét.
for(int i=0;i<4;i++){ // for ciklus, mely 4-szer fut le.
a=a+b; // a értékét módosítja a+b-re.
System.out.println(a); // kiírja a aktuális értékét.
b=a+b; // b értékét módosítja a+b-re.
System.out.println(b); // kiírja b aktuális értékét.
}
}
public static void main(String[] args) { // main eljárás
fibonacci(); // meghívjuk az fentebb létrehozott eljárást.
}
}
3.
Függvények, Globális változók
A függvények annyiban térnek el az eljárásoktól, hogy a visszatérési típusok nem void hanem valamilyen adatot tárolni képes típus ()pl.: int, char, double...), valamint a függvények utolsó sora mindig a return sor, amivel egy adott értéket vagy egy változó tartalmát adja vissza a main-nek. A függvényeket mindig úgy hívjuk meg a main-ben, hogy valamilyen változóban letároljuk annak a visszaadott eredményét.
A globális változók olynba változók, melyeket a main kívül hozunk létre láthatósági és statikus tulajdonsággal. Annyiban térnek el a mainben létrehozott változóktól, hogy azok a változók, amiket a mainben hoztunk létre, csak a meinben lehet használni, de a globális változókat a JAVA programon belül akárhol lehet használni. Olvasni vagy akár módosítani is az értéküket.
1.feladat: Hozzunk létre egy programot, amely tartalmaz egy globális változót (pl x), egy eljárást, ami két bemenő paraméterrel rendelkezik (pl a és b) és azt csinálja, hogy egy számsorozatot ír ki, úgy, hogy "a"-val osztható számokból "b" darabot. Ezt az eljárást hívjuk meg a main-ben legalább kétszer úgy, hogy a darabszámhoz mind a kétszer az x változót adjuk meg bemeneti paraméterként. (Kicsit egyszerűbben megfogalmazva. Két számsorozatot kell kiíratni úgy, hogy ha egy helyen módosítom a darabszámot, mind a két sorozat reagáljon rá!)
+1.feladat: Az előző feladat megvalósítása függvény használatával. Szükséges módosítások elvégzésével a mainben.
+2.feladat: Hozzunk létre két globális változót és két eljárást! Az egyik eljárással értékeket adunk a változóknak bemenő paraméterekkel(ezek az értékek 1 vezeték és 1 keresztnév), a másikkal pedig kiíratjuk ezeket az értékeket. Hívjuk meg ezt a két eljárást a mainben legalább két példány segítségével.
public class Sorozatok { // osztály létrehozása.
public static int x=10; // globális statikus változó deklarálása, melynek értéke 10. a program bármely részében elérhető és módosítható
public static void oszthatosag(int a, int b) { // oszthatosag eljárás létrehozása két bemenő paraméterrel.
int h=0; // h változó deklarálása, melynek értéke 0.
for(int i=0;i// for ciklus, mely b-szer fut le.
h=h+a; // h értékének megadása úgy, hogy h-hoz hozzáadjuk a értékét.
System.out.println(h); // kiírja h aktuális értékét.
}
}
public static void main(String[] args) { // main eljárás
System.out.println("A 3mmal oszthato elso x szam"); // kiírja ezt a szöveget: "A 3mmal oszthato elso x szam"
oszthatosag(3,x); // meghívja az oszthatosag eljárást, melynek segítségével kiírja a 3-al osztható számokat. Az x a fentebb megadott globális változó értéke lesz, azaz 10. Tehát 10 db 3-al osztható számot fog kiírni.
System.out.println(""); // üres sort ír ki.
System.out.println("5ttel oszthato elso x szam"); // kiírja ezt a szöveget: "5ttel oszthato elso x szam"
oszthatosag(5,x); // meghívja az oszthatosag eljárást, melynek segítségével kiírja az 5-el osztható számokat. Az x a fentebb megadott globális változó értéke lesz, azaz 10. Tehét 10 db 5-el osztható számot fog kiírni.
}
}
Példányosítás, Öröklődés
A példányosítást ha megfogható alakra akarjuk hozni úgy kell elképzelnünk, mint a klónozást. Megalkotunk egy olyan programot, ami megfelel az elvárásainknak és ha többször akarjuk egymás után végrehajtani a lépéseket úgy, hogy Mindegyik változatnak megmaradjanak az eredményei, akkor nem kell a különböző változónevek kiötlésével bajlódnunk, csak csinálunk egy újabb példányt(klónt), aminek a memóriacímére hivatkozva könnyen megnézhetjük a számunkra szükséges adatokat. Fontos különbség, hogy példányosításnál a változók, eljárások és függvények deklarálásánál nem kell használni a static tulajdonságot. A példányosításkor lehet konstruktorfüggvényeket megalkotni. Ez a függvény fogja tartalmazni azokat a lépéseket, amiknek már a példány megalkotásakor végbe kell mennie.
Az Öröklődés lényege, hogy a programokat lehet egymásból leszármaztatni. A leszármazott osztályok öröklik a szülőosztály minden mezőjét és metódusát (azonban a konstruktorfüggvényeket nem!). Az osztályokban a mezők mellett célszerű mindazokat a metódusokat definiálni, amelyekkel a mezőkön műveleteket végezhetünk. Ha az összes szükséges metódust létrehoztuk, a mezőkre nem kell közvetlenül hivatkoznunk, mivel a metódusokon keresztül minden szükséges művelet elvégezhető rajtuk (ez az ún. zártság vagy egységbezárás elve).
Egy leszármazott osztálynak lehetnek további leszármazottjai, így egy öröklési hierarchiához jutunk. Az öröklési hierarchiában egyes metódusokat átdefiniálhatunk, ilyenkor többalakúságról (polimorfizmusról) beszélünk. A polimorf metódusok neve és típusa, valamint szignatúrája (a formális paraméterek száma, típusa és sorrendje) megegyezik, de definíciójuk eltér (például azért, mert az öröklési hierarchia különböző pontjain más adatmezők érhetőek el, és ezekre a metódusok hivatkoznak).
Egy osztályon belül létezhetnek azonos nevű, de különböző szignatúrájú metódusok. Ilyenkor a metódusnév túlterheléséről beszélünk. A túlterhelt metódusok típusa különböző is lehet, valamint vegyesen előfordulhatnak közöttük osztály- és példányszintű metódusok is.
Hozzunk létre egy programot, amely tartalmaz 3 globális változót és három mező szintű eljárást. Az első eljárás egy számot vár bemenő paraméterként és azt a számot letárolja az egyik globális változóban. A másik eljárás egy vezetéknevet és egy keresztnevet vár bemenő paraméternek, melyeket értékül ad a másik két globális változóban. A harmadik eljárásnak nincs bemenő paramétere és azt csinálja, hogy kiíratja a következő szövet: "Helló 22 éves Nagy Gergő!" (Természetesen a név és a szám annak felel meg, ami a bemenő paraméter volt az előző két eljárásban.) Hozzunk létre a main-ben két példányt és hívjuk meg velük mindhárom eljárást!
public class Udv{ // osztály létrehozása.
public int x; // x-et deklarálja, globális változó.
public String vnev,knev; // String típusú változókat deklarál, mely segítségével karakterláncokat hozhatunk létre. Ezek is globális változók.
public void ev(int a){ // mező szintű eljárás, mely egy int bemenő paramétert vár.
x=a; // a bemenő paramétert ( az a-t) letárolja az x, globális változóban.
}
public void nev(String a,String b){ // mező szintű eljárás, amely két String típusú változót vár bemenő paraméterként.
vnev=a; // az "a" bemenő paramétert letárolja a vnev nevű globális változóban.
knev=b; // a "b" bemenő paramétert letárolja a knev nevű globális változóban.
}
public void kiir(){ // létrehoz egy kiir nevű, mező szintű eljárást
System.out.println("Hello "+x+" eves "+vnev+" "+knev+"!"); // kiírja a megadott paraméterek alapján a szöveget.
}
public static void main(String[]args){ // main eljárás.
Udv p1=new Udv(); // új példány létrehozása.
p1.nev("Nagy","Sandor"); // a p1 példány címére hivatkozva meghívjuk a nev eljárást.
p1.ev(23); // a p1 példány címére hivatkozva meghívjuk az ev eljárást.
p1.kiir(); // a p1 példány címére hivatkozva meghívjuk a kiir eljárást.
Udv p2=new Udv(); // új példány létrehozása.
p2.nev("Hoki","Gyuri"); // a p2 példány címére hivatkozva meghívjuk a nev eljárást.
p2.ev(26); // a p2 példány címére hivatkozva meghívjuk az ev eljárást.
p2.kiir(); // a p2 példány címére hivatkozva meghívjuk a kiir eljárást.
}
}
Az előző feladatban megírt programból származtassunk le egy új programot! (Öröklődés) Írjátok meg a névadó eljárást úgy, hogy egy sorszámnév is kerüljön bele római számmal bemenő paraméterként! (pl.: III. Török Szulejmán) Valamint a kiírató eljárást is írjátok meg újra úgy, hogy azt írja ki: "Üdvözöllek III. Török Szulejmán, aki 40 éves!" Természetesen itt is a bemenő paraméterekből kell megkapni ezt az eredményt. Fontos, hogy az ősosztályban és a leszármazott osztályban ugyanaz legyen a neve az értékadó és a kiírató eljárásoknak. Majd a mainben hozzatok létre egy példányt az ős osztályból, valamint a leszármazott osztályból és hívjátok meg a hozzájuk tartozó eljárásokat!
public class Uralkodoi extends Udv{ // az "extends"-el a származtatott osztály (Uralkodoi) örökli az ősosztály (Udv) összes adattagját és metódusát.
public String v; // String típusú, globális változó deklarálása.
public void nev(String a,String b,String c){ // mező szintű eljárás, mely 3 String típusú bemenő paramétert vár.
vnev=a; // az "a" bemenő paramétert letárolja a vnev változóban.
knev=b; // a "b" bemenő paramétert letárolja a knev változóban.
v=c; // a "c" bemenő paramétert letárolja a c változóban.
}
public void kiir(){ // kiir nevű eljárás létrehozása.
System.out.println("Udvozollek "+v+" "+vnev+" "+knev+" aki "+x+" eves!"); // a megadott paraméterek alapján kiírja a szöveget.
}
public static void main(String[]args){ // main eljárás
Udv p1=new Udv(); // példány létrehozása az ősosztályból.
p1.nev("Nagy","Sandor"); // a p1 példány címére hivatkozva meghívjuk az ősosztály nev eljárást.
p1.ev(23); // a p1 példány címére hivatkozva meghívjuk az ősosztály ev eljárást.
p1.kiir(); // a p1 példány címére hivatkozva meghívjuk az ősosztály kiir eljárást.
Uralkodoi q1=new Uralkodoi(); // példány létrehozása az aktuális osztályból.
q1.nev("Nagy","Sandor","II."); // a q1 példány címére hivatkozva meghívjuk a leszármazott osztály nev eljárását.
q1.ev(23); // a q1 példány címére hivatkozva meghívjuk az ősosztály ev eljárását.
q1.kiir(); // a q1 példány címére hivatkozva meghívjuk a leszármazott osztály kiir eljárását.
}
}
Vezérlési szerkezetek, Hibakezelés
A JAVA-ban a vezértlési szerkezetek, tehát az if és a switch teljesen azonosan működnek a C nyelvben tanultakkal.
A hibakezeléssel a JAVA-ban lehetőségünk van arra, hogy bizonyos specifikus hibákat megkeressünk a programban és arra, önmagunknak vagy a későbbi felhasználók számára egyértelmű és könnyebben érthető hibaüzeneteket közöljünk, mint a fordító. A try{} blokkban szereplő programrészletben fogja keresni a hibákat. A catch{} blokkokban pedig megírhatjuk, hogy bizonyos hibák esetén mit tegyen a program.
Hozzunk létre egy programot, amelyben létrehozunk egy függvényt, ami két bemenő paraméterrel rendelkezik! Az első paraméter legyen a hatványozás alapja, a második pedig a kitevő! Végeztessük el a műveletet a függvénnyel és a visszatérési érték legyen a művelet eredménye! (Nem ér használni a Math.pow() függvényt!) Hozzunk létre egy eljárást, ami kiírja szövegesen, hogy "szám alap a szám kitevőn: eredmény." (Pl.: 2 alap a 3 kitevőn: 8)! Hívjuk meg ezt a függvényt és az eljárást a mainben! A hatványozáshoz szükséges értékeket a parancssorról (billentyűzetről) kapjuk.
public class Hatvanybe{
public static int a, k, e; // a, k és e int típusú statikus globális változók deklarálása.
public static int hatvany(int alap, int kitevo){ // függvény létrehozása, két bemenő paraméterrel, int visszatérési értékkel. Az első a hatványozás alapja, a másik pedig a kitevő.
int c=1; // 1 értékül adása a c-nek.
for (int i=0;i// for ciklus, mely addig fut le, míg az i értéke kisebb, mint a kitevő értéke)
c=c*alap; // c értékének megadása úgy, hogy c-t megszorozza alap-pal.
}
return c; // visszatérési érték, mely az előző művelet eredménye.
}
public static void kiiras(int alap, int kitevo,int c){ // kiiras eljárás, mely az alap, a kitevő és c bemenő paraméterekkel rendelkezik.
System.out.println(alap+" alap a "+kitevo+ " kitevon: "+c+"."); // kiírja a megadott szöveget a megadott paraméterekkel.
}
public static void main (String[]args){
if(args.length<2) { // a bemenő paramétereket parancssori paraméterekből veszi. Ha a bemenő paraméterek száma kisebb 2-nél
System.out.println("Irj be ket szamot legkozelebb!");// akkor ezt a szöveget írja ki: "Irj be ket szamot legkozelebb!
System.exit(1); // ezt követően kilép az eljárásból.
}
a=Integer.parseInt(args[0]); // az első parancssori paraméter intté alakításával adja meg az a értékét.
k=Integer.parseInt(args[1]); // a második parancssori paraméter intté alakításával adja meg a k értékét.
e=hatvany(a,k); // kiszámolja a hatvány fv-ben megadott művelet alapján az eredményt és letárolja az e változóban.
kiiras(a,k,e); // kiírja az alap, a kitevő, és az érték eredményét.
}
}
Hozzunk létre egy osztályt, amiben példányosítás segítségével egy bibliográfiát fogunk csinálni! Állítsuk be eljárás(ok) segítségével (mindenkire rábízom, hogy mennyivel oldja meg), hogy mi a cím és ki a szerző, valamint legyen feltüntetve még egy kiadási év is! Valamint készítsetek egy kiírató eljárást is, ami a következőt írja ki: "Cím/Szerző. - kiadév"! (Pl.:Első és egyetlen/Dan Abnett. - 2001) Hozzunk létre legalább 3 példányt/rekordot!
public class Biblio{
public String szerzo,cim; // String típusú globális változók deklarálása.
public int kiadas; // int típusú globális változó deklarálása.
public void nevado(String a, String b, int c){ // nevado eljárás létrehozása, 3 bemenő paraméterrel.
szerzo=a; // az "a" bemenő paramétert letárolja a szerzo változóban.
cim=b; // a "b" bemenő paramétert letárolja a cim változóban.
kiadas=c; // a "c" bemenő paramétert letárolja a kiadas változóban.
}
public void kiir(){ // kiir nevű eljárás létrehozása.
System.out.println(cim+"/"+szerzo+". - "+kiadas); // Kiírja a fentebb megadott bemenő paramétereket.
}
public static void main(String[]args){ // main eljárás létrehozása.
Biblio p1=new Biblio(); // példányosítás.
p1.nevado("Andrzej SapBibliowski","Az utolso kivansag",1993); // eljárás meghívása.
p1.kiir(); // kiírás.
Biblio p2=new Biblio(); // példányosítás.
p2.nevado("Drew Karpyshyn","A pusztitas utja",2006); // eljárás meghívása.
p2.kiir(); // kiíratás.
Biblio p3=new Biblio(); // példányosítás.
p3.nevado("John Scalzi","Venek haboruja",2005); // eljárás meghívása.
p3.kiir(); // kiíratás.
}
}
Hozzunk létre egy programot, ami egy parancssori paramétert vár! Ez a parancssori paraméter egy betű legyen! A program csinálja azt, hogy valamilyen olyan keresztnevet írjon ki, ami a megadott betűvel kezdődik. Csak, hogy ne kelljen végig írni az egész ábécét, elég ha mondjuk g-ig lekezelitek a betűket. Az összes többi esetben pedig azt írja ki, hogy "Az adatbázis csak G-ig tartalmaz neveket" vagy valami hasonlót. A feladat megoldásához kötelezően használjatok IF-et. Megjegyzés: Stringekre nem működik az = =, szóval ilyenekkel ne is próbálkozzatok, hogy 'betu=="a";', mert nem fog lefutni. Helyette a '.equals();' szövegfüggvényt alkalmazzátok! Ha pl az "a" betűt akarjátok behasonlítani, akkor az úgy néz ki, hogy: if(valtozonev.equals("a"));.
public class Nevek{
public static void main(String[] args) {
if(args.length<1) { // ha nincs parancssori paraméter, akkor az alatta lévő kiírás teljesül
System.out.println("Irj mar be egy betut!"); // ha igaz volt az előző feltétel, akkor ezt a szöveget írja ki: Irj mar be egy betut!
System.exit(1); // megszakítja a program futását.
}
String s="Az adabazis csak g-ig van feltoltve"; // deklarál egy s nevű, String típusú változót.
String j=args[0]; // a j változóba beleteszi az első parancssori paraméter értékét.
if(j.equals("a")){s="Aladar";} // a Stringeknél nem működik értékek egyenlőségének vizsgálatra az "==" parancs, helyette a .equals() utasítást kell használni úgy hogy a vizsgálandó változó neve után írjuk. Ha j tartalma egyenlő az a Stringgel, akkor s-be belekerül az Aladar érték.
else if(j.equals("b")){s="Bela";} // Az else if akkor lép életbe, ha az előző if ágban megadott feltételek nem teljesülnek. Ha az else if ágból bármely else if igaz, akkor az utána következő else if és else ágakat már nem vizsgálja meg. Ha az else if-ben teljesül a feltétel. Ha j tartalma egyenlő a b Stringgel, akkor s-be belekerül a Bela érték.
else if(j.equals("c")){s="Cezar";} // Ha j tartalma egyenlő a c Stringgel, akkor s-be belekerül a Cezar név.
else if(j.equals("e")){s="Elemer";} // Ha j tartalma egyenlő az e Stringgel, akkor s-be belekerül az Elemer név.
else if(j.equals("f")){s="Ferenc";} // Ha j tartalma egyenlő az f Stringgel, akkor s-be belekerül a Ferenc keresztnév.
else if(j.equals("g")){s="Gergo";} // Ha j tartalma egyenlő a g Stringgel, akkor s-be belekerül a Gergo keresztnév.
System.out.println(s); // Kiíratódik a megadott betű alapján behasonlított keresztnév.
}
}
Hozzunk létre egy osztályt a Vez2 kettő mintájára, ami szintén egy parancssori paramétert vár. Ha a parancssori paraméter 0 és 3 illetve 5 és 9 közé esik, akkor írassuk ki a megfelelő ETO főosztályt! A többi esetre pedig végezzük el a szükséges hibakezeléseket!
public class Eto {
public static void main(String[] args) {
try { // a hibakezelési blokk kezdete. Hibakezelés csak mainben lehetséges.
String s; // String típusú változó deklarálása.
int j=Integer.parseInt(args[0]); // deklarálja az int típusú j változót, és ebben tárolja le az első parancssori paramétert, int típussá alakítva.
switch(j) { // a switch blokk kezdete a j változóra vonatkozóan.
case 0:s="Altalanos muvek";break; // a "case" kezeli a változó értékét. Ha j=0, akkor a String típusú s változóba az "Altalanos muvek" érték töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 1:s="Filozofia, pszichologia";break; // Ha j=1, akkor a String s-be a "Filozofia, pszichologia" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 2:s="Vallas";break; // Ha j=2, akkor a String s-be a "Vallas" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 3:s="Tarsadalomtudomanyok";break; // Ha j=3, akkor a Strig s-be a "Tarsadalomtudomanyok" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 5:s="Matematika, természettudományok";break; // Ha j=5, akkor a String s-be a "Matematika, természettudományok" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 6:s="Alkalmazott tudomanyok";break; // Ha j=6, akkor a String s-be az "Alkalmazott tudományok" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 7:s="Muveszetek, jatek, sport,";break; // Ha j=7, akkor a String s-be a "Muveszetek, jatek, sport" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 8:s="Nyelveszet, irodalom";break; // Ha j=8, akkor a String s-be a "Nyelveszet, irodalom" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
case 9:s="Regeszet, foldrajz, eletrajz, tortenelem";break; // Ha j=9, akkor a String s-be, a "Regeszet, foldajz, eletrajz, tortenelem" töltődik be. A break parancs segítségével az első igaz feltétel után abbahagyja a vizsgálatot.
default:s="Nincs. Probalkozz 0 es 9 kozt, a 4 kivetelevel."; // A default akkor lép működésbe, ha az eddigi feltételek közül egyik sem volt igaz.
}
System.out.println("A szamhoz tartozo foosztaly: "+s); // Kiírja a megadott szöveget: "A szamhoz tartozo foosztaly: " majd az s segítségével a megadott számhoz tartozó String típusú változó értékébe betöltött szöveget.
}
catch(NumberFormatException e) { // A catch segítségével "elkapja" azokat a hibákat, amikor nem számot adunk meg értékként.
System.out.println("Szamot kerek fiam!"); // Ha a nem megfelelő formátumot adtuk meg, kiír egy általunk megadott hiba üzenetet, jelen esetben: Szamot kerek fiam!
}
catch(ArrayIndexOutOfBoundsException e){ //olyan hibákat kap el, amikor az az elem, amire hivatkoztunk az nem létezik a tömbben, illetve a tömbön kívüli elemre hivatkozunk.
System.out.println("Nem létező paraméter"); //Ha nem létező paraméterre hivatkozunk kiírja az általunk megadott hibaüzenetet.
}
catch(Exception e) { // Elkapja az összes hibát.
System.out.println("Irj be valamit, lehetoleg szamot!"); // Kiírja az általunk megadott szöveget, jelen esetben: Irj be valamit, lehetoleg szamot!
}
}
}
Típusok
A JAVA nyelvben különböző típusú változókat lehet deklarálni, melyekbe különböző formátumú adatokat lehet letárolni. A fontosabb típusok: byte: -128 és 127 között tárol értéket.
short: -32768 és 32767 között tárol értéket.
int: -2 a 31.-en és 2 a 31.-en-1 között tárol értéket.
long: -2 a 63.-on és 2 a 63.-on-1 között tárol értéket.
char: karaktereket tud tárolni.
boolean: igaz vagy hamis értéket tud tárolni.
float és double: különböző intervallumon képesen tizedes törteket tárolni.
String: Karaktersorozatot képes tárolni.
Hozzunk létre egy programot, amelyben az alábbi számokat (78 97 32 108 97 116 111 100 44 32 109 101 103 121 32 101 122 33) szigorúan ebben a sorrendben karakter típussá konvertáljuk majd kiíratjuk őket úgy, hogy vízszintesen egy darab értelmes mondat legyen olvasható! A feladat megoldásához használjunk tömböt!
public class Hf015 {
public static void main(String[] args) {
int tomb[]={78,97,32,108,97,116,111,100,44,32,109,101,103,121,32,101,122,33}; // int típusú tömb deklarálása és feltöltése a megadott számokkal.
for(int i=0;i<18;i++) { // for ciklus, mely 18-szor fut le, pont annyiszor ahány db számot megadtunk a tömbben.
System.out.print((char)tomb[i]); // karakter típussá konvertálja a tömbben megadott számokat, majd egy vízszintes sorban kiírja őket, és egy értelmes mondatot kapunk.
}
}
}
Tömbök, Véletlen szám generálás
A JAVA-ban a tömböket úgy kell elképzelni, mint egy nagy szekrényt sok-sok fiókkal. Ezek a fiókok mind fel vannak címkézve egy indexszel. Ezek a számok 0-tól a tömb mérete-1-ig vannak kiosztva. Így jön ki a tömb mérete. Minden egyes fiókban csak 1 elemet lehet tárolni. Ha a töb valamelyik elemére vagyunk kíváncsiak, akkor csak a megfelelő indexű tömbelemre kell hivatkoznunk.
ha véletlen számokat akarunk generálni egy adott intervallumon, akkor azt úgy tehetjük meg, hogy (int)(Math.random()*(felső intervallum-alsó intervallum)+1).
Hozzunk létre egy programot, amelyben két darab int típust tárolni képes, 10 férőhelyes tömböt töltünk fel véletlen számokkal! A véletlen számok generálásához az intervallum felső határát a parancssori paraméterről kérjük be! Ha megvannak a véletlen számok, akkor hozzunk létre egy harmadik, ezúttal 20 férőhelyes tömböt, majd az előző két tömb tartalmát másoljuk át bele egyetlen ciklussal! A szükséges sorrend: a[0] b[0] a[1] b[1]....a[9] b[9].
public class Hf016{
public static void main(String[] args){
int tomb1[]=new int[10];int tomb2[]=new int[10];int tomb3[]=new int[20]; // deklarálunk 3 tömböt, melyeknek megadjuk, hogy hány db számot tudnak tárolni. A tomb1 10, a tomb2 szintén 10, a tomb 3 20 férőhelyes tömb.
try{ // hibakezelés kezdete
int felso=Integer.parseInt(args[0]); // parancssori paraméter segítségével adjuk meg a felső határt.
for(int i=0;i<10;i++){ // for ciklus, mely 10-szer fut le.
System.out.print((tomb1[i]=(int)(((Math.random())*felso)+1))+" ");} // Egy lépésben tölti fel a tömböt 1 és a felső határ között generált számokkal, valamint ezeket ki is íratja.
System.out.println(""); // üres sor.
for(int i=0;i<10;i++){ // for ciklus, mely 10-szer fut le.
System.out.print((tomb2[i]=(int)(((Math.random())*felso)+1))+" "); // Egy lépésben tölti fel a tömböt 1 és a felső határ között generált számokkal, valamint ezeket ki is íratja.
}
System.out.println(""); // üres sor.
int j=0; // deklarál egy int típusú j változót, melynek kezdőértéke 0.
for(int i=0;i<20;i=i+2){ // ciklus ami 10-szer fut le, mert az i értékét nem egyesével hanem kettesével léptetjük.
System.out.print((tomb3[i]=tomb1[j])+" "+(tomb3[i+1]=tomb2[j])+" "); // a tömb3-ba belerak egy elemet a tömb1 és tömb2 tömbökből, majd kiírja ezt a két elemet.
j++;}}
catch(Exception e){System.out.println("Hiba");} // Elkapja az összes hibát, és ha talál, akkor kiírja a "Hiba" szöveget.
}
}
Egy parancssori paraméterről érkező Stringet tároljunk le karakterenként egy tömbbe, ami pontosan olyan hosszú, mint a String, majd írassuk ki a karaktereket egymás mellé szóközzel elválasztva! ( Tipp: .length() .charAt(index) ).
public class Hf017 {
public static void main(String[] args){
char[] tomb=new char[args[0].length()]; // karakter típusú tömb deklarálása, ami parancssori paraméterről érkező String hosszával megegyező számú elemet tud tárolni és tárol le karakterenként ebbe a tömbbe.
for(int i=0;i// for ciklus, ami addig nem lép ki, annyiszor nem futott le, mint a String karaktereinek a száma.
System.out.print((tomb[i]=args[0].charAt(i))+" ");} // Kiírja a tömbben letárolt karaktereket egymás mellé szóközökkel elválasztva.
}
}
Math osztály, Szövegfüggvények
A JAVA-ban a különböző, leggyakrabban használt matematikai függvények előre le vannak generálva és csak meg kell hívnunk őket a MAth osztály megfelelő függvényére hivatkozva. A legfontosabb függvények:
Math.round(): egészre kerekít.
Math.abs(): Abszolút értéket ad meg.
Integer.toBinaryString(): Egy egész decimális számot bináris számmá alakít és letárolja a karaktersorozatot Stringbe.
Integer.parseInt("1011",2): Egy megadott Stringet (első paraméter) átalakít decimális számmá a megadott számrendszer szerinti értelmezés alapján (második paraméter).
Math.sqrt(): Gyökvonás.
Math.pow(2,15): Hatványozás. Alap, kitevő paraméterekkel.
Math.random(): Véletlen szám generátor. Az alapérték 0-1 közötti érték, de az 1-et sohasem generálja le. Double típust generál.
Math.PI: A PI értékét tartalmazza. 3,14............
Math.E: Az e értékét tartalmazza.
Math.toRadians(): Fokban megadott számot radiánná alakít.
Math.sin(): Szinusz függvény.
Math.cos(): Koszinusz függvény.
Math.tan(): Tangens függvény.
Math.toDegrees(): Radiánt fokká alakít.
Math.log(): Logaritmus függvény.
A JAVA-ban a String típusú változókon speciális műveleteket tudunk végrehajtani bizonyos szövegfüggvények segítségével. Ezeket az adott változónév után írva tudjuk meghívni. A legfontosabbak:
.length(): Megmondja hány karakter hosszú az adott String. Fontos különbség a tömböknél vett .length-hez képest, hogy itt a függvény végére kell a ().
.charAt(): String egy megadott sorszámú karakterét adja vissza.
.trim(): Levágja a String elejéről és végéről a fölösleges whitespace-eket.
.indexOf(' ',i1): Adott karakter indexét adja vissza a Stringben. Az első paraméter az, hogy melyik karaktert keressük, a második pedig az, hogy hányadik karaktertől kell kezdeni a keresést.
Hozzunk létre egy programot, aminek van egy bemenő paramétere, ami egy szám (decimális)! Ezt a számot írjuk ki 8-as számrendszerben! (Tilos használni az Integer.toOctalString() parancsot!)A következő parancsokat érdemes használni: konvertálás és szövegfüggvények.
public class OktalisSZs{
public static void main(String[]args){
if(args.length<1){ // ha az ifben lévő feltétel teljesül - azaz a parancssori paraméterek száma kisebb, mint 1 - akkor belép az elágazásba.
System.out.println("Keves parameter"); // Ha teljesül a feltétel, kiírja a megadott szöveget: "Keves parameter"
System.exit(1); // megszakítja a program futását.
}
int a=Integer.parseInt(args[0]); // int típusú, a változóba a parancssori paraméterről kér értéket.
String s=Integer.toBinaryString(a); // String típusú s változóban tárolja le az a-ban megadott értéket, amelyet átalakít bináris számmá.
int db,i1,i2; // deklarál int típusú db, i1 és i2 változókat.
if(s.length()%3==0){db=(int)(s.length()/3);} // ha az s változó karaktereinek a hossza 3-mal való osztása után a maradék nulla, akkor a db változóba betöltődik az egész típusúvá kényszertett 3-mal való osztás eredménye.
else db=(int)(s.length()/3+1); // egyéb esetben a db értékbe az int típusúvá kényszerített 3-al való osztás eredménye +1.
System.out.println("A szam decimalisan: "+a); // Kiírja a számot decimálisan
System.out.println("A szam binarisan: "+s); // Kiírja a számot binárisan
System.out.println("Az okalis szam hossza "+db);// Kiírja az oktális szám hosszát.
int[] okt=new int[10]; // létrehoz egy 10 elemű, int típusú tömböt.
i1=s.length(); // az i1 értéke az s-ben letárolt bináris számmá alakított szám hosszát.
i2=i1-3; // i2 értéke: i1-ből kivonunk 3-at.
for(int i=db-1;i>=0;i--){ // for ciklus, ahol i az oktális szám karaktereinek száma-1-ről indul és 0-ig megy.
if(i2<0){i2=0;okt[i]=Integer.parseInt(s.substring(i2,i1),2);break;} // ha i2 értéke kisebb, mint 0, akkor az i2=0, és az okt tömbben betölti a parancssori paraméterről megadott változó i2 és i1 közötti alkaraktersorozat 2-es számrendszerből 10-es számrendszerbe való átalakítását.
else if(i1>i2){okt[i]=Integer.parseInt(s.substring(i2,i1),2);} // egyébként ha i1 nagyobb, mint i2, akkor is ugyanezt csinálja, mint az előző sorba csak nem írja felül i2-t 0-ra.
i1=i2; // i1-be betölti i2 értékét.
i2=i1-3; // i2-be betölti azt a számot, amit az i1-3 művelettel kapunk meg.
}
System.out.print("A szam oktalisan: "); // kiírja a megadott szöveget.
for(int i=0;i// for ciklus, mely db-vel megegyező értékszer fut le.
System.out.print(okt[i]); // kiírja az okt tömb elemeit.
}
System.out.println(""); // üres sor.
}
}
Hozzunk létre egy programot, ami három parancssori paramétert vár, ami 3 darab szám előjellel együtt (pl:a,b,c)! Ezek segítségével írassuk ki az "ax*xbxc=0" karaktersorozatot/másodfokú egyenletet! Majd hozzunk létre egy eljárást, ami kiszámítja az adott egyenlet megoldásait!
public class Egyenlet1SZs{
public static void main(String[]args){
if(args.length<3){ // Ha a parancssori paraméterek száma kisebb, mint 3, akkor belép a feltételbe.
System.out.println("Keves bemenet!"); // Kiírja, hogy "Keves bemenet!"
System.exit(1); // Kilép a ciklusból.
}
int a=Integer.parseInt(args[0]); // int típusú a változót deklarál, melynek értékét az első parancssori paraméter.
int b=Integer.parseInt(args[1]); // int típusú b változót deklarál, melynek értékét a második parancssori paraméter.
int c=Integer.parseInt(args[2]); // int típusú c változót deklarál, melynek értékét a harmadik parancssori paraméter.
int x1,x2; // int típusú x1 és x2 változót deklarált.
if(b>0 && c>0){System.out.println("Az egyenlet: "+a+"x*x"+"+"+b+"x"+"+"+c+"=0");} // ha az if-ben megadott feltétel teljesül - azaz b nagyobb mint nulla és c is nagyobb mint nulla, akkor kiírja a megadott szöveget.
else if(b>0 && c<0){System.out.println("Az egyenlet: "+a+"x*x"+"+"+b+"x"+c+"=0");} // ha nem teljesül az if-ben megadott feltétel, rálép az else if ágra, ahol ha a megadott feltétel teljesül - azaz b kisebb mint nulla és c nagyobb mint nulla - akkor kiírja a megadott szöveget.
else if(b<0 && c>0){System.out.println("Az egyenlet: "+a+"x*x"+b+"x"+"+"+c+"=0");} // ha nem teljesül az előző ágban a feltétel, rálép a második else if ágra, ahol ha a megadott feltétel teljesül - azaz b kisebb mint nulla és c nagyobb mint nulla - akkor kiírja a megadott szöveget.
else System.out.println("Az egyenlet: "+a+"x*x"+b+"x"+c+"=0"); // ha egyik előző feltétel sem teljesül, akkor az else ágban kiírja a megadott szöveget.
if((Math.pow(b,2)-4*a*c)<0){ // ha bnégyzet mínusz 4*a*c kisebb mint nulla, akkor belép a feltételbe
System.out.println("Az egyenletnek nincs megoldasa"); // kiírja, hogy "Az egyenletnek nincs megoldása"
System.exit(1); // kilép a programból.
}
x1=(int)(-b+(Math.sqrt(Math.pow(b,2)-4*a*c)))/(2*a); // a fentebb deklarált x1-be értékül adja a matematikai gyökfüggvény (Math.sqrt) és a négyzetre emelés (Math.pow) segítségével kiszámolt másodfokú egyenlet egyik eredményét.
x2=(int)(-b-(Math.sqrt(Math.pow(b,2)-4*a*c)))/(2*a); // ugyan azt csinálja, mint az x1-ben, csak itt a -b után a számítás értékét nem hozzáadja, hanem kivonja.
System.out.println("x1= "+x1); // kiírja az x1 értékét.
System.out.println("x2= "+x2); // kiírja az x2 értékét.
}
}
Szövegfüggvények és matematika függvények gyakorlása
1.feladat: Hozzunk létre egy programot, ami egy Stringet vár parancssori paraméterről! Feladat, hogy ennek a Stringnek a karaktereit fordított sorrendben jelenítsük meg. (pl alma->amla)
public class Hf021 {
public static void main(String[] args){
char[] tomb=new char[args[0].length()]; // karakter típusú tömb deklarálása, mely az első parancssori paraméter hosszával megegyező számú elemet képes letárolni.
for(int i=args[0].length()-1;i>=0;i--){ // for ciklus, amely anyiszor fut le, amilyen hosszú az első parancssori paraméter.
System.out.print((tomb[i]=args[0].charAt(i)));} // A tomb i-ik értékébe berakja az első parancssori paraméter i-ik karakterét.
System.out.println(); // üres sor
System.out.println(); // üres sor.
for(int t=0;t// for ciklus, amely anyiszor fut le, amilyen hosszú az első parancssori paraméter.
System.out.print(tomb[t]); // kiírja a tömb t elemét.
}
System.out.println(); // üres sor.
System.out.println(); // üres sor.
for(int i=args[0].length()-1;i>=0;i--){ // for ciklus, amely anyiszor fut le, amilyen hosszú az első parancssori paraméter.
System.out.print((tomb[i]=args[0].charAt(args[0].length()-i-1)));} //kiíratja és értékül adja a tomb i-ik érétkének azt a karaktert, ami a parancssori paraméternek annyiadik karaktere, mint a parancssori paraméter hosszából kivonva az i-t és még 1-et.
System.out.println(); // üres sor.
System.out.println(); // üres sor.
for(int p=0;p// for ciklus, amely anyiszor fut le, amilyen hosszú az első parancssori paraméter.
System.out.print(tomb[p]); // kiíratjuk a tömb tartalmát.
}
}
}
Hozzunk létre egy programot, ami egy Stringet vár parancssori paraméterről! Vizsgáljuk meg karakterenként az adott Stringet és a mássalhangzókat cseréljük benne nagy betűkre!
public class Hf022 {
public static void main(String[] args){
char[] tomb=new char[args[0].length()]; // karakter típusú tömb deklarálása, mely az első parancssori paraméter hosszával megegyező számú elemet képes letárolni.
for(int i=0;i// belép a for ciklusba addig, amíg i kisebb mint a bemenő parancssori paraméter hossza
tomb[i]=args[0].charAt(i); // a tomb-öt feltölti a parancssori paraméter karaktereivel.
if("aeiou".indexOf(tomb[i])<0){ // megkeresi az aeiou karakterek előfordulását a tömbön belül, és ha az kisebb, mint nulla, akkor
tomb[i] = Character.toUpperCase(tomb[i]);} // e sor segítségével a mássalhangzókat kisbetűről nagybetűre írja át.
System.out.print(tomb[i]);} // kiírja a tömbben megadott karakterláncot az átalakított formában.
}
}
3.feladat: Hozzunk létre egy programot, ami egy Stringet vár parancssori paraméterről! Vizsgáljuk meg, hogy az adott karaktersorozat átalakítható-e 16-os számrendszerbe! (Csak 0-9-ig és a-f-ig tartalmaz karaktereket.) Majd ha lehetséges, konvertáljuk is át, ha nem, akkor írassunk ki valami ezzel kapcsolatos szöveget!
public class Hf023 {
public static void main(String[] args){
try{ // hibakezelő blokk kezdete
for(int i=0;i// for ciklus kezdete
if(Character.isDigit(args[0].charAt(i))||!("abcdef".indexOf(args[0].charAt(i))<0)){ //ha a kapott karakter szám vagy valamilyen abcdef karakter, akkor lehetséges az átkonvertálás
System.out.print("atalakithato, az erteke " + Integer.parseInt(args[0],16)+" ");} //kiírja a megadott szöveget és kiírja az egész típusú számmá kényszerített értéket 16-os számrendszerben.
else System.out.println("nem atalakithato");break;}} // ha nem teljesül az ifben megadott feltétel, akkor kiírja, hogy nem atalakithato és kilép a break-el.
catch(Exception e){ // hibakezelés
System.out.println(e);} // kiírja a hibát.
}
}
4.feladat: Hozzunk létre egy programot, amiben egy 10 elemű, csupa 0-val feltöltött tömböt generálunk! A parancssorról egy számot(x) várunk 1 és 10 között. Feladat, hogy kicseréljünk x darab számot 0 és x között generált véletlen számokkal!
public class Hf024 {
public static void main(String[] args){
int tomb[]=new int[10]; // int típusú tömb legenerálása ,amely 10 elemet képes tárolni.
for(int i=0;i<10;i++){ // for ciklus, mely 10-szer fut le
tomb[i]=0;} // a tömb feltöltése a 0-val.
try{ // hibakezelés kezdete
int x=Integer.parseInt(args[0]); // int típusú x változó deklarálása, melynek értéket a parancssori paraméterről kapunk.
if(x<1||x>10){ // akkor lép a program az elágazásba, ha teljesül az a feltétel, hogy x kisebb, mint 1, vagy x nagyobb, mint 10.
System.out.println("1 es 10 kozotti szamot adj."); // ha az előző feltétel teljesül, akkor kiírja, hogy "1 és 10 kozotti szamot adj."
System.exit(1);} // majd kilép a programból.
for(int i=0;i// for ciklus kezdete, mely x-szer fut le.
System.out.print("kicsereltuk a "+i+". helyen: "+tomb[i]+"-t "); // kiírja, hogy hányadik helyen, melyik számot cseréljük majd ki.
tomb[i]=(int)(Math.random()*x)+1; // a tömbnek értékül adja az int - azaz egész - típussá konvertált random számot, amit a 1-x intervallumon generáltunk.
System.out.println(tomb[i]+"-re.");}} // kiírja, hogy mire cseréltük ki a fentebb megadott értéket.
catch(Exception e){ // elkapja az összes hibát.
System.out.println(e);}} // kiírja a talált hibát.
}
Rendezések, Keresések
A JAVA-ban is használnak különböző keresési és rendezési algoritmusokat. Ezekkel sajnos nem lehet mást tenni csak szóról szóra-sorról sorra megtanulni őket.
Hozzunk létre egy programot, amivel egy parancssori paraméterről érkező String elemeit karakterenként letároljuk egy tömbbe! Ezt követően rendezzük a karaktereket növekvő sorrendben! Tipp: Számmá konvertálás és vissza.
public class Hf025 {
public static void main (String[] args){
char[] str = new char[args[0].length()]; // karakter típusú tömb deklarálása, mely az első parancssori paraméter hosszával megegyező számú elemet képes letárolni.
int[] str1 = new int[args[0].length()]; // int típusú tömb deklarálása, mely az első parancssori paraméter hosszával megegyező számú elemet képes letárolni.
for(int i=0;i// for ciklus kezdete
str[i]=args[0].charAt(i); // a str tömb értékét karakterré alakítja át.
str1[i]=(int)str[i]; // típuskényszerítéssel intté alakítja át a str tömb elemeit.
System.out.print(str[i]);} // kiírja a str tömb elemeit.
System.out.println(); // üres sort ír ki.
int j; // deklarál egy int típusú j változót.
for(int i=0;i// for ciklus ami a parancssori paraméter-1-szer fut le
for(int k=i+1;k// for ciklus ami a parancssori paraméter-1-szer fut le
if(str1[i]>str1[k]){ // ha a tömb i.-ik elem kisebb, mint a k.-ik akkor belép az elágazásba
j=str1[k];str1[k]=str1[i];str1[i]=j;}}} // megcseréli a két elem értékét
for(int i=0;i// for ciklus ami a parancssori paraméterszer fut le
System.out.print(str[i]=(char)str1[i]);} // kiírja az értékeket karakterré kényszerítve
Hozzunk létre egy programot, amivel feltöltünk egy 15 elemű tömböt 1 és 10 közötti számokkal véletlenszerűen. Számoljuk meg és írassuk ki, hogy melyik számból mennyi van a tömbben!
public class Hf026 {
public static void main(String[] args){
int[] tomb = new int[15]; // int típusú tömb deklarálása, mely 15 elemet képes tárolni
for(int i=0;i<15;i++){ // for ciklus, mely 15ször fut le.
System.out.print((tomb[i]=(int)(Math.random()*10)+1)+" ");} // Kiírja az int típusúvá kényszerített random számot, amit 1-10 intervallumon generáltunk.
System.out.println(); // üres sor.
for(int i=1;i<=10;i++){ // for ciklus, mely 10szer lefut.
int x=0; // int típusú x elem deklarálása, melynek értéke 0.
for(int j=0;j<15;j++) // for ciklus, mely 15ször fut le.
if(i==tomb[j]) x++; // ha i egyenlő j értékével, akkor növeli x értékét egyel.
System.out.println(x+" db " +i );} // kiírja, hogy x db van i számból.
}
}
Rendezések, Beolvasás billentyűzetről
JAVA-ban a LineNumberReader segítségével lehetőségünk van rá, hogy futás közben a billentyűzetről értékeket olvassunk be.
1.feladat: Hozzunk létre egy programot, amelyben a readLine() segítségével beolvasunk 5 számot! Ezeket a számokat tároljuk le egy tömbbe, majd írassuk ki a tömb tartalmát. (int típusú tömböt használjunk)
import java.io.*; // importáljuk a java.io csomagot.
public class Laoms3{
public static void main(String[] args) throws IOException { //létrehozzuk a main-t, de figyelmen kívül hagyunk minden lehetséges IO hibát.
LineNumberReader in=new LineNumberReader(new InputStreamReader(System.in)); // ez a sor kötelező, ha sorokat akarok bevinni a billentyűzetről.
System.out.print("? "); // kiírja a kérdőjelet.
String s=in.readLine(); // string típusú s változó deklarálása, melynek értéke a sorból van megadva.
int[] szamok=new int[5]; // int típusú szamok tömb létrehozása, melynek öt eleme van.
for(int i=0;i<5;i++){ // for ciklus, mely ötször fut le.
szamok[i]=Integer.parseInt(s); // szamok tömb, melyben a string típusú s értékét intté kényszerít át.
System.out.print("? "); // kérdőjelet ír ki.
s=in.readLine(); // s-nek értéket ad, mely a megadott sorból van.
}
System.out.println("A beolvasott szamok: "); // kiírja a megadott szöveget
for(int i=0;i<5;i++){
System.out.print("\t"+szamok[i]); // kiírja a szamok tömb tartalmát
}
}
}
Hozzunk létre egy programot, amelyben két változót feltöltünk 0 és 50 közötti véletlen generált számokkal! Töltsünk fel egy tíz elemű tömböt úgy, hogy random segítségével döntsük el, melyik kerül be az adott indexre! (0-1 intervallumon generáljunk számokat a tömbbe! Ha 0, akkor az első szám, ha 1, akkor a második kerüljön az adott indexre!)
public class Laoms4{
public static void main(String[]args){
int a=(int)(Math.random()*51); // int típusú random szám generálása 0 és 50 között, az int típusú a változóba.
int b=(int)(Math.random()*51); // int típusú random szám generálása 0 és 50 között, az int típusú b változóba.
int[] tomb=new int[10]; // 10 elemű, int típusú tömb deklarálása.
System.out.println("a="+a); // kiírja az a értékét.
System.out.println("b="+b); // kiírja a b értékét.
for(int i=0;i<10;i++){ // for ciklus, mely 10szer fut le.
tomb[i]=(int)(Math.random()*2); // int típusú random számok generálása, 0-1 intervallumon.
}
for(int i=0;i<10;i++){ // for ciklus, mely 10szer fut le.
System.out.print("tomb["+i+"]="+tomb[i]+"\t"); // kiírja a tömb tartalmát.
}
System.out.println(""); // üres sor
System.out.println(""); // üres sor
for(int i=0;i<10;i++){ // for ciklus, mely 10szer fut le.
if(tomb[i]==0){tomb[i]=a;} // ha a tömb eleme egyenlő nullával, akkor a tömb értéke egyenlő lesz a értékével.
else{tomb[i]=b;} // egyébként a tömb eleme egyenlő lesz a b értékével.
}
for(int i=0;i<10;i++){
System.out.print("tomb["+i+"]="+tomb[i]+"\t"); // kiírja, hogy az adott szám melyik indexre kerül be.
}
}
}
Fájlkezelés, Stringek rendezése
JAVA-ban képesek vagyunk fájlok tartalmát is kiolvasni a LineNumberReader-rel.
A Stringek rendezésére speciális függvényt hívünk segítségül. A .compareTo()-t. Egy String típusú változóra tudjuk meghívni egy másik típusú változóval paraméterként. Ha a forrás változó kisebb, mint a paraméterben megadott szöveg, akkor negatív eredményt ad vissza. Fordított esetben pozitívat.
1.fealdat: Hozzunk létre egy programot, amivel kiolvassuk egy txt tartalmát és soronként visszaadjuk.
import java.io.*;
public class Fajl{
public static void main(String[] args) throws IOException {
LineNumberReader in=new LineNumberReader(new InputStreamReader(new FileInputStream("szoveg.txt"))); //Az adott nevű és kiterjesztésű fájlból kiolvassa a biteket, majd bináris kóddá alakítja, majd szöveggé.
String s; //s változó deklarálása
s=in.readLine(); //string típusú s változó deklarálása, melynek értéke a sorból van megadva.
while(s!=null) { //ha s nem üres, akkor
System.out.println("\t"+in.getLineNumber()+". sor = "+(s.length()>0?s:"(ures sor)")); //lekéri az adott sor számát. Ha van benne szöveg kiírja a tartalmát, ha nem akkor azt hogy üres sor.
s=in.readLine(); //s értékét felülírja a következő soréval.
}
in.close(); //bezárja a megnyitott fájlt.
}
}
Hozzunk létre egy programot, amiben a parancssori paraméterről kérünk három Stringet és ezeket rendezett sorrendben kiírja azokat.
public class String4 {
public static String min(String s,String t) {
return (s.compareTo(t)<0 ? s : t);
}
public static String max(String s,String t) {
return (s.compareTo(t)>0 ? s : t);
}
public static void main(String[] args) {
if (args.length<=2) {
System.out.println("Maskor adjon meg harom parancssori parametert!");
System.exit(1);
}
String s,t,u;
s=min(args[0],args[1]);
t=max(args[0],args[1]);
u=args[2];
System.out.println("A legkisebb parameter: "+min(s,u));
System.out.println("A legnagyobb parameter: "+max(t,u));
}
}
Karakterkészlet
A program forrásszövegének legkisebb alkotórészei a karakterek.
Az UNICODE 16 bites kódtáblára épül, ahol betű minden nyelv betűje lehet. Tartalmazza az összes nemzetközi abc-t. Megkülönbözteti a kis-és nagybetűt.
Kategóriák:
· betűk (minden nyelv betűje)
· számjegyek (0-9 decimális számjegy)
· egyéb karakterek (műveleti jelek, elhatároló jelek, írás jelek, speciális karakterek)
Szimbolikus nevek
Azonosító
Olyan karaktersorozat, amely betűvel kezdődik, és betűvel vagy számjeggyel folytatódhat. Arra használjuk, hogy a programozói eszközeinket megnevezzük vele, és ezután bárhol a program szövegében hivatkozhassunk rá. Betűnként nem csak a nemzeti karaktereket, hanem az _ és $ jelet is használhatjuk.
Azonosító képzési szabályok:
· Az azonosító bármilyen hosszú Javában használható unikód karaktersorozat lehet
· Egy azonosító nem kezdődhet számjeggyel, nem lehet kulcsszó, és nem lehet a nyelv egy előre definiált konstansa (true, false vagy null).
· Két azonosító csak akkor egyezik meg, ha unikód karaktereik rendre megegyeznek.
Példák az azonosítóra:
Szabályos Java azonosítók:
Nem azonosítók:
x
x+y
ár x*y+3
diak_kod
12öt
Néhány gyakorlati hasznos tanács az azonosítók készítéséhez:
· Próbáljunk meg jól olvasható, beszédes azonosítókat választani! (minSebesseg, karakterekSzama)
· Az osztályok azonosítóját nagybetűvel kezdjük. (Emberek,Diákok)
· A változók és metódusok azonosítóját kisbetűvel kezdjük. (szám, darab)
· A konstansokat csupa nagybetűvel írjuk. (ALAPAR)
· Az azonosítókat úgy tagoljuk, hogy az összetett szavak kezdőbetűit nagybetűvel, a többit kisbetűvel írjuk. (maxSebessegHatar)
Kulcsszó
Olyan karaktersorozat, amelynek az adott nyelv tulajdonít jelentést, és ez a jelentés a programozó által nem megváltoztatható.
A java kulcsszavai a következők:
abstract
default
if
package
transient
boolean
do
implements
private
try
break
double
import
protected
void
byte
else
instanceof
public
volatile
case
extends
int
return
while
catch
final
interface
short
synchronized
char
finally
long
static
this
class
float
native
super
throw
continue
for
new
switch
throws
A const és a goto szintén foglalt szó, de nincs implementálva, egyik sem használatos.
Címke
A végrehajtható utasítások megjelölésére szolgál, bármely végrehajtható utasítás megcímkézhető. Azért alkalmazzuk, hogy a program egy másik pontjáról hivatkozni tudjunk rá.
A címke egy azonosító, az utasítás előtt áll kettősponttal elválasztva.
Szintaktika:
cimke: { }, vagy cimke: utasítás
A címkét a break vagy a continue paranccsal együtt használjuk úgy, hogy megadjuk a parancs után azt, hogy melyik egységre vonatkozik.
Példa:
Megjegyzések
A megjegyzés olyan programozási eszköz, amely arra szolgál, hogy a program írója a kód olvasójának valamilyen információt szolgáltasson.
A megjegyzést a forrásszövegben háromféle módon helyezhetjük el:
· //-től sorvégig megjegyzés.
· /* */ zárójelek között tetszőleges hosszan.
· /** */ dokumentációs megjegyzés. A fejlesztőkörnyezet segítségével automatikusan lehet generálni hypertext (HTML) dokumentációt, ami felhasználja a dokumentációs megjegyzéseket is. (Run > Generate Javadoc (Projekt név))
Példa a megjegyzésekre:
Literálok
A literál olyan programozási eszköz, amelynek segítségével fix, explicit értékek építhetők be a program szövegébe. Két komponense van: típus és érték.
Fajtái:
· egész: egy pozitív vagy negatív egész szám, vagy nulla.(pl. +200, -3, 1256987)
· valós: egy tizedesekkel leírható szám. Két formában adható meg: tizedes forma és lebegőpontos forma (pl. 6.32, 100.0, 0.0006, 6.3E2, 5E-4)
· logikai: két logikai konstans létezik, a true (igaz) és a false (hamis).
· karakter: egy unicode karakter (szimpla aposztrófok közé tesszük). (pl. 'a', 'B')
· szöveg: akármilyen hosszú, unicode karakterekből álló sorozat (idézőjelek közé tesszük).
(pl. "Szia")
· null
Változó
A programok adatokon végeznek különféle manipulációkat, ezek az adatok a program futása alatt változtatják értéküket. A kezdeti adatokat a program eltárolja a változókba, az értékek az algoritmusnak megfelelően módosulnak a program futása folyamán. Az algoritmus végén a változó a végeredmény értékével rendelkezik.
A változó olyan adatelem, amely azonosítóval van ellátva. Az egyik legfontosabb programozási eszközünk.
A változókat használat előtt deklarálni kell. Ez azt jelenti, hogy meg kell adni a típusát, nevét, esetleg értékét is. Amikor egy változónak kezdeti értéket adunk, akkor a változót inicializáljuk.
pl. byte a; int x = 0;
Egy változót a program tetszőleges részén deklarálhatunk.
A változó érvényességi tartománya a programnak az a része, ahol a változó használható. A változódeklaráció helye határozza meg az érvényességi tartományt.
A változó lehet (A deklarálás helyétől függően.):
· tagváltozó: Az osztály vagy objektum része, az osztály egészében látható (alkalmazható). Az osztály változók deklarálásánál a static kulcsszót kell használni.
· lokális változó: Egy kódblokkon belül alkalmazzuk. A láthatósága a deklaráció helyétől az őt körülvevő blokk végéig tart.
· A metódusok formális paraméterei az egész metóduson belül láthatók.
· A kivételkezelő paraméterek hasonlók a formális paraméterekhez.
Példa a változókra:
A változót lehet véglegesen is deklarálni (konstans változó), a végleges változó értékét nem lehet megváltoztatni az inicializálás után.
A végleges változók deklarációnál a final kulcsszót kell használni:
pl. final int aKonstans = 0;
Kifejezések (operandusok és operátorok)
A kifejezések szintaktikai eszközök, arra valók, hogy a program egy adott pontján ismert értékekből új értékeket határozzunk meg. Két komponense van típus és érték.
Alapvetően kétféle feladata van: végrehajtani a számításokat, és visszaadni a számítás végeredményét.
Összetevők:
· Operandusok: Az értéket képviselik. Lehet literál, nevesített konstans, változó vagy függvényhívás az operandus.
· Operátorok: Műveleti jelek (pl. *, /, +, -).
· Kerek zárójelek: A műveletek végrehajtási sorrendjét befolyásolják.
Példa a kifejezésre:
a
+
sin(0)
Operandus
Operátor
Operandus
Attól függően, hogy egy operátor hány operandussal végez műveletet, beszélhetünk:
· egyoperandusú (unáris pl. (+2)),
· kétoperandusú (bináris pl. (2+3)) vagy
· háromoperandusú (ternáris pl. (a*b*c)) operátorokról.
Operátorok:
(Az operanduson hajtanak végre egy műveletet.)
Aritmetikai operátorok: Alapvető matematikai műveletek végzésére használjuk őket.
+ (összeadás),
- (kivonás),
* (szorzás),
/ (osztás),
% (maradékképzés).
Példa az aritmetikai operátorok használatára:
Implicit konverzió: Amikor egy aritmetikai operátor egyik operandusa egész a másik pedig lebegőpontos, akkor az eredmény is lebegőpontos lesz. Az egész érték implicit módon lebegőpontossá konvertálódik, mielőtt a művelet végrehajtódna.
Példa: Egy egész számot osztunk egy valós számmal, a végeredmény automatikusan valós lesz.
A konverziót ki is "kényszeríthetjük" explicit konverzióval. A programozó ebben az esetben a kifejezés értékére "ráerőltet" egy típust.
Szintaxis:
(<típus>) <kifejezés>
Példa:
6/4 >> eredmény: 1 (Itt két egész számot osztottunk egymással.)
(double) 6/4 >> eredmény: 1.5
Relációs operátorok: Összehasonlítanak két értéket, és meghatározzák a köztük lévő kapcsolatot.
> (nagyobb),
>= (nagyobb vagy egyenlő),
< (kisebb),
<= (kisebb vagy egyenlő),
= = (egyenlő),
! = (nem egyenlő).
Példa a relációs operátorok használatára:
Logikai operátorok:
&& (logikai és),
|| (logikai vagy),
! (logikai nem),
& (bitenkénti és),
| (bitenkénti vagy),
^ (bitenkénti nem),
~ (Bitenkénti tagadás (negáció)).
Példa a logikai operátorok használatára:
Léptető operátorok: A léptető operátorok bitműveleteket végeznek, a kifejezés első operandusának bitjeit jobbra, vagy balra léptetik.
<< (op1 << op2; op1 bitjeit op2 értékével balra lépteti, jobbról nullákkal tölti fel)
>> (op1 >> op2; op1 bitjeit op2 értékével jobbra lépteti, balról a legnagyobb helyértékű bitet tölt fel)
>>> (op1 >>> op2; op1 bitjeit op2 értékével jobbra lépteti, balról nullákkal tölt fel)
Értékadó operátorok
= Alap értékadó operátor, arra használjuk, hogy egy változóhoz értéket rendeljünk.
Rövidített értékadó operátorok: + =, - =, * =, / =, % =, & =, | =, ^ =, << =, >> =, >>> = (pl. i = i + 1; rövidítve: i + = 1;)
Példa az értékadó operátorok használatára:
Egyéb operátorok:
? : Feltételes operátor.
[ ] Tömbképző operátor.
. Minősített hivatkozás.
new Új objektum létrehozása.
A kifejezés alakja lehet:
· prefix: Az operátor az operandusok előtt áll (* 2 5).
· infix: Az operátor az operandusok között áll (2 * 5).
· postfix: Az operator az operandusok mögött áll (2 5 *).
Azt a folyamatot, amikor a kifejezés értéke és típusa meghatározódik, a kifejezés kiértékelésének nevezzük. A kiértékelés során adott sorrendben elvégezzük a műveleteket, előáll az érték, és hozzárendelődik a típus.
A Javában a következő módon megy végbe a kiértékelés:
· Zárójelezéssel meghatározhatjuk, hogy egy kifejezés hogyan értékelődjön ki.
pl. (x + y) / 2 Először a zárójelben szereplő kifejezés hajtódik végre.
· Ha nem jelezzük, hogy milyen sorrendben akarjuk, az összetett kifejezést kiértékelni, akkor a sorrendet az operátorok precedenciája fogja meghatározni. A magasabb precedenciával rendelkező operátorok hajtódnak végre elsőként.
· pl. x + y / 2 Ebben a kifejezésben, mivel az osztás precedenciája magasabb mint az összeadásé, ezért először ez hajtódik végre, majd az összeadás következik. A következő kifejezés egyenértékű vele:
x + (y / 2).
Operátor precedencia szintek:
postfix expr++ expr--
unáris ++expr --expr +expr -expr ~ !
multiplikatív * / %
additív + -
léptetés << >> >>>
relációs < > <= >= instanceof
egyenlőség = = !=
bitenkénti és &
bitenkénti kizáró vagy ^
bitenkénti vagy |
logikai és & &
logikai vagy | |
feltételes ? :
értékadás = += -= *= /= %= &= ^= |= <<= >>= >>>=
A táblázat a Java platformon használt operátorok precedencia szintjeit mutatja be. Az operátorok precedencia szint szerint vannak rendezve, mégpedig úgy, hogy legfelül a legnagyobb precedenciájú, legalol a legkisebb precedenciájú található. Az azonos szinten elhelyezkedő operátorok azonos precedenciával rendelkeznek. Ha azonos precedenciájú operátorok szerepelnek egy kifejezésben, akkor balról jobbra történik a végrehajtás, kivéve az értékadó operátorokat, amelyek jobbról balra hajtódnak végre.
Azt a kifejezést, amelynek értéke fordítási időben eldől konstans kifejezésnek nevezzük. Létrehozására a final módosítót használjuk, így érjük el, hogy az adattag értékét nem változtathatja meg senki.
pl. final double PI: Pi értékét jelenti.
Deklarációs és végrehajtható utasítások
A deklarációs utasítások mögött nem áll tárgykód. A programozó a névvel rendelkező saját programozási eszközeit tudja deklarálni.
pl. int i=10;
A végrehajtható utasításokból generálja a fordító a tárgykódot.
Melyek ezek?
· Üres utasítás (pl. ;)
· Kifejezés utasítás (pl. 8; a = b;)
· Vezérlő utasítások (szekvencia, feltételes utasítás, többszörös elágaztatás, ciklusok, vezérlésátadó utasítások)
· Módszerhívások (metódushívások)
· Objektumot létrehozó kifejezések
Alprogramok
A programot célszerű kisebb egységekre (alprogram) bontani, melyeket a program bizonyos pontjairól aktivizálhatunk. Így áttekinthetőbbé, olvashatóbbá válik a forrásprogram, valamint a többször előforduló tevékenységeket elegendő egyszer megírni (elkészíteni).
A Javaban metódusnak nevezzük az alprogramot. A metódus utasítások összessége, melyet meghívhatunk a metódus nevére való hivatkozással.
Egy metódus lehet eljárás vagy függvény aszerint, hogy van-e visszatérési értéke.
Eljárás
Az eljárásnál nincsen visszatérési érték, egyszerűen végrehajtódik az eljárás nevére való hivatkozással. A végrehajtás után a program azzal az utasítással folytatódik, amelyik az eljárást meghívó utasítást követi. Az eljárás visszatérési típusa void (semleges), ami azt jelenti , hogy a visszatérési típus nincs definiálva.
Példa az eljárásra:
(Az eljárás egy vonalat "rajzol" a képernyőre.)
Függvény
A függvénynél van visszatérési érték. A függvényt is egyszerűen a nevére való hivatkozással hívunk meg, de visszaad egy értéket, melyet a függvény neve képvisel.
Példa a függvényre:
(A függvény megduplázza az x változó értékét.)
Blokk
A blokk nulla vagy több utasítás kapcsos zárójelek között, amely használható bárhol, ahol az önálló utasítások megengedettek.
Jellemzői:
· { } zárójelek között szerepel.
· Címkézhető.
· Tetszőleges mélységben egymásba skatulyázható.
· A változó a blokk lokális változójaként deklarálható.
· A blokkon belül tetszőleges a deklarációs- és végrehajtható utasítások sorrendje.
Nincsenek megjegyzések:
Megjegyzés küldése