Programoz�s alapjai I

Document Sample
Programoz�s alapjai I Powered By Docstoc
					Programozás alapjai I. félév
(Debreceni Egyetem, informatikus könyvtáros szak)

Tartalom:

      a Java nyelv alapjai példákon keresztül (kezdõk számára)
           o alapvetõ programszerkezetek
           o összetett programszerkezetek
           o grafikus programszerkezetek ÚJ!
      bevezetés
      képernyõkezelés, standard i/o (elsõsorban Turbo Pascal)
      programok szerkezete
      egyszerû adattípusok
      kódrendszerek
      konstansok
           o konstansok, parancssori paraméterek, kivételkezelés példákon keresztül (Java)
      változók, kifejezések, értékadás
           o változók, összetett adattípusok
                    változók, összetett adattípusok példákon keresztül (Java)
           o kifejezések, mûveletek
           o értékadás, konverzió
      standard eljárások és függvények
      karakterláncokon végzett mûveletek
      vezérlési szerkezetek
      rendezés, interfészek, csomagoló osztályok (Java)
      összefoglalás (olvassa el újra a bevezetést!)

Feladatok:

      példaprogramok


                                                                                 Boda István, 2004. november 23.
Alapvetõ programszerkezetek (Java)
egy számítógépet kétféleképpen használhatunk

        elõre elkészített programokat használunk, rendszerint interaktívan (beírva a program által kért adatokat
         vagy "kattintgatva" az egérrel)
        egy programban, utasítások segítségével lépésenként leírjuk a számítógépnek, milyen adatokon milyen
         mûveleteket hajtson végre, majd a programot végrehajtatjuk a számítógéppel, amely a programban leírt
         utasításokat az általunk megadott sorrendben végre fogja hajtani - feltéve, hogy megérti õket
             o egy program készítésekor egy olyan mesterséges nyelvet, ún. programozási nyelvet kell
                 használnunk, amelyet a számítógép megért, azaz a benne szereplõ utasításokat adott sorrendben
                 végre tudja hajtani
             o az egyik legkorszerûbb programozási nyelv a Java, amely támogatja a számítógép
                 programozását grafikus felületen, például weblapokon megjeleníthetõ programocskákkal (ún.
                 appletekkel); az alábbi alapprogramok a Java nyelv alapvetõ programszerkezeteit szemléltetik
                 egy rendkívül egyszerû feladat végrehajtásával (egy adott nevû, adott korú hölgy üdvözlése
                 szöveges feületen, egy vagy több sor kiírásával a számítógép képernyõjére)



Alappélda


        a Java programok írásakor osztályokat vagy objektumokat (class) készítünk
             o   az osztály nevét a public class kulcsszavak után kell megadnunk (az osztályok neve megállapodás
                 szerint nagybetûvel kezdõdik)
             o   az osztály törzsének kezdetét és végét kapcsos zárójelek adják meg
        a számítógép által végrehajtandó utasítások a public static void main(String[] args) metódus törzsében
         találhatóak
             o   a metódus törzsének kezdetét és végét kapcsos zárójelek adják meg
             o   az utasításokat pontosvesszõ zárja le
        a számítógép a System.out.println() eljárásban megadott paraméter értékét kiírja a képernyõre
             o   a paramétert az eljárás neve után álló zárójelek között kell megadnunk
             o   a paraméter egy tetszõleges szöveg (karakterlánc) lehet
             o   a szöveget (karakterláncot) a programban idézõjelek között adjuk meg


public class Hello {
public static void main(String[] args) {
 System.out.println("**********");
 System.out.println("* Hello! *");
 System.out.println("**********");
 }
}
1. példa (lokális változók használata; részletesebben lásd Programok szerkezete)


           az adatok tárolására egy programban változókat használunk
                o   a main() metódus törzsében megadott változókat lokális változóknak nevezzük (pl. nev, kor)
                o   a változókban tárolt adatok típusát a változó elsõ megadásakor (deklarációjakor) adjuk meg a változó
                    neve elõtt
                           az int típusú változókban egész számokat tárolhatunk
                           a String típusú változókban karakterláncokat tárolhatunk
                o   egy változónak az = mûvelettel (operátorral) adhatunk értéket
           a System.out.println() eljárásban paraméterként nemcsak egy szöveget adhatunk meg, hanem egy változót
            (változónevet) is
                o   a program a paraméterként megadott változónak nem a nevét, hanem a tartalmát fogja kiírni a
                    képernyõre


public class Hello1 {
public static void main(String[] args) {
 int kor;
 String nev;
 kor=23;
 nev="Kata";
 System.out.println("Hello!");
 System.out.println(nev);
 System.out.println(kor);
 System.out.println("Program vege.");
 }
}
1.1 variáció (szövegek és változók értékének kiiratása egy sorban)


           a System.out.println() eljárásban paraméterként egyszerre megadhatunk több különbözõ szöveget (konstans
            értéket) és változót (változónevet) + jelekkel elválasztva


public class Hello1a {
public static void main(String[] args) {
 int kor;
 String nev;
 kor=23;
 nev="Kata";
 System.out.println("Hello "+kor+" eves "+nev+"!");
 }
}
1.2 variáció (változók kezdõértékének megadása)


        a változók deklarációjakor lehetõségünk van a változók (kezdõ)értékének a megadására is


public class Hello1b {
public static void main(String[] args) {
 int kor=23;
 String nev="Kata";
 System.out.println("Hello "+kor+" eves "+nev+"!");
 }
}



2. példa (mezõk deklarálása)


        egy osztály tartalmazhat (adat)mezõket (másképpen attribútumokat) is, amelyeket az osztály törzsében adhatunk
         meg (pl. kor, nev)
               o   a mezõkben ténylegesen csak az objektum példányosítása után tárolhatunk adatokat; a példányosítás
                   memóriaterületet rendel az osztály adatmezõihez
        egy objektumpéldányt úgy készíthetünk, hogy a new operátor után meghívjuk az osztály ún.
         konstruktorfüggvényét
               o   a konstruktorfüggvény neve megegyezik az osztály nevével (pl. Hello2())
               o   ha nem deklaráltunk konstruktorfüggvényt, a Java fordító automatikusan létrehoz egy paraméterek
                   nélküli ún. alapértelmezett konstruktorfüggvényt (pl. a Hello2() konstruktorfüggvényt)
               o   a létrehozott új példány címét (referenciáját) értékadással egy olyan lokális változóban tárolhatjuk el,
                   amelynek típusa megegyezik a példányosított osztállyal (pl. h)
        a létrehozott objektumpéldány mezõire az objektumpéldány referenciáját tartalmazó lokális változón keresztül,
         minõsítéssel hivatkozhatunk (pl. h.kor, h.nev)


public class Hello2 {
public int kor;
public String nev;
public static void main(String[] args) {
 Hello2 h=new Hello2();
 h.kor=23;
 h.nev="Kata";
 System.out.println("Hello "+h.kor+" eves "+h.nev+"!");
 }
}
3. példa (eljárások és függvények deklarálása; részletesebben lásd Programok szerkezete)


        egy osztály tartalmazhat metódusokat (függvényeket vagy eljárásokat) is, amelyeket a mezõkhöz hasonlóan az
         osztály törzsében adhatunk meg (pl. getKor(), getNev(), beallit())
                o   a függvények a return kulcsszó után megadott értéket számítják ki, és befejezésük után ezt adják vissza
                           a visszatérési érték típusát a függvény neve elõtt adjuk meg (pl. int getKor() vagy String
                            getNev())
                o   az eljárások befejezõdésük után nem adnak vissza semmilyen értéket (az eljárás törzsében megadott
                    utasítások rendszerint az osztályok adatmezõinek az értékét módosítják)
                           az eljárásokat formálisan úgy adjuk meg, mintha void ("semmilyen") típusú visszatérési értékkel
                            rendelkezõ függvények lennének (pl. void beallit())
                o   a metódusok törzsében közvetlenül hivatkozhatunk az osztály mezõire (pl. return kor; vagy kor=23;)
                o   a metódusok utasításainak tényleges végrehajtása csak az objektum példányosítása után történhet meg
        a létrehozott objektumpéldány metódusait az objektumpéldány referenciáját tartalmazó lokális változón keresztül,
         minõsítéssel hívhatjuk meg (pl. h.getKor() vagy h.beallit();)
                o   az eljárásokat rendszerint utasításokként hívjuk meg (pl. h.beallit();)
                o   a függvényeket meghívhatjuk egy metódus paramétereként; ekkor a függvény által visszaadott értéket az
                    a metódus dolgozza fel, amelynek a paraméterében a függvényt meghívtuk (pl. a System.out.println()
                    metódus kiírja a h.getKor() vagy h.getNev() függvények által visszaadott értékeket)


szintaxis:
public class Hello3 {
public int kor;
public String nev;
public int getKor() {
 return kor;
 }
public String getNev() {
 return nev;
 }
public void beallit() {
 kor=23; // mezõ(k) értékének megadása
 nev="Kata";
 }
public static void main(String[] args) {
 Hello3 h=new Hello3();
 h.beallit();
 System.out.println("Hello "+h.getKor()+" eves "+h.getNev()+"!");
 }
}
szemantika:




     VÉGREHAJTOTT UTASÍTÁS                                             UTASÍTÁS HATÁSA



                                       (1) memóriaterület rendelése a h lokális változóhoz;
                                       (2) a Hello3() objektum egy példányának létrehozása (pl. memóriaterület rendelése a
Hello3 h=new Hello3();
                                       kor és nev mezõkhöz);
                                       (3) a létrehozott objektumpéldány címének beírása a h lokális változóba

h.beallit();                           a h lokális változóban tárolt címû objektumpéldány beallit() eljárásának meghívása

   kor=23;                             a kor mezõ értékének beállítása (23)

   nev="Kata";                         a nev mezõ értékének beállítása ("Kata")

System.out.println(
                                       (1) a a h lokális változóban tárolt címû objektumpéldány getKor() és getNev()
"Hello "+
                                       függvényeinek meghívása;
h.getKor()+
                                       (2) a "Hello "+h.getKor()+" eves "+h.getNev()+"!" kifejezés értékének kiszámítása;
" eves "+
                                       (3) a System.out.println() eljárás meghívása (paraméterként átadva a kiszámított
h.getNev()+
                                       kifejezés értékét)
"!");

   return kor;                         a getKor() függvény értékének visszaadása (23)

   return nev;                         a getNev() függvény értékének visszaadása ("Kata")

   "Hello "+"23"+" eves "+"Kata"+"!"
                                       a kifejezés értékének kiszámítása (megjegyzés: a számként ábrázolt 23 érték
==
                                       automatikusan karakterlánc típusú értékké konvertálódik)
   "Hello 23 éves Kata!"

   System.out.println("Hello 23        a System.out.println() eljárás paraméterében megadott érték kiírása a képernyõre
éves Kata!");                          (Hello 23 éves Kata!)
3.1 variáció (függvény meghívása értékadó utasításban)


         a függvényeket meghívhatjuk egy értékadó utasítás jobb oldalán is; ekkor a függvény által visszaadott értéket az
          értékadó utasítás bal oldalán szereplõ változóban tároljuk el (pl. kor=h.getKor();)


public class Hello3a {
public int kor;
public String nev;
public int getKor() {
 return kor;
 }
public String getNev() {
 return nev;
 }
public void beallit() {
 kor=23;
 nev="Kata";
 }
public static void main(String[] args) {
 Hello3a h=new Hello3a();
 int k;
 String n;
 h.beallit(); // itt állítjuk be a mezõ(k) kezdõértékét
 k=h.getKor();
 n=h.getNev();
 System.out.println("Hello "+k+" eves "+n+"!");
 }
}
3.2 variáció (mezõk kezdõértékének beállítása konstruktorfüggvénnyel)


         a mezõk kezdõértékét rendszerint az osztály konstruktorfüggvényében állítjuk be; ilyenkor az osztály
          példányosítása során automatikusan megtörténik a mezõk kezdõértékének a beállítása is
         a konstruktorfüggvényt olyan metódusként deklaráljuk, amelyben nem adjuk meg a visszatérési érték típusát, és
          a metódus neve megegyezik az osztály nevével (pl. public Hello3b())


public class Hello3b {
public int kor;
public String nev;
public Hello3b() {
 kor=23; // a konstruktor helyettesíti a beallit() metódust
 nev="Kata";
 }
public int getKor() {
 return kor;
 }
public String getNev() {
 return nev;
 }
public static void main(String[] args) {
 Hello3b h=new Hello3b(); // ezután nem kell majd h.beallit();
 int k;
 String n;
 k=h.getKor();
 n=h.getNev();
 System.out.println("Hello "+k+" eves "+n+"!");
 }
}
3.3 variáció (formális paraméterek használata metódusokban)


         a metódusok deklarációjában a név utáni zárójelek között megadhatjuk a metódus (egy vagy több) formális
          paraméterének a típusát és a nevét (pl. setNev(String s))
               o   a metódus törzsében megadott utasításokban formális paramétereket használva a metódust különbözõ
                   bemeneti (input) értékek mellett definiálhatjuk
               o   a formális paraméternek a metódus meghívásakor adhatunk értéket, ezt aktuális paraméternek nevezzük
                   (pl. h.setKor(23); esetén az aktuális paraméter 23)


public class Hello3c {
public int kor;
public String nev;
public void setNev(String s) {
 nev=s; // az eljárás hívásakor megadott paraméter értékét másolja be a mezõbe
 }
public void setKor(int i) {
 kor=i;
 }
public String getNev() {
 return nev;
 }
public int getKor() {
 return kor;
 }
public static void main(String[] args) {
 Hello3c h=new Hello3c();
 String n;
 int k;
 h.setNev("Kata"); // most így állítjuk be a mezõk értékét
 h.setKor(23);
 n=h.getNev();
 k=h.getKor();
 System.out.println("Hello "+k+" eves "+n+"!");
 }
}
3.4 variáció (mezõk nyilvános hozzáférésének megtiltása)


         megfelelõ eljárások és függvények használatával a mezõk értékét be tudjuk állítani és le tudjuk kérdezni (pl. a
          Hello3da osztály kor mezõjének az értékét a setKor(int k) eljárással állíthatjuk be, és a getKor() függvénnyel
          kérdezhetjük le)
               o   ha az adatmezõket a private kulcsszóval deklaráljuk, a metódus adatmezõire más osztályokból nem
                   tudunk közvetlenül hivatkozni (azaz ilyenkor "elrejtjük" az adatmezõket a többi osztály elõl); ilyenkor ún.
                   zárt objektumról beszélünk, amelynek csak a public kulcsszóval deklarált ("nyilvános") metódusaira lehet
                   hivatkozni más osztályokból (pl. a Hello3db osztályból nem hivatkozhatunk h.kor módon a Hello3da
                   osztály private láthatóságú kor mezõjére, viszont hivatkozhatunk pl. h.setKor(23); módon a Hello3da
                   osztály public láthatóságú setKor(int k) metódusára)


public class Hello3da {
private int kor;
private String nev;
public void setNev(String s) {
 nev=s;
 }
public void setKor(int i) {
 kor=i;
 }
public String getNev() {
 return nev;
 }
public int getKor() {
 return kor;
 }
}
public class Hello3db {
public static void main(String[] args) {
 Hello3da h=new Hello3da();
 String n;
 int k;
 h.setNev("Kata");
 h.setKor(23);
 n=h.getNev();
 k=h.getKor();
 System.out.println("Hello "+k+" eves "+n+"!");
 }
}
4. példa (lokális változók használata metódusokban; részletesebben lásd Programok szerkezete)


        a metódusok törzsében is deklarálhatunk lokális változókat a részeredmények tárolására (pl. s az udvozlet()
         függvény törzsében)
        a karakterláncokat (konstansokat) és a String típusú változókat a + (konkatenációs) operátorral fûzhetjük össze
         egy karakterlánccá (pl. "Hello "+kor+" eves "+nev+"!")


public class Hello4 {
public int kor;
public String nev;
public void beallit() {
 kor=23;
 nev="Kata";
 }
public String udvozlet() {
 String s;
 s="Hello "+kor+" eves "+nev+"!";
 return s;
 }
public static void main(String[] args) {
 Hello4 h=new Hello4();
 h.beallit();
 System.out.println(h.udvozlet());
 }
}
4.1 variáció (a toString() függvény használata)


        a toString() függvény String típusú alapértelmezett értéket rendel a Hello4a osztály példányaihoz, amit például a
         példány referenciáját tartalmazó változó "kiíratásával" kérdezhetünk le
                o   ha h objektum (referencia) típusú lokális változó, a System.out.println(h); utasítás egyenértékû a
                    System.out.println(h.toString()); utasítással


public class Hello4a {
public int kor;
public String nev;
public void beallit() {
 kor=23;
 nev="Kata";
 }
public String toString() {
 String s;
 s="Hello "+kor+" eves "+nev+"!";
 return s;
 }
public static void main(String[] args) {
 Hello4a h=new Hello4a();
 h.beallit();
 System.out.println(h);
 }
}
5. példa (metódusok meghívása más metódusokból)


        a metódusok törzsében közvetlenül hivatkozhatunk az osztály metódusaira (pl. a hello() eljárás törzsében a
         beallit(); vagy a System.out.println(udvozlet()); utasításokban)
        a return kulcsszó után nemcsak változót, hanem egy kifejezést is megadhatunk (pl. return "Hello "+kor+" eves
         "+nev+"!";)


public class Hello5 {
public int kor;
public String nev;
public void beallit() {
 kor=23;
 nev="Kata";
 }
public String udvozlet() {
 return "Hello "+kor+" eves "+nev+"!";
 }
public void hello() {
 beallit();
 System.out.println(udvozlet());
 }
public static void main(String[] args) {
 Hello5 h=new Hello5();
 h.hello();
 }
}
5.1 variáció (metódusok meghívása a konstruktorfüggvénybõl)


        a konstruktorfüggvény törzsében is közvetlenül hivatkozhatunk az osztály metódusaira (pl. a Hello5a()
         konstruktorfüggvény törzsében a beallit(); utasításban)


public class Hello5a {
public int kor;
public String nev;
public Hello5a() {
 beallit();
 }
public void beallit() {
 kor=23;
 nev="Kata";
 }
public String udvozlet() {
 return "Hello "+kor+" eves "+nev+"!";
 }
public void hello() {
 System.out.println(udvozlet());
 }
public static void main(String[] args) {
 Hello5a h=new Hello5a();
 h.hello();
 }
}
5.2 variáció (formális paraméterek használata a konstruktorfüggvényben)


         a konstruktorfüggvény deklarációjában a név utáni zárójelek között megadhatjuk a konstruktorfüggvény (egy
          vagy több) formális paraméterének a típusát és a nevét (pl. Hello5b(String n,int k))
              o   a konstruktorfüggvény meghívásakor (példányosításkor) a formális paramétereknek értéket kell adnunk
                  (pl. new Hello5b("Kata",23); esetén az aktuális paraméterek "Kata" és 23)
              o   ha konstruktorfüggvényt deklaráltunk, a Java fordító nem fog automatikusan létrehozni egy paraméterek
                  nélküli alapértelmezett konstruktorfüggvényt (pl. ha csak a Hello5b(String n,int k) konstruktorfüggvényt
                  deklaráljuk, nem hivatkozhatunk a Hello5b() konstruktorfüggvényre)


public class Hello5b {
public int kor;
public String nev;
public Hello5b(String n,int k) {
 kor=k;
 nev=n;
 }
public String udvozlet() {
 return "Hello "+kor+" eves "+nev+"!";
 }
public void hello() {
 System.out.println(udvozlet());
 }
public static void main(String[] args) {
 Hello5b h=new Hello5b("Kata",23); // most így állítjuk be a mezõk kezdõértékét
 h.hello();
 }
}
5.3 variáció (több konstruktorfüggvény deklarálása)


         egyidejûleg több konstruktorfüggvényt is deklarálhatunk (ez az ún. túlterhelés), ha a különbözõ
          konstruktorfüggvények különbözõ számú vagy különbözõ típusú formális paraméterekkel (azaz különbözõ ún.
          szignatúrával) rendelkeznek (pl. Hello5c() és Hello5c(String n,int k) különbözõ szignatúrájú
          konstruktorfüggvények)
               o   a konstruktorfüggvények meghívásakor a híváskor megadott aktuális paraméterek határozzák meg,
                   melyik konstruktorfüggvény fog végrehajtódni (pl. new Hello5c(); esetén a paraméterek nélküli Hello5c()
                   konstruktorfüggvény fog végrehajtódni, new Hello5c("Szilvi",35); esetén pedig a két paraméterrel
                   rendelkezõ Hello5c(String n,int k) konstruktorfüggvény)
               o   egy konstruktorfüggvénybõl egy másik konstruktorfüggvényre a konstruktorfüggvény törzsének elsõ
                   sorában a this kulcsszóval hivatkozhatunk (pl. this("Kata",23); módon a Hello5c() konstruktorfüggvény
                   törzsének elsõ sorában)


public class Hello5c {
public int kor;
public String nev;
public Hello5c(String n,int k) {
 kor=k;
 nev=n;
 }
public Hello5c() {
 this("Kata",23);
 }
public String udvozlet() {
 return "Hello "+kor+" eves "+nev+"!";
 }
public void hello() {
 System.out.println(udvozlet());
 }
public static void main(String[] args) {
 Hello5c h1=new Hello5c();
 Hello5c h2=new Hello5c("Szilvi",35);
 h1.hello();
 h2.hello();
 }
}
6. példa (öröklõdés; részletesebben lásd Programok szerkezete)

                az extends kulcsszóval létrehozhatjuk egy osztály leszármazott osztályát (pl. a Hello6 osztály a Hello5 osztály leszármazottja, azaz a Hello5
                 osztály a Hello6 osztály szülõosztálya lesz)
                a leszármazott osztály örökli a szülõosztály publikus adatmezõit és publikus metódusait; ez az ún. öröklõdés (pl. a Hello6 osztály örökli a
                 Hello5 osztály kor és név adatmezõit és a beallit(), udvozlet(), valamint hello() metódusait)
                a leszármazott osztályban átdefiniálhatjuk a szülõosztálytól örökölt bármelyik metódust; ilyenkor az átdefiniált metódusnak különbözõ
                 változatai léteznek az öröklõdési láncban, ez az ún. polimorfizmus vagy többalakúság (pl. a Hello6 osztályban átdefiniáljuk a beallit()
                 metódust)
                       o       ha egy metódust átdefiniálunk, az összes olyan metódus, amely törzsében meghívja az átdefiniált metódust, az átdefiniálás után
                               automatikusan a metódus új definícióját fogja meghívni akkor is, ha a hívó metódusokat eredetileg a szülõosztályban definiáltuk (ez
                               az ún. dinamikus öröklõdés)


egy ábrával jól szemléltethetjük a a Hello6 osztály és a Hello5 osztály közötti kapcsolatot:
     Hello5
      | void beallit()
      | String udvozlet()
      | void hello() [meghívja a beallit() és udvozlet() metódusokat]
      |
     Hello6
              void beallit()
bár a hello() metódust a Hello5 osztályban definiáltuk, ha a Hello6 osztályból hívjuk meg, a hello() metódus a Hello6 osztályban (át)definiált beallit()
metódust fogja meghívni
public class Hello5 {
public int kor;
public String nev;
public void beallit() {
 kor=23;
 nev="Kata";
 }
public String udvozlet() {
 return "Hello "+kor+" eves "+nev+"!";
 }
public void hello() {
 beallit();
 System.out.println(udvozlet());
 }
public static void main(String[] args) {
 Hello5 h=new Hello5();
 h.hello();
 }
}
public class Hello6 extends Hello5 {
public void beallit() {
 kor=42;
 nev="Szilvi";
 }
public static void main(String[] args) {
 Hello5 h5=new Hello5();
 Hello6 h6=new Hello6();
 h5.hello();
 h6.hello();
 }
}
6.1 variáció (a szülõ osztály konstruktorának automatikus meghívása)


        a leszármazott osztályok konstruktora a konstruktor törzsének elsõ sorában automatikusan meghívja a szülõ
         osztály alapértelmezett (paraméter nélküli) konstruktorát, ha az elsõ sorban nincs semmilyen hivatkozás más
         konstruktorra (pl. az alapértelmezett Hello6a() konstruktor automatikusan meghívja a szülõ osztály Hello5a()
         konstruktorát, így itt is megtörténik a beallit() metódus meghívása)


ha a Hello6a osztályban mi definiálnánk az alapértelmezett konstruktort, ezt
public Hello6a() {
super();
}
módon tehetnénk meg. A szülõ osztály alapértelmezett (paraméterek nélküli) konstruktorára super(); módon
hivatkozhatunk, de ha ezt elmulasztjuk, a Java automatikusan megteszi ezt helyettünk.
public class Hello5a {
public int kor;
public String nev;
public Hello5a() {
 beallit();
 }
public void beallit() {
 kor=23;
 nev="Kata";
 }
public String udvozlet() {
 return "Hello "+kor+" eves "+nev+"!";
 }
public void hello() {
 System.out.println(udvozlet());
 }
public static void main(String[] args) {
 Hello5a h=new Hello5a();
 h.hello();
 }
}
public class Hello6a extends Hello5a {
public String udvozlet()
 return "Szia "+kor+" eves "+nev+"!";
 }
public static void main(String[] args) {
 Hello5a h1=new Hello5a();
 Hello6a h2=new Hello6a();
 h1.hello();
 h2.hello();
 }
}
6.2 variáció (a szülõ osztály konstruktorának közvetlen meghívása)


         A szülõ osztály konstruktorára a super kulcsszóval hivatkozhatunk a leszármazott osztály konstruktorának elsõ
          sorában. (pl. a Hello6b osztály Hello6b(String n,int k) konstruktorának elsõ sorában super(n,k); módon hívjuk
          meg a Hello5b szülõ osztály Hello5b(String n,int k) konstruktorát)
               o   Ha a szülõ osztálynak nincs paraméter nélküli konstruktora, akkor (1) a leszármazott osztályban kötelezõ
                   egy konstruktort definiálnunk, és (2) ennek elsõ sorában kötelezõ a szülõ osztály megfelelõ
                   konstruktorára hivatkoznunk (ezért, ha saját konstruktort definiálunk egy osztályban, minden esetben
                   célszerû egy paraméter nélküli konstruktor definiálása is).


public class Hello5b {
public int kor;
public String nev;
public Hello5b(String n,int k) {
 kor=k;
 nev=n;
 }
public String udvozlet() {
 return "Hello "+kor+" eves "+nev+"!";
 }
public void hello() {
 System.out.println(udvozlet());
 }
public static void main(String[] args) {
 Hello5b h=new Hello5b("Kata",23);
 h.hello();
 }
}
public class Hello6b extends Hello5b {
public Hello6b(String n,int k) {
 super(n,k);
 }
public String udvozlet() {
 return "Szia "+kor+" eves "+nev+"!";
 }
public static void main(String[] args) {
 Hello5b h1=new Hello5b("Zsofi",26);
 Hello6b h2=new Hello6b("Zsuzsi",18);
 h1.hello();
 h2.hello();
 }
}
6.3 variáció (az eddigiek összegzése)
public class Hello5c {
public int kor;
public String nev;
public Hello5c(String n,int k) {
 kor=k;
 nev=n;
 }
public Hello5c() {
 this("Kata",23);
 }
public String udvozlet() {
 return "Hello "+kor+" eves "+nev+"!";
 }
public void hello() {
 System.out.println(udvozlet());
 }
public static void main(String[] args) {
 Hello5c h1=new Hello5c();
 Hello5c h2=new Hello5c("Szilvi",35);
 h1.hello();
 h2.hello();
 }
}
public class Hello6c extends Hello5c {
public Hello6c(String n,int k) {
 super(n,k);
 }
public Hello6c() {
 super();
 }
public String udvozlet() {
 return "Szia "+kor+" eves "+nev+"!";
 }
public static void main(String[] args) {
 Hello5c h1=new Hello5c();
 Hello5c h2=new Hello5c("Zsofi",25);
 Hello6c h3=new Hello6c();
 Hello6c h4=new Hello6c("Zsuzsi",18);
 h1.hello(); //eredeti üzenet alapértelmezett értékekkel (Hello 23 éves Kata!)
 h2.hello(); //eredeti üzenet megadott értékekkel (Hello 25 éves Zsofi!)
 h3.hello(); //átdefiniált üzenet alapértelmezett értékekkel (Szia 23 éves Kata!)
 h4.hello(); //átdefiniált üzenet megadott értékekkel (Szia 18 éves Zsuzsi!)
 }
}
7. példa (új mezõ deklarálása a leszármazott osztályban)


          a leszármazott osztályban a szülõ osztálytól örökölt mezõk mellett további mezõket is deklarálhatunk (pl. a Hello7 osztályban
           a nev2 mezõt)
          ha bõvítjük a leszármazott osztály adatszerkezetét, célszerû lehet a szülõ osztálytól örökölt metódusok módosítása is, hogy a
           leszármazott osztályban deklarált mezõket is kezelni tudják (pl. a Hello7 osztályban módosítjuk a beallit() és udvozlet()
           metódusokat is)
               o     ha egy örökölt metódust módosítunk, a módosított metódusban az eredeti (örökölt) metódusra a super kulcsszóval
                     hivatkozhatunk a módosított metódus bármelyik sorában (pl. a Hello7 osztály beallit() metódusában super.beallit()
                     módon, a a Hello7 osztály udvozlet() metódusában pedig super.udvozlet() módon hivatkozhatunk a Hello5 szülõ
                     osztály beallit() és udvozlet() metódusaira)


public class Hello5 {
public int kor;
public String nev;
public void beallit() {
 kor=23;
 nev="Kata";
 }
public String udvozlet() {
 return "Hello "+kor+" eves "+nev+"!";
 }
public void hello() {
 beallit();
 System.out.println(udvozlet());
 }
public static void main(String[] args) {
 Hello5 h=new Hello5();
 h.hello();
 }
}
public class Hello7 extends Hello5 {
public String nev2;
public void beallit() {
 super.beallit();
 nev2="Csaba";
 }
public String udvozlet() {
 String s;
 s=super.udvozlet()+"\nUdvozol: "+nev2;
 return s;
 }
public static void main(String[] args) {
 Hello7 h=new Hello7();
 h.hello();
 }
}

                                                                                                            Boda István, 2004. szeptember 1.
Programok szerkezete

         Turbo Pascal
             o alprogram nélkül
             o eljáráshívással
             o függvényhívással
             o mindkettõvel (önállóan kidolgozandó feladat)
         Java
             o alprogram nélkül
                     referencia típusú változók
                     csomagok és standard osztályok
             o eljáráshívással
             o függvényhívással (önállóan kidolgozandó feladat)
             o mindkettõvel
             o öröklõdéssel
             o további példák az alapvetõ Java programszerkezetekre




Turbo Pascal program alprogram nélkül
program hello; {programfej-sor}
uses crt; {uses záradék}
{deklarációs rész kezdete; deklarációs utasítások, pl. változók deklarálása}
var i:integer; nev,s:string; {változók deklarálása: változók nevének és típusának megadása}
{deklarációs rész vége}
begin {végrehajtási rész vagy fõprogram kezdete; végrehajtható utasítások, pl. adatbevitel,
mûveletek végzése az adatokon, adatok kiiratása}
clrscr;
write('Neved: ');
readln(nev);
write('Korod: ');
readln(i);
s:='Hello '+nev+'!';
writeln('A(z) ',i,' éves ',nev,' üdvözlése:');
writeln(s);
end. {végrehajtási rész vagy fõprogram vége}
Turbo Pascal program eljárással
program hello1; {programfej-sor}
uses crt; {uses záradék}
{deklarációs rész kezdete; deklarációs utasítások, pl. változók és eljárások deklarálása}
var i:integer; nev,s:string; {ún. globális, a fõprogramban deklarált változók megadása, amelyeknek a
hatásköre a teljes programszövegre, tehát a deklarált alprogramokra és a program végrehajtási
részére is kiterjed}
procedure beolvas; {eljárásfej-sor: a deklarált eljárás nevének megadása}
  begin {eljárás végrehajtási részének kezdete; "kötegbe fogott", az eljárás meghívása során
végrehajtható utasítások megadása}
  write('Neved: ');
  readln(nev); {karaktersorozat beolvasása a billentyûzetrõl és eltárolása a nev globális változóban}
  write('Korod: ');
  readln(i); {karaktersorozat beolvasása a billentyûzetrõl és eltárolása az i globális változóban}
  end; {eljárás végrehajtási részének vége}
{megjegyzés: figyeljük meg, hogy az eljárás két visszatérési értéket "számít ki" (esetünkben
egyszerûen beolvassa õket), és a visszatérési értékeket úgy adja át a fõprogramnak, hogy
megváltoztatja a globális változók értékét}
{deklarációs rész vége}
begin {fõprogram végrehajtási részének kezdete}
clrscr;
beolvas; {eljárás meghívása: az eljárás végrehajtási részében megadott utasítások végrehajtása }
s:='Hello '+nev+'!';
writeln('A(z) ',i,' éves ',nev,' üdvözlése:');
writeln(s);
end. {fõprogram végrehajtási részének vége}
Turbo Pascal program függvényhívással
program hello2; {programfej-sor}
uses crt; {uses záradék}
{deklarációs rész kezdete; deklarációs utasítások, pl. változók és függvények deklarálása}
var i:integer;
    nev,s:string;
function udvozlet:string; {függvényfej-sor: a függvény nevének és a függvény végrehajtási részében
kiszámított visszatérési (output) érték típusának a megadása}
  begin {függvény végrehajtási részének kezdete; "kötegbe fogott", a függvény meghívása során
végrehajtható utasítások megadása}
  udvozlet:='Hello '+nev+'!'; {a függvény visszatérési értékének kiszámítása a nev globális változó
értékébõl és hozzárendelése a függvény nevéhez}
  end; {függvény végrehajtási részének vége}
{megjegyzés: figyeljük meg, hogy a függvény felhasználta, de nem változtatta meg a globális
változók értékét, és a kiszámított visszatérési értéket a függvény nevéhez rendeltük }
{deklarációs rész vége}
begin {fõprogram végrehajtási részének kezdete}
clrscr;
write('Neved: ');
readln(nev);
write('Korod: ');
readln(i);
writeln('A(z) ',i,' éves ',nev,' üdvözlése:');
writeln(udvozlet); {függvény meghívása a writeln eljárás aktuális paramétereként: a függvény
végrehajtási részében megadott utasítások végrehajtása és a függvény nevében visszaadott érték
kiírása}
end. {fõprogram végrehajtási részének vége}
Java program alprogram nélkül
public class Hello1 { /*a Hello nevû osztály deklarálása (v.ö. programfej-sor); a Java programokban a programfejlesztésre
szolgáló 'osztály' fogalma és a végrehajtható program fogalma a 'main' metódus osztályokon belüli elhelyezésével összekapcsolódik */
/*megjegyzés: a Hello osztály alábbi forráskódját - figyelve a nagy- és kisbetûk közötti különbségekre - a Hello.java nevû fájlba kell
kimentenünk, majd lefordítanunk a javac fordítóval és a fordítás után kapott Hello.class ún. bájtkódú programot futtatnunk a java
értelmezõvel, az ún. "Java Virtuális Géppel" (JVM)*/
public static void main(String[] args) {         /*a main metódus deklarálása; v.ö. fõprogram kezdete, amely Java programok esetén
deklarációs és végrehajtási részt is tartalmazhat, bár a deklarációs rész korlátozottabb lehetõségekkel rendelkezik, mint Turba Pascal
esetén (ti. csak lokális változókat deklarálhatunk benne)*/
/*(lokális) változók deklarálása a main() metódusban; v.ö. deklarációs rész kezdete*/

int kor;    /*a kor egyszerû vagy elemi (int, egész) típusú változó deklarálása*/

String nev=new String();         /*a nev összetett, ún. referencia vagy osztály-típusú változó deklarálása; a deklarálással egyidõben a
new operátorral és a meghívott String() ún. konstruktor-függvénnyel a String osztály egy példányát hozzuk létre; a konstruktor-
függvény (egyebek között) memória-területet és kezdõértékeket rendel a String osztály elemváltozóihoz (esetünkben a 'nev' változó
kezdõértéke az üres sztring lesz)*/
/*megjegyzés: a main statikus metódusban elemi típusú lokális változók esetén automatikusan megtörténik a memória-terület
hozzárendelése, így nincs szükség a new operátor használatára, referencia-típusú lokális változók esetén viszont ezt (majdnem)
mindig nekünk kell megtennünk. A "példányosítást" közvetlenül a deklarációval egyidõben vagy késõbb, a deklaráció után is
megtehetjük, például egy nev=new String("Kata"); értékadó utasítással (ilyenkor a deklarációs részben egyszerûen String s;
szerepelhet). A String osztály egyébként sok szempontból úgy "viselkedik", mintha elemi típus lenne, például sem a new operátort,
sem a String() konstruktor-függvényt nem kötelezõ használnunk, mivel egy értékadás automatikusan létrehozza a String osztály egy
példányát: pl. a nev="Kata"; értékadó utasítás ugyanazt jelenti, mint a nev=new String("Kata"); értékadás */
/*változók deklarálásának vége; v.ö. deklarációs rész vége*/
/*végrehajtható utasítások megadásának kezdete a main() metódusban; v.ö. fõprogram végrehajtási részének kezdete (a Java nyelv
esetén egyébként a deklarálási és végrehajtási rész nem válik olyen mereven el, mint a Turbo Pascal nyelvben, mivel bármikor
lehetõségünk van pl. új lokális változók deklarálására, és az új változók deklarálását mindig kiegészíthetjük egy kezdõérték-adó
utasítással)*/
nev="Kata";       /*az egyszerûség kedvéért nem foglalkozunk az adatok beolvasásával a billentyûzetrõl, ezért egyszerûen értéket
adunk a programból a nev változónak; az elõzõ megjegyzésnek megfelelõen az értékadás megfelel a nev=new String("Kata");
értékadásnak*/
kor=23;
System.out.println("A "+kor+" eves "+nev+" udvozlese: "+"Hello "+nev+"!"); /*ebben az utasításban a System
standard osztályban levõ PrintStream osztálytípusú out (statikus) elemváltozó println() metódusának meghívásával adatokat írunk ki a
képernyõre; figyeljük meg, hogy a println() metódusban az idézõjelek közé zárt szövegek (például "A " vagy " eves"), valamint a kor és
nev nevû változók összekapcsolása a + összefûzõ (konkatenációs) operátorral történik meg (ékezetes karaktereket a különbözõ
platformok - DOS, Windows, Linux, UNIX, stb. - eltérõ kódolási konvenciói miatt nem célszerû használnunk)*/
/*megjegyzés: a System standard osztály a java.lang csomagban van definiálva; a java.lang csomagban definiált osztályok mindig
elérhetõek, így nem kell például a System osztályra java.lang.System módon hivatkoznunk (lásd még: csomagok és standard
osztályok)*/
/*végrehajtható utasítások megadásának vége; v.ö. fõprogram végrehajtási részének vége*/
}   /*a main() metódus deklarációjának vége*/

}   /*a Hello nevû osztály deklarálásának vége*/
referencia-típusú változók - jegyezzük meg:

Referencia-típusú lokális változók esetén célszerû a deklarációval egyidõben a változók egy példányát
létrehoznunk a new operátorral és a referencia-típusnak megfelelõ konstruktor-függvény meghívásával (és
esetleg a kezdõérték megadásával).
Például: String nev=new String("Kata"); vagyHello h=new Hello();



csomagok és standard osztályok (a System és PrintStream standard osztályok helye a csomagok
hierarchiájában Java(TM) 2 SDK, Standard Edition, Version 1.4.0 Beta esetén)

      com
      java
           o   applet
           o   awt
           o   beans
           o   io
                       ...
                       PrintStream.java
                             package java.io;
                             public class PrintStream extends FilterOutputStream {
                             ...
                                 public void println(String x) {
                             ...
                       ...
           o   lang
                       ...
                       System.java
                             package java.lang;
                             import java.io.*;
                             ...
                             public final class System {
                             ...
                                 public final static PrintStream out = nullPrintStream();
                             ...
                       ...
           o   math
           o   ...
      javax
      ...

Jegyezzük meg: a java.io.PrintStream osztályban deklarált println() metódust az általunk készített Java
programokban, amikor a képernyõre akarunk egy adatot kiírni, a System osztály PrintStream osztálytípusú
out (statikus) elemváltozóján keresztül hívjuk meg [java.lang.]System.out.println() módon; itt a szögletes
zárójelek arra utalnak, hogy a java.lang "elérési utat" nem kötelezõ kitennünk
Java program eljáráshívással
public class Hello3 { /*a Hello3 nevû osztály deklarálása*/
/*mezõk deklarálásának kezdete; a mezõk a Hello3 osztály minden (nem statikus) metódusából közvetlenül elérhetõk lesznek*/
/*megjegyzés: a main() statikus metódusban elõbb "példányosítani" kell a Hello3 osztályt pl. Hello3 h=new Hello3(); módon; ezután a
deklarált mezõk a Hello3 osztály létrehozott h objektumpéldányának elemváltozóiként lesznek elérhetõek h.kor vagy h.nev módon)*/
public int kor;
public String nev;        /*referencia-típusú mezõk esetén - ellentétben a lokális változókkal - nem szükséges a mezõ egy példányát
létrehoznunk, mivel a teljes osztály (esetünkben a Hello3 osztály) példányosításakor ez automatikusan megtörténik */
/*mezõk deklarálásának vége*/

public void beallit() {       /*a Hello3 osztály beallit() metódusának deklarálása*/

nev="Kata";         /*a Hello3 osztály metódusaiból a Hello3 osztály mezõi közvetlenül elérhetõek!*/

kor=23;
}   /*a beallit() metódus deklarálásának vége*/

public static void main(String[] args) {           /*a main metódus deklarálása*/
/*(lokális) változók deklarálásának kezdete a main metódusban*/

String s=new String();
Hello3 h=new Hello3();           /*a Hello3 osztálytípusú h lokális változó deklarálása és a deklarációval egyidõben a Hello3 osztály egy
példányának létrehozása; ahhoz, hogy a main() statikus metódusból elérhessük a Hello3 osztály mezõit és metódusait, elõbb létre kell
hozni a Hello3 osztály egy h példányát*/
/*jegyezzük meg: ha mi nem deklarálunk saját konstruktorfüggvényt, akkor ezt megteszi helyettünk a Java fordító a következõ
utasítások beszúrásával:
public Hello3() {
super();
}
így tehát nyugodtan hivatkozhatunk a Hello3() (paraméter nélküli) alapértelmezett konstruktorfüggvényre. Figyeljük meg, hogy a fenti
deklarációban nem kell típust megadni, a konstruktorfüggvény neve pedig pontosan megegyezik az osztály nevével. A 'super'
azonosító az osztály szülõosztályára, a super(); metódushívás pedig a szülõosztály konstruktorfüggvényének meghívására utal.
Esetünkben a Hello3 osztály szülõosztálya a standard
public class Object
osztály, amely minden Java objektum õsobjektuma, azaz az osztályhierarchia kiinduló vagy gyökéreleme.*/
/*(lokális) változók deklarálásának vége*/
/*végrehajtható utasítások megadásának kezdete a main metódusban*/

h.beallit();    /*csak a h lokális változón keresztül érhetjük el a Hello3 osztály beallit() metódusát*/

s="A "+h.kor+" eves "+h.nev+" udvozlese: "+"Hello "+h.nev+"!"; /*ez nem túl szép megoldás, mivel itt közvetlenül
hivatkozunk a h.kor, ill. h.nev elemváltozókra (vagyis nem valamelyik, Hello3-ban definiált metóduson keresztül érjük el õket), ami
nincs összhangban az objektumok zártságának elvével - de persze mûködik*/
System.out.println(s);
/*végrehajtható utasítások megadásának vége*/
}   /*a main() metódus deklarációjának vége*/

}   /*a Hello3 nevû osztály deklarálásának vége*/
Java program eljárás- és függvényhívással
public class Hello4 {
public int kor;
public String nev;
public void beallit() {
nev="Kata";
kor=23;
}
public String udvozlet() {       /*a Hello4 osztály udvozlet() metódusának (függvényének) deklarálása*/
/*(lokális) változók deklarálásának kezdete az udvozlet() metódusban*/

String s=new String();
/*(lokális) változók deklarálásának vége*/

s="A "+kor+" eves "+nev+" udvozlese: "+"Hello "+nev+"!"; /*vegyük észre, hogy a metóduson belül
közvetlenül hivatkozhatunk a kor és nev mezõkre; mivel így a main metódusból nem közvetlenül, hanem az udvozlet()
metóduson keresztül fogjuk elérni õket, nem sértjük meg az objektumok zártságának elvét */
return s;      /*a függvény visszatérési értékének megadása; függvények esetén mindig kötelezõ megadnunk (legalább
egy) return utasítást*/
}   /*az udvozlet() metódus deklarálásának vége*/

public static void main(String[] args) {
Hello4 h=new Hello4();
h.beallit();
System.out.println(h.udvozlet());
}
}
Java program öröklõdéssel
/*Hello5.java: a Hello6 osztály szülõ- vagy õsosztálya; a beallit() metódus beállítja a kor és nev mezõk értékét, a hello() metódus pedig kiírja õket a
képernyõre*/
/*megjegyzés: Ha a Hello5 osztályt nem deklaráljuk publikusnak (public class Hello5 { ... } módon), a Hello5 osztály forráskódja elhelyezhetõ a
Hello6.java fájlban is; ilyenkor a javac fordító külön fogja létrehozni a Hello5.class és Hello6.class állományokat. Egyébként a Hello5.java és Hello6.java
fájlokat (pontosabban a lefordításuk után kapott Hello5.class és Hello6.class fájlokat) nekünk kell ugyanabban az alkönyvtárban elhelyezni.*/
public class Hello5 {
public int kor;
public String nev;
public void beallit() {
    nev="Kata";
    kor=23;
    }
public void hello() {
    beallit(); /*a beallit() metódust a hello() metódus hívja meg*/
    System.out.println("A "+kor+" eves "+nev+" udvozlese: "+"Hello "+nev+"!");
    }
}
/*Hello6.java: a Hello5 osztály leszármazottja, örökli a kor és nev metódusokat, valamint a beallit() és hello() metódusokat, amelyek közül a beallit()
metódust felüldefiniálja*/
public class Hello6 extends Hello5 {
public void beallit() {      /*polimorf metódus: a Hello5 õsosztályban is létezik*/

    nev="Zsuzsa";
    kor=25;
    }
public static void main(String[] args) {
    Hello5 h5=new Hello5();
    Hello6 h6=new Hello6();
    h5.hello();
    h6.hello();
    }
/*a Hello5 osztály h5 példányának hello() metódusa a Hello5 (õs)osztály beallit() metódusát fogja meghívni, a Hello6 osztály h6 példányának hello()
metódusa pedig a Hello6 osztályban (át)definiált beallit() metódust, így a képernyõn két különbözõ üzenet fog megjelenni*/
}

                                                                                                                               Boda István, 2003. november 2.
Összetett programszerkezetek


8. példa (a Java adattípusai)
import java.util.*;
public class Adattipusok {
public static void main(String[] args) {
byte b1=-128,b2=127;
short s1=-32768,s=0x2a,s2=32767;
int i1=(int)(-Math.pow(2,31)),i=0xe1,i2=(int)(Math.pow(2,31)-1);
long l1=(long)(-Math.pow(2,63)),l=160L,l2=(long)(Math.pow(2,63)-1);
char c='\u002a',cA=(char)65,ca='a',caaWIN=(char)i,caaDOS=(char)l;
String sz="\u002a Hello! \u002a";
boolean bF=false,bT=true;
float f1=(float)Math.PI,f=(float)1/3,f2=1e18F;
double d1=Math.PI,d2=1.234e-2D;
String lotto[]={"4","12","33","65","78"};
List llist=Arrays.asList(lotto);
System.out.println("b1 = "+b1+"         b2 = "+b2);
System.out.println("s1 = "+s1+"         s = "+s+"      s2 = "+s2);
System.out.println("i1 = "+i1+"        i = "+i+"     i2 = "+i2);
System.out.println("l1 = "+l1+"        l = "+l+"     l2 = "+l2);
System.out.println("c = "+c+"        cA = "+cA+
                      "   ca = "+ca+
                      "   ca'(WIN) = "+caaWIN+
                      "   ca'(DOS) = "+caaDOS);
System.out.println("sz = "+sz);
System.out.println("bF = "+bF+"          bT = "+bT);
System.out.println("f1 = "+f1+"        f = "+f+"     f2 = "+f2);
System.out.println("d1 = "+d1+"         d2 = "+d2);
System.out.println("lotto.length = "+lotto.length+" (tomb elemszama)");
System.out.println("lotto[] = "+llist+" (listakent kiirva)");
System.out.println("       lotto[0] = "+lotto[0]);
System.out.println("       lotto[1] = "+lotto[1]);
System.out.println("       lotto[2] = "+lotto[2]);
System.out.println("       lotto[3] = "+lotto[3]);
System.out.println("       lotto[4] = "+lotto[4]);
}
}
9. példa (a Java operátorai)
public class Muveletek {
public static void main(String[] args) {
 int i=65;
 double j=2.71;
 boolean b=false;
 System.out.println("i = "+i+", j = "+j);
 System.out.println("***** Unaris muveletek: *****");
 System.out.println("i++ = "+(i++)+", i = "+i);
 System.out.println("i-- = "+(i--)+", i = "+i);
 System.out.println("i = "+i+", ++i ="+(++i));
 System.out.println("i = "+i+", --i ="+(--i));
 System.out.println("i = "+i+", -i = "+(-i)+", -(-i) = "+(-(-i)));
 System.out.println("b = "+b+", !b = "+!b+", !!b = "+!!b);
 System.out.println("(char)i = "+(char)i+", (short)'A' = "+(short)'A');
 System.out.println("(double)i = "+(double)i);
 System.out.println("(int)j = "+(int)j);
 System.out.println("***** Binaris muveletek: *****");
 System.out.println("(i + j) = "+(i+j)+", (i - j) = "+(i-j));
 System.out.println("(i * j) = "+(i*j)+", (i / j) = "+(i/j));
 System.out.println("(i / (int)j) = "+(i/(int)j));
 System.out.println("(i % (int)j) = "+(i%(int)j));
 System.out.println("(i <= j) = "+(i<=j)+", (i > j) = "+(i>j));
 System.out.println("(i == j) = "+(i==j)+", (i != j) = "+(i!=j));
 System.out.println("(i <= j) && (i > j) = "+(i<=j && i>j));
 System.out.println("(i <= j) || (i > j) = "+(i<=j || i>j));
 System.out.println("(i<j ? \"i kisebb\" : \"j kisebb\") = "+(i<j?"i kisebb":"j kisebb"));
 }
}
10. példa (a Java függvényei)
public class Fuggvenyek {
public static void main(String[] args) {
double d;
int i;
String s;
System.out.println("2.7 kerekitve: "+Math.round(2.7)+
            ",   3.1 kerekitve: "+Math.round(3.1));
System.out.println("-4 abszolut erteke: "+Math.abs(-4));
System.out.println("225 binarisan: "+Integer.toBinaryString(225)+
            ",   225 hexadecimalisan: "+Integer.toHexString(225));
System.out.println("2 negyzetgyoke: "+Math.sqrt(2));
System.out.println("2^15 (hatvanyozas): "+Math.pow(2,15));
System.out.println("egy veletlen valos szam a [0,1) intervallumbol: "+Math.random());
System.out.println("                   egy masik veletlen szam: "+Math.random());
System.out.println("PI erteke: "+Math.PI+",       e erteke: "+Math.E);
d=(long)(Math.PI*1e4)/1e4;
System.out.println("      PI erteke 4 tizedesjegyre vagva: "+d);
d=Math.round((Math.PI*1e4))/1e4;
System.out.println("      PI erteke 4 tizedesjegyre kerekitve: "+d);
d=Math.toRadians(75);
System.out.println("75 fok = "+d+" radian");
System.out.println("75 fok szogfuggvenyei: ");
System.out.println("      sin(75) = "+Math.sin(d));
System.out.println("      cos(75) = "+Math.cos(d));
System.out.println("       tg(75) = "+Math.tan(d));
System.out.println("PI radian = "+Math.toDegrees(Math.PI)+" fok");
System.out.println("e^2 = "+Math.exp(2)+",         ln(8) = "+Math.log(8));
s="3";i=Integer.parseInt(s);
System.out.println("Integer.parseInt(\"3\") = "+i+" (egesz szam)");
i=-25;s=String.valueOf(i);
System.out.println("String.valueOf(-25) = \""+s+"\" (string)");
s="Hello!";
System.out.println("s = "+s);
System.out.println("s.length() = "+s.length()+
            ",   s.charAt(5) = "+s.charAt(5)+
            ",   s.substring(1,5) = "+s.substring(1,5));
System.out.println("s.equals(\"Szia!\") = "+s.equals("Szia!")+
            ",   s.compareTo(\"Szia!\") = "+s.compareTo("Szia!"));
}
}
11. példa (statikus mezõk és metódusok; egy- és kétirányú elágazás)
public class KesDij {
public static final int DIJ=100;
public static final int LEJARAT=10;
public int napok;
public double fizetendo;
public KesDij(int n) {
napok=n;
fizetendo=kiszamit(napok);
}
public synchronized static double kiszamit(int n) {
double f;
if (n<=LEJARAT) {
    f=0;
    }
else {
    f=(n-LEJARAT)*DIJ;
    }
return f;
}
public void kiir() {
int i=napok-LEJARAT;
System.out.println("Eltelt napok szama: "+napok);
System.out.println("Kolcsonzesi ido lejarata: "+LEJARAT+" nap");
System.out.println((i>0?"Kesedelmes":"Hatralevo")+" napok szama: "+(int)Math.abs(i));
if(fizetendo>0) {
    System.out.println("Kesedelmi dij: "+DIJ+" Ft/nap");
    System.out.println("Fizetendo: "+fizetendo+" Ft");
    }
System.out.println("-----------------------------");
}
public static void main(String[] args) {
        KesDij k0=new KesDij(5);
        KesDij k1=new KesDij(10);
        KesDij k2=new KesDij(25);
        KesDij k3=new KesDij(40);
        k0.kiir();
        k1.kiir();
        k2.kiir();
        k3.kiir();
        }
}
12.példa (parancssori paraméterek és kivételkezelés)
public class MinMax {
public static int min(int x,int y,int z) {
    return Math.min(Math.min(x,y),z);
    }
public static int mid(int x,int y,int z) {
    int w1=Math.min(x,y);
    int w2=Math.max(x,y);
    if(z<w1) return w1;
    else if(z<w2) return z;
    else return w2;
    }
public static int max(int x,int y,int z) {
    return Math.max(Math.max(x,y),z);
    }
public static void main(String[] args) {
    int i,j,k;
    try {
        i=Integer.parseInt(args[0]);
        j=Integer.parseInt(args[1]);
        k=Integer.parseInt(args[2]);
        System.out.println("A legkisebb szam: "+min(i,j,k));
        System.out.println("A kozepso szam:    "+mid(i,j,k));
        System.out.println("A legnagyobb szam: "+max(i,j,k));
        }
    catch(Exception e) {
        System.out.println("Legkozelebb adj meg harom szamot!");
        }
    }
}
13. példa (többirányú elágazás)
public class NegativJegyException extends Exception {
}
public class Jegyek {
public int jegy;
public Jegyek(int j) throws NegativJegyException {
 if(j<0) throw new NegativJegyException();
 jegy=j;
 }
public void kiir() {
 String s;
 switch(jegy) {
    case 1: s="egyes"; break;
    case 2: s="kettes"; break;
    case 3: s="harmas"; break;
    case 4: s="negyes"; break;
    case 5: s="otos"; break;
    default: s="???";
    }
 System.out.println("A megadott jegy: "+jegy+" ("+s+")");
 }
public static void main(String[] args) {
 int i;
 try {
    i=Integer.parseInt(args[0]);
    }
 catch(Exception e) {
    i=1;
    }
 try {
    Jegyek j=new Jegyek(i);
    j.kiir();
    }
 catch(NegativJegyException e) {
    System.out.println("Negativ jegy nincs!!!");
    }
 }
}
14. példa (ciklusok)
public class Szamok {
public static void main(String[] args) {
 int i,n=10;
 System.out.println("------------------------------");
 System.out.println("Az elso "+n+" egesz szam (while):");
 i=1;
 while(i<=n){
    System.out.print(i+(i!=n?", ":""));
    i++;
    }
 System.out.println();
 System.out.println("Az elso "+n+" egesz szam (for):");
 for(i=1;i<=n;i++){
    System.out.print(i+(i!=n?", ":""));
    }
 System.out.println();
 System.out.println("Az elso "+n+" egesz szam (do):");
 i=1;
 do{
    System.out.print(i+(i!=n?", ":""));
    i++;
    }while(i<=n);
 System.out.println();
 System.out.println("------------------------------");
 }
}
15. példa (összegzés 1)
public class tulNagySzamException extends Exception {
public tulNagySzamException() {
 super();
 }
public tulNagySzamException(String s) {
 super(s);
 }
}
public class Negyzet {
public int n;
public int[] szamok;
public Negyzet(int i) throws tulNagySzamException {
 if(i>20) throw new tulNagySzamException(i+" tul nagy!");
 n=i;
 szamok=new int[n];
 }
public Negyzet() {
 n=10;
 szamok=new int[10];
 }
public static String ketjegyuSzam(int i) {
 if(i<0 || i>99) return "??";
 if(i<=9) return "0"+i;
 else return String.valueOf(i);
 }
public static String haromjegyuSzam(int i) {
 String s;
 if(i<0) s="-??";
 else if(i<=9) s="00"+i;
 else if(i<=99) s="0"+i;
 else if(i<=999) s=String.valueOf(i);
 else s="+??";
 return s;
 }
public void kiir() {
 int i;
 String s2,s3;
 System.out.println("Az elso "+n+" negyzetszam:");
 for(i=1;i<=n;i++){
    s2=ketjegyuSzam(i);
    s3=haromjegyuSzam(i*i);
    System.out.println("i = "+s2+",   "+s2+"*"+s2+" = "+s3);
    }
 }
public static void main(String[] args) throws tulNagySzamException {
Negyzet x10=new Negyzet();
x10.kiir();
Negyzet x7=new Negyzet(7);
x7.kiir();
Negyzet x77=new Negyzet(77);
x77.kiir();
}
}
16. példa (összegzés 2)
public class Lotto {
public static final int OTOS=5;
public static final int HATOS=6;
private byte szamos;
private int[] lotto;
public Lotto(int n) throws Exception {
 switch(n) {
    case OTOS: lotto=new int[OTOS];szamos=OTOS;break;
    case HATOS: lotto=new int[HATOS];szamos=HATOS;break;
    default: throw new Exception("Nincs "+n+" szamos lotto!");
    }
 beallit();
 }
public void beallit() {
 int i,j;
 boolean[] kihuz=new boolean[90];
 for(j=0;j<90;j++) {
    kihuz[j]=false;
    }
 i=0;
 while(i<szamos) {
    j=(int)(90*Math.random());
    if(!kihuz[j]) {
     kihuz[j]=true;
     i++;
     }
    }
 i=0;
 for(j=0;j<90;j++) {
    if(kihuz[j]) {
     lotto[i]=j+1;
     i++;
     }
    }
 }
public void kiir() {
int i;
System.out.println("A javasolt szamok ("+szamos+" szamos lotto):");
for(i=0;i<szamos;i++) {
 System.out.println("      A(z) "+(i+1)+". lottoszam: "+lotto[i]);
 }
System.out.println("--------------------------------------------");
}
public static void main(String[] args) throws Exception {
    Lotto p5=new Lotto(5);
    p5.kiir();
    Lotto p6=new Lotto(6);
    p6.kiir();
    Lotto p7=new Lotto(7);
    p7.kiir();
    }
}




                                                            Boda István, 2004. szeptember 2.
Grafikus programszerkezetek

1. példa (egyszerû grafikus alakzatok kirajzolása)

      ElsoApplet.java
      ElsoApplet.html




2. példa (egyszerû grafikus eljárások használata I.)

      MasodikApplet.java
      MasodikApplet.html
3. példa (egyszerû grafikus eljárások használata II.)

      HarmadikApplet.java
      HarmadikApplet.html




4. példa (számok bevitele és összeadása)

      NegyedikApplet.java
      NegyedikApplet.html
5. példa (egyszerû számológép kialakítása)

      OtodikApplet.java
      OtodikApplet.html




Kiegészítõ példa - haladók számára (egyszerû alakzatok kirajzolása interaktívan)

      Alakzatok.java
      Alakzatok.html




                                                                             Boda István, 2004. november 23.
ElsoApplet.java

/* a használt osztályok metódusok és konstansok:

public abstract class java.awt.Component
| public void paint(Graphics g)
| public void setBackground(Color c)
|
public class java.applet.Applet
|
|
public class ElsoApplet
   public void paint(Graphics g)

-----------------

public class public class java.awt.Font
   public static final int BOLD
   public static final int ITALIC
   public static final int PLAIN

     public Font(String name, int style, int size)

-----------------

public abstract class java.awt.Graphics
   public abstract void drawLine(int x1, int y1, int x2, int y2)
   public abstract void drawOval(int x, int y, int w, int h)
   public void drawPolygon(int[] xP, int[] yP, int n)
   public void drawRect(int x1, int y1, int w, int h)
   public abstract void drawString(String s, int x, int y)
   public abstract void fillOval(int x, int y, int w, int h)
   public abstract void fillPolygon(int[] xP, int[] yP, int n)
   public abstract void fillRect(int x, int y, int w, int h)
   public abstract void setColor(Color c)
   public void setFont(Font f)

-----------------

public class java.awt.Color
   public static final Color black
   public static final Color blue // Hue=2/3f
   public static final Color cyan // Hue=1/2f
   public static final Color darkGray
   public static final Color gray
   public static final Color green // Hue=1/3f
   public static final Color lightGray
   public static final Color magenta // Hue=5/6f
   public static final Color orange
   public static final Color pink
   public static final Color red // Hue=0f
   public static final Color white
   public static final Color yellow // Hue=1/6f

     public Color(int r, int g, int b)
     public static Color getHSBColor(float h, float s, float b)

*/

import java.awt.*;
import java.applet.*;
public class ElsoApplet extends Applet {

public void paint(Graphics g) {
 Color hatterszin=new Color(255,213,192);
 Color betuszin1=Color.black;
 Color betuszin2=Color.blue;
 Color betuszin3=Color.red;
 Color rajzoloszin1=Color.getHSBColor(1/6f,1f,1f);
 Color rajzoloszin2=Color.getHSBColor(5/6f,1f,1f);
 Color rajzoloszin3=Color.getHSBColor(1/2f,1f,1f);
 Color rajzoloszin4=Color.getHSBColor(1/3f,1f,1f);
 Color rajzoloszin5=Color.getHSBColor(1/3f,1f,1/2f);
 Color rajzoloszin6=Color.getHSBColor(0f,0f,0f);
 Font font1=new Font("Courier",Font.BOLD,24);
 Font font2=new Font("Arial",Font.ITALIC,24);
 Font font3=new Font("Times New Roman",Font.BOLD+Font.ITALIC,24);

 setBackground(hatterszin);
 g.setColor(rajzoloszin1);
 g.drawLine(0,0,400,300);
 g.setColor(rajzoloszin2);
 g.fillRect(150,100,100,100);
 g.setColor(rajzoloszin6);
 g.drawRect(150,100,100,100);
 g.setColor(rajzoloszin1);
 g.drawLine(399,0,0,300);
 g.setColor(rajzoloszin3);
 int[] xP={150,240,195},yP={50,50,120};
 g.fillPolygon(xP,yP,3);
 g.setColor(rajzoloszin6);
 g.drawPolygon(xP,yP,3);
 g.setColor(rajzoloszin4);
 g.fillOval(200,180,80,60);
 g.setColor(rajzoloszin6);
 g.drawOval(200,180,80,60);
 g.setColor(betuszin1);
 g.setFont(font1);
 g.drawString("Hello in Courier BOLD!",20,60);
 g.setColor(betuszin2);
 g.setFont(font2);
 g.drawString("Hello in Arial ITALIC!",100,150);
 g.setColor(betuszin3);
 g.setFont(font3);
 g.drawString("Hello in Times BOLD+ITALIC!",20,240);
 g.setColor(rajzoloszin5);
 g.drawLine(0,200,399,200);
 g.drawLine(0,202,399,202);
 g.drawLine(300,0,300,299);
 g.drawLine(302,0,302,299);
 }

}
MasodikApplet.java

import java.awt.*;
import java.applet.*;

public class MasodikApplet extends Applet {

public int x,y,w,h;
public float c;

public void teglalapok(Graphics g) {
 float hue=c;
 do {
  g.setColor(Color.getHSBColor(hue,1f,1f));
  g.fillRect(x,y,w,h);
  hue+=0.03f; //következő színárnyalat-érték
  x+=4;y+=3;w-=8;h-=6;
  } while(w>0 && h>0);
 }

public void ellipszisek(Graphics g) {
 float sat=0;
 do {
  g.setColor(Color.getHSBColor(c,sat,1f));
  g.fillOval(x,y,w,h);
  sat+=0.05f; //következő telítettség-érték
  x+=4;y+=3;w-=8;h-=6;
  } while(w>0 && h>0);
 }

public void vizszintes_vonalak(Graphics g) {
 int ymax=y+h;
 float bri=1;
 do {
  g.setColor(Color.getHSBColor(c,1f,bri));
  g.drawLine(x,y,x+w,y);
  bri-=0.02f; //következő fényerő-érték
  y++;
  } while(y<=ymax);
 }

public void fuggoleges_vonalak(Graphics g) {
 int xmax=x+w;
 float bri=1;
 do {
  g.setColor(Color.getHSBColor(c,1f,bri));
  g.drawLine(x,y,x,y+h);
  bri-=0.02f; //következő fényerő-érték
  x++;
  } while(x<=xmax);
 }

public void paint(Graphics g) {
 x=10;y=10;w=240;h=180;c=0f;
 teglalapok(g);
 x=200;y=50;w=160;h=120;c=0f;
 ellipszisek(g);
 x=200;y=150;w=160;h=120;c=1/3f;
 ellipszisek(g);
 x=100;y=150;w=160;h=120;c=2/3f;
 ellipszisek(g);
 x=10;y=250;w=380;h=40;c=3/6f;
 vizszintes_vonalak(g);
 x=350;y=10;w=40;h=280;c=5/6f;
 fuggoleges_vonalak(g);
 }

}
HarmadikApplet.java

/* a használt osztályok mezők és metódusok:

public class MasodikApplet
 | public int x,y,w,h;
 | public float c;
 |
 | public void teglalapok(Graphics g)
 | public void ellipszisek(Graphics g)
 | public void vizszintes_vonalak(Graphics g)
 | public void fuggoleges_vonalak(Graphics g)
 | public void paint(Graphics g)
 |
public class HarmadikApplet
   public int r,n;

     public void vizszintes_vonalak_2(Graphics g)
     public void fuggoleges_vonalak_2(Graphics g)
     public void prizma(Graphics g)
     public void szinkor(Graphics g)
     public void szinkorok(Graphics g)
     public void csillag(Graphics g)
     public void paint(Graphics g)

*/

import java.awt.*;
import java.applet.*;

public class HarmadikApplet extends MasodikApplet {

public int r,n;

public void vizszintes_vonalak_2(Graphics g) {
 int ymax=y+h;
 float hue=c;
 do {
  g.setColor(Color.getHSBColor(hue,1f,1f));
  g.drawLine(x,y,x+w,y);
  hue+=0.002f; //következő színárnyalat-érték
  y++;
  } while(y<=ymax);
 }

public void fuggoleges_vonalak_2(Graphics g) {
 int xmax=x+w;
 float hue=c;
 do {
  g.setColor(Color.getHSBColor(hue,1f,1f));
  g.drawLine(x,y,x,y+h);
  hue+=0.005f; //következő színárnyalat-érték
  x++;
  } while(x<=xmax);
 }

public void prizma(Graphics g) {
 int xmax=x+w,x0=x+w/2,y1=y+h;
 float hue=c;
 do {
  g.setColor(Color.getHSBColor(hue,1f,1f));
  g.drawLine(x0,y,x,y1);
  hue+=0.004f; //következő színárnyalat-érték
  x++;
  } while(x<=xmax);
 }

public void szinkor(Graphics g) {
 int x0=x,x1,y0=y-r,y1;
 int[] xP=new int[3],yP=new int[3];
 float hue=0;
 double fi;
 do {
  g.setColor(Color.getHSBColor(hue,1f,1f));
  fi=2.0*hue*Math.PI;
  x1=(int)(r*Math.sin(fi))+x;
  y1=y-(int)(r*Math.cos(fi));
/* g.drawLine(x,y,x1,y1); */
  xP[0]=x;yP[0]=y;
  xP[1]=x0;yP[1]=y0;
  xP[2]=x1;yP[2]=y1;
  g.fillPolygon(xP,yP,3);
  x0=x1;y0=y1;
  hue+=0.001f; //következő színárnyalat-érték
  } while(hue<=1);
 }

public void szinkorok(Graphics g) {
 int x0,y0;
 float hue=c;
 do {
 x0=x-r;y0=y-r;
 g.setColor(Color.getHSBColor(hue,1f,1f));
 g.fillOval(x0, y0, 2*r, 2*r);
 hue+=0.01; r-=1;
 }while(r>0);
}

public void csillag(Graphics g) {
 int x1,y1,i=0;
 int[] xP=new int[2*n],yP=new int[2*n];
 double fi=0;
 do {
  x1=(int)(r*Math.sin(fi)/(i%2+1))+x;
  y1=y-(int)(r*Math.cos(fi)/(i%2+1));
  xP[i]=x1;yP[i]=y1;
  fi+=Math.PI/n;
  ++i;
  } while(i<2*n);
 g.setColor(Color.getHSBColor(c,1f,1f));
 g.fillPolygon(xP,yP,2*n);
 }

public void paint(Graphics g) {
 x=10;y=10;w=150;h=380;c=0f;vizszintes_vonalak_2(g);
 x=240;y=10;w=150;h=380;c=0f;fuggoleges_vonalak_2(g);
 x=100;y=100;r=90;n=25;c=1/6f;csillag(g);
 x=200;y=60;r=50;szinkor(g);
 x=300;y=100;r=90;n=15;c=0f;csillag(g);
 x=100;y=300;r=90;c=0f;szinkorok(g);
 x=110;y=110;w=180;h=180;c=0f;prizma(g);
 x=300;y=300;r=90;c=0.5f;szinkorok(g);
 x=200;y=340;r=50;n=7;c=2/3f;csillag(g);
 }

}
NegyedikApplet.java

/* a használt osztályok és metódusok:

public interface java.awt.LayoutManager

public abstract class java.awt.Component
| public void paint(Graphics g)
| public void setBackground(Color c)
| public void validate()
|
public class java.awt.Container extends java.awt.Component
| public void setLayout(LayoutManager lm)
| public Component add(Component c)
|
public class java.awt.Panel extends java.awt.Container
|
public class java.applet.Applet extends java.awt.Panel
| public void init()
|
public class NegyedikApplet extends java.applet.Applet
   public void paint(Graphics g)

----------------------------

public abstract class java.awt.Component
| public void setBackground(Color c)
| public void setBounds(int x, int y, int w, int h)
|
public class java.awt.TextComponent extends java.awt.Component
| public synchronized void setText(String s)
| public synchronized String getText()
|
public class java.awt.TextField extends java.awt.TextComponent
   public TextField()

----------------------------

public abstract class java.awt.Component
| public void setBackground(Color c)
| public void setBounds(int x, int y, int w, int h)
|
public class java.awt.Button extends java.awt.Component
   public Button(String s)
   public void addActionListener(ActionListener l)

----------------------------

public abstract class java.awt.Component
| public void setBackground(Color c)
| public void setBounds(int x, int y, int w, int h)
|
public class java.awt.Label extends java.awt.Component
   public Label()
   public Label(String s)

----------------------------

public class java.awt.event.ActionEvent

public interface java.awt.event.ActionListener
| public abstract void actionPerformed(ActionEvent ev)
|
public class NegyedikApplet implements java.awt.event.ActionListener
   public void actionPerformed(ActionEvent e)

----------------------------

public abstract class java.lang.Number
| public abstract double doubleValue()
|
public final class java.lang.Double extends java.lang.Number
   public Double(String s) throws NumberFormatException

public class java.lang.Exception
|
public class java.lang.NumberFormatException extends java.lang.Exception

*/

import java.applet.*;
import java.awt.*;
import java.awt.event.*;

public class NegyedikApplet extends Applet implements ActionListener {

public TextField x=new TextField();
public Button plus=new Button("+");
public TextField y=new TextField();
public Label eq=new Label("=");
public Label z=new Label();

public void init() {
 setLayout(null);
 x.setBounds(5,5,50,20);
 add(x);
 plus.setBounds(60,5,20,20);
 add(plus);
 plus.addActionListener(this);
 y.setBounds(85,5,50,20);
 add(y);
 eq.setBounds(140,5,20,20);
 add(eq);
 z.setBounds(165,5,100,20);
 add(z);
 }

public void actionPerformed(ActionEvent ev) {
 double a,b;
 try {
  a=(new Double(x.getText())).doubleValue();
  b=(new Double(y.getText())).doubleValue();
  z.setText(""+(a+b));
  }
 catch(Exception ex) {
  z.setText("Hiba!");
  }
 validate();
 }
public void paint(Graphics g) {
 setBackground(Color.pink);
 }

}
OtodikApplet.java

/* a használt (fontosabb) osztályok és metódusok:

public abstract class java.awt.Component
 | public void paint(Graphics g)
 | public void repaint()
 | public void repaint(int x, int y, int w, int h)
 | public void setBackground(Color c)
 | public void setSize(int w, int h)
 | public void update(Graphics g)
 | public void validate()
 |
public class java.awt.Container extends java.awt.Component
 | public void setLayout(LayoutManager lm)
 | public Component add(Component c)
 |
public class java.awt.Panel extends java.awt.Container
 |
public class java.applet.Applet extends java.awt.Panel
 | public void init()
 |
public class NegyedikApplet extends java.applet.Applet
   public void paint(Graphics g)

----------------------------

public abstract class java.awt.Component
 | public void setBackground(Color c)
 | public void setBounds(int x, int y, int w, int h)
 |
public class java.awt.TextComponent extends java.awt.Component
 | public void addTextListener(TextListener l)
 | public synchronized void setText(String s)
 | public synchronized String getText()
 |
public class java.awt.TextField extends java.awt.TextComponent
   public TextField()

----------------------------

public abstract class java.awt.Component
 | public void setBackground(Color c)
 | public void setBounds(int x, int y, int w, int h)
 |
public class java.awt.Button extends java.awt.Component
   public Button(String s)
   public void addActionListener(ActionListener l)
   public void setActionCommand(String s)

----------------------------

public abstract class java.awt.Component
 | public void setBackground(Color c)
 | public void setBounds(int x, int y, int w, int h)
 |
public class java.awt.Label extends java.awt.Component
   public static final int LEFT
   public static final int CENTER
   public static final int RIGHT
   public Label()
   public Label(String s)
   public synchronized void setAlignment(int x)
   public synchronized void setText(String s)

----------------------------

public class java.awt.event.ActionEvent
   public String getActionCommand()

public interface java.awt.event.ActionListener
 | public abstract void actionPerformed(ActionEvent ev)
 |
public class NegyedikApplet implements java.awt.event.ActionListener
   public void actionPerformed(ActionEvent e)

public class java.awt.event.TextEvent

public interface java.awt.event.TextListener
 | public abstract void textValueChanged(TextEvent ev)
 |
public class NegyedikApplet implements java.awt.event.ActionListener
   public void textValueChanged(TextEvent ev)

*/

import java.applet.*;
import java.awt.*;
import java.awt.event.*;

public class OtodikApplet extends Applet
                implements ActionListener, TextListener {

public TextField x=new TextField();
public Label op=new Label("?");
public TextField y=new TextField();
public Label eq=new Label("=");
public TextField z=new TextField();
public Button plus=new Button("ADD");
public Button minus=new Button("SUB");
public Button mul=new Button("MUL");
public Button div=new Button("DIV");
public Button pow=new Button("POW");
public Button back=new Button("BACKGROUND");
private int bgcolor=0;

 public void init() {
  setSize(400,200);
  setBackground(new Color(bgcolor));
  setLayout(null);
// szövegbeviteli mezők és címkék
  x.setBackground(Color.white);
  x.setBounds(5,5,110,20);
  add(x);
  x.addTextListener(this);
  op.setBackground(Color.gray);
  op.setBounds(120,5,20,20);
  op.setAlignment(Label.CENTER);
  add(op);
  y.setBackground(Color.white);
  y.setBounds(145,5,110,20);
  add(y);
  y.addTextListener(this);
  eq.setBackground(Color.gray);
  eq.setBounds(260,5,20,20);
  eq.setAlignment(Label.CENTER);
  add(eq);
  z.setBackground(Color.white);
  z.setBounds(285,5,110,20);
  add(z);
// műveleteket végrehajtó gombok
  plus.setBackground(Color.gray);
  plus.setBounds(5,35,50,20);
  add(plus);
  plus.setActionCommand("+");
  plus.addActionListener(this);
  minus.setBackground(Color.gray);
  minus.setBounds(65,35,50,20);
  add(minus);
  minus.setActionCommand("-");
  minus.addActionListener(this);
  mul.setBackground(Color.gray);
  mul.setBounds(125,35,50,20);
  add(mul);
  mul.setActionCommand("*");
  mul.addActionListener(this);
  div.setBackground(Color.gray);
  div.setBounds(185,35,50,20);
  add(div);
  div.setActionCommand("/");
  div.addActionListener(this);
  pow.setBackground(Color.gray);
  pow.setBounds(245,35,50,20);
  add(pow);
  pow.setActionCommand("^");
  pow.addActionListener(this);
  back.setBackground(Color.white);
  back.setBounds(305,35,90,20);
  add(back);
  back.setActionCommand("b");
  back.addActionListener(this);
  }

public void actionPerformed(ActionEvent ev) {
 double a,b;
 if(ev.getActionCommand().charAt(0)=='b') {
  bgcolor=(int)(Math.pow(2,24)*Math.random());
  setBackground(new Color(bgcolor));
 repaint();
 return;
 }
try {
 a=(new Double(x.getText())).doubleValue();
 b=(new Double(y.getText())).doubleValue();
 switch(ev.getActionCommand().charAt(0)) {
 case '+':
  op.setText("+");
  z.setText(""+(a+b));
  break;
 case '-':
  op.setText("-");
  z.setText(""+(a-b));
  break;
 case '*':
  op.setText("*");
  z.setText(""+(a*b));
  break;
 case '/':
  op.setText("/");
  z.setText(""+(a/b));
  break;
 case '^':
  op.setText("^");
  z.setText(""+Math.pow(a,b));
 }
 }
catch(Exception ex) {
 z.setText("Hiba!");
 }
validate(); //a változások érvényesítése
}

public void textValueChanged(TextEvent ev) {
  op.setText("?");
  z.setText("");
 }

public void paint(Graphics g) {
 g.setFont(new Font("Courier NEW CE",Font.BOLD,14));
 g.setColor(new Color(~bgcolor));
 g.drawString("Számológép 1.1",5,80);
 }

}
Alakzatok.java

import java.applet.*;
import java.awt.*;
import java.awt.event.*;

public class Alakzatok extends Applet
              implements ActionListener {

public final int XX=420;
public final int YY=230;
public final int RR=150;
public final int NN=25;

public TextField x=new TextField(""+XX);
public TextField y=new TextField(""+YY);
public TextField r=new TextField(""+RR);
public TextField n=new TextField(""+NN);
public Label op1=new Label("Háromszög");
public Label op2=new Label("Négyzet");
public Label op3=new Label("Kör");
public Label op4=new Label("Csillag");
public Label op5=new Label("Színkör");
public Label opback=new Label("Háttér");
public Button b1=new Button("OK");
public Button b2=new Button("OK");
public Button b3=new Button("OK");
public Button b4=new Button("OK");
public Button b5=new Button("OK");
public Button back=new Button("OK");

public int rr,nn;
public int xx,yy,ww,hh, z;

private int bgcolor=0;

public void init() {
 setBackground(new Color(bgcolor));
 setLayout(null);

 op1.setBackground(Color.gray);
 op1.setBounds(10,50,100,20);
 op1.setAlignment(Label.CENTER);
 add(op1);
 op2.setBackground(Color.gray);
 op2.setBounds(10,80,100,20);
 op2.setAlignment(Label.CENTER);
 add(op2);
 op3.setBackground(Color.gray);
 op3.setBounds(10,110,100,20);
 op3.setAlignment(Label.CENTER);
 add(op3);
 op4.setBackground(Color.gray);
 op4.setBounds(10,140,100,20);
 op4.setAlignment(Label.CENTER);
 add(op4);
 op5.setBackground(Color.gray);
 op5.setBounds(10,170,100,20);
 op5.setAlignment(Label.CENTER);
 add(op5);
 opback.setBackground(Color.gray);
 opback.setBounds(10,200,100,20);
 opback.setAlignment(Label.CENTER);
 add(opback);

// szövegbeviteli mezők és címkék
  x.setBackground(Color.white);
  x.setBounds(10,20,100,20);
  add(x);
  y.setBackground(Color.white);
  y.setBounds(140,20,100,20);
  add(y);
  r.setBackground(Color.white);
  r.setBounds(270,20,100,20);
  add(r);
  n.setBackground(Color.white);
  n.setBounds(400,20,100,20);
  add(n);

// műveleteket végrehajtó gombok
  b1.setBackground(Color.gray);
  b1.setBounds(140,50,50,20);
  add(b1);
  b1.setActionCommand("1");
  b1.addActionListener(this);
  b2.setBackground(Color.gray);
  b2.setBounds(140,80,50,20);
  add(b2);
  b2.setActionCommand("2");
  b2.addActionListener(this);
  b3.setBackground(Color.gray);
  b3.setBounds(140,110,50,20);
  add(b3);
  b3.setActionCommand("3");
  b3.addActionListener(this);
  b4.setBackground(Color.gray);
  b4.setBounds(140,140,50,20);
  add(b4);
  b4.setActionCommand("4");
  b4.addActionListener(this);
  b5.setBackground(Color.gray);
  b5.setBounds(140,170,50,20);
  add(b5);
  b5.setActionCommand("5");
  b5.addActionListener(this);
  back.setBackground(Color.gray);
  back.setBounds(140,200,50,20);
  add(back);
  back.setActionCommand("b");
  back.addActionListener(this);

 xx=XX;yy=YY;rr=RR;nn=NN;
}

public void actionPerformed(ActionEvent ev) {
 int a,b,c,d;
 try {
  a=(new Integer(x.getText())).intValue();
  b=(new Integer(y.getText())).intValue();
  c=(new Integer(r.getText())).intValue();
  d=(new Integer(n.getText())).intValue();
  if(d<3) throw new Exception();
  }
 catch(Exception ex) {
  a=XX;
  b=YY;
  c=RR;
  d=NN;
  }
 xx=a;
 yy=b;
 rr=c;
 nn=d;
 x.setText(""+xx);
 y.setText(""+yy);
 r.setText(""+rr);
 n.setText(""+nn);
 switch(ev.getActionCommand().charAt(0)) {
  case 'b':
   bgcolor=(int)(Math.pow(2,24)*Math.random());
   break;
  case '1':
   z=1;
   bgcolor=~bgcolor;
   break;
  case '2':
   z=2;
   bgcolor=~bgcolor;
   break;
  case '3':
   z=3;
   bgcolor=~bgcolor;
   break;
  case '4':
   z=4;
   bgcolor=~bgcolor;
   break;
  case '5':
   z=5;
   bgcolor=~bgcolor;
  }
 setBackground(new Color(bgcolor));
 repaint();
 }

public void szinkor(Graphics g) {
 int x0=xx,x1,y0=yy-rr,y1;
 int[] xP=new int[3],yP=new int[3];
float hue=0;
double fi;
do {
 g.setColor(Color.getHSBColor(hue,1f,1f));
 fi=2.0*hue*Math.PI;
 x1=(int)(rr*Math.sin(fi))+xx;
 y1=yy-(int)(rr*Math.cos(fi));
 xP[0]=xx;yP[0]=yy;
 xP[1]=x0;yP[1]=y0;
 xP[2]=x1;yP[2]=y1;
 g.fillPolygon(xP,yP,3);
 x0=x1;y0=y1;
 hue+=0.001f; //következő színárnyalat-érték
 } while(hue<=1);
}

public void csillag(Graphics g) {
 int x1,y1,i=0;
 int[] xP=new int[2*nn],yP=new int[2*nn];
 double fi=0;
 do {
  x1=(int)(rr*Math.sin(fi)/(i%2+1))+xx;
  y1=yy-(int)(rr*Math.cos(fi)/(i%2+1));
  xP[i]=x1;yP[i]=y1;
  fi+=Math.PI/nn;
  ++i;
  } while(i<2*nn);
 g.fillPolygon(xP,yP,2*nn);
 }

public void paint(Graphics g) {
 g.setFont(new Font("Courier NEW CE",Font.BOLD,14));
 g.setColor(new Color(~bgcolor));
 g.drawString("Alakzatok",10,400);
 switch(z) {
  case 1:
   int[] xP={xx-rr,xx,xx+rr},yP={yy+rr,yy-rr,yy+rr};
   g.fillPolygon(xP,yP,3);
   break;
  case 2:
   g.fillRect(xx-rr,yy-rr,2*rr,2*rr);
   break;
  case 3:
   g.fillOval(xx-rr,yy-rr,2*rr,2*rr);
   break;
  case 4:
   csillag(g);
   break;
  case 5:
   szinkor(g);
  }
 }
}
Bevezetés

magasszintû programozási nyelvek

      szintaxis
      szemantika
      nyelvhasználat
      implementációk ("nyelvjárások")
           o a Turbo Pascal implementáció
           o a Java Development Kit




szintaxis (cél adott nyelvi egységekbõl összetett nyelvi egységek létrehozása meghatározott szabályok, un.
nyelvtani szabályok segítségével)

      nyelvtani szabályok megadása un. metanyelvekkel
          o BNF (Backus-Naur Form); példák:
                   <számjegy> ::= {0|1|2|3|4|5|6|7|8|9}
                   <számsor> ::= <számjegy>[<számjegy>]...
                   <elõjel> ::= {+|-}
                   <egész szám>::= [<elõjel>]<számsor>
                   ...




           o   szintaxisgráfok; példa:
      szintaktikai hibák (egyes nyelvi egységeket nem megfelelõen, azaz nem a nyelvtani szabályok helyes
       alkalmazásával hoztunk létre)
           o hibaüzenetek a fordítás során (pl. Error 85: ":=" expected. (TP); Hello.java:3: ';' expected (Java)
               )

Jegyezzük meg: a szintaktikai hibák formális javítást igényelnek a forrásprogram szövegében (pl. írásjelek
vagy zárójelek pótlását). Csak akkor hajtsunk végre lényegi változtatásokat a már elkészült program
forráskódján (pl. utasítások törlésével vagy hozzáadásával), ha a program már fut, de nem az elvárt
eredményt adja!
szemantika

       a programozási nyelvek célja algoritmusok leírása (általában a számítógép által történõ végrehajtás céljából, de
        pl. a Pascal-t eredetileg "publikációs nyelvnek" szánták)
             o a programok, ill. alprogramok specifikálása "fekete dobozként"
                      input értéktartományának megadása
                      output értéktartományának megadása
                      függvénykapcsolat megadása az input és output értékek között
             o az algoritmusok lépéseinek leírása utasításokkal
             o a program helyességének ellenõrzése (helyesség: a program minden megengedett bemeneti, input értékre
                 úgy mûködik, ahogy specifikáltuk)
                      szemantikai hibák (a program nem úgy mûködik, ahogy specifikáltuk, azaz nem megfelelõ
                          kimeneti, output értékeket szolgáltat)
                      kivételek ("futásidejû hibák", runtime errors; a program általában megfelelõen mûködik, de
                          egyes kivételes esetekben nem várt módon fejezõdik be, pl. futása "váratlanul" megszakad - a
                          program által leírt algoritmus egyes bemeneti, input adatok mellett nem mûködik helyesen, azaz
                          nem teljes)
                                futásidejû hibaüzenetek (pl. egy Turbo Pascal programban nullával való osztás esetén a
                                   Runtime Error 200 at 0BEA:006E. üzenetete kapjuk a program futási ablakában vagy a
                                   TP integrált fejlesztõi rendszerének (IDE) "felhasználói képernyõjén", ami megfelel az
                                   Error 200: Division by zero. üzenetnek az IDE forrásprogramot tartalmazó ablakában)
       a nyelvi egységek jelentésének megadására különbözõ modellek szolgálnak
             o magasszintû programozási nyelvek ("az emberi gondolkodáshoz állnak közel"; pl. Pascal, Java)
                      a modell egy absztrakt számítógép-architektúrához kötõdik
                                használatához nem szükséges egy konkrét számítógép-típushoz kötõdõ hardver-, ill.
                                   platformspecifikus fogalmak ismerete
                      a magasszintû programnyelvek szimbolikus azonosítókat használnak a változók és mûveletek
                          leírására
             o alacsonyszintû programozási nyelvek (pl. Assembler)
                      a modell egy konkrét számítógép típushoz kötõdik
                                ismerni kell a memória szerkezetét (pl. a változók helyfoglalásának és címének
                                   megadásához)
                                ismerni kell a különbözõ adattípusok kódolását
                                ismerni kell a processzor címzési mechanizmusait
                                ...
                      az alacsonyszintû programnyelvek is szimbolikus azonosítókat használnak a változók és
                          mûveletek leírására
             o gépi kód használata (a modell egy konkrét számítógép típushoz kötõdik; a program leírásakor
                 változónevek helyett közvetlenül memóriacímeket adunk meg, és szimbolikus utasítások helyett az adott
                 processzor utasításódjait használjuk)



algoritmusok lépéseinek leírása utasításokkal

    1. a bemeneti adatok bevitele és tárolásuk változókban
    2. a következõ végrehajtandó utasítás kiválasztása
           o az utasításokat rendszerint egymás után, szekvenciálisan hajtjuk végre
           o a szekvenciális végrehajtási sorrendet a kapott részeredményektõl függõen esetenként vezérlésátadással
                megváltoztatjuk (pl. elágaztatással, ciklussal)
    3. a változókon meghatározott mûveletek végrehajtása
           o elõre definiált, "standard" mûvelet végrehajtása (pl. + (TP, Java), vagy sin(x) (TP), ill. Math.sin(x) (Java)
                )
           o a programban definiált mûvelet (pl. eljárás vagy függvény) végrehajtása
    4. a mûveletek (rész)eredményének eltárolása változókban
    5. a 2-4 lépések ismétlése addig, amíg meg nem kapjuk a kívánt végeredményeket
    6. a végeredmények ("kimeneti adatok") megjelenítése
nyelvhasználat ("programozási stílus")

        öndokumentáltság (a programszöveg érthetõségének javítása megjegyzések gyakori elhelyezésével a programszövegben)
        strukturáltság (csak meghatározott vezérlési szerkezetek használata)
        modularitás (a programokat kisebb, áttekinthetõ egységekbõl építjük fel, amelyek önállóan, egymástól függetlenül
         kódolhatóak, futtathatóak, tesztelhetõek, és javíthatóak; ez tipikusan statikus környezetet igényel, amelyben futtatható
         programkódok, és a változók számára ténylegesen lefoglalt memóriahelyek állnak rendelkezésre)
        objektum-orientáltság (a programokban objektumokat használunk, amelyeket absztrakt objektum-típusokból vagy
         osztályokból hozunk létre; a hatékony programfejlesztés céljából az osztályokat osztály-hierarchiákba és csomagokba
         szervezzük; az osztályok alkalmazása tipikusan dinamikus környezetet igényel, amelyben az adatszerkezetek (mezõk) és a
         hozzájuk kötõdõ mûveletek (metódusok) leírásai meghatározott elvek szerint egymásra épülnek és az osztály-hierarchia
         különbözõ szintjein különbözõ jelentéssel rendelkezhetnek; statikus környezetben, például futtatható programokban a
         dinamikus környezetben leírt osztályokból konkrét objektumokat vagy objektuméldányokat kell konstruálnunk, hogy
         használhassuk õket)



strukturáltság (csak olyan vezérlési szerkezetek használata egy programban, amelyek a belõlük felépített utasításblokkok számára
pontosan egy belépési és kilépési pontot, azaz kezdõ, ill. záróutasítást engednek meg)

        megengedett vezérlési szerkezetek
            o szekvencia (utasítások sorozata, amelyeket sorrendben egymás után hajtunk végre; az utasítások között
                megengedünk további szekvenciákat, feltételes elágazásokat vagy iterációkat is)
                      alprogram (olyan névvel ellátott szekvencia, amelyet a többi utasítástól függetlenül adunk meg és a
                         továbbiakban a név megadásával egy végrehajtható utasításként hivatkozunk rá)
            o feltételes elágazás (egy feltételtõl függõen választunk egy, két vagy esetleg több utasítás vagy szekvencia
                végrehajtása között)
            o ciklus (iteráció; egy feltétel teljesüléséig ismétlünk egy utasítást vagy egy szekvenciát)
        nem megengedett vezérlési szerkezetek
            o feltétel nélküli vezérlésátadás



szekvencia

        {szabályos belépési pont}
        begin
        write('Sugár=');
        readln(r);
        k:=2*r*Pi;
        writeln('A kör kerülete: ', k:3:2);
        end;
        {szabályos kilépési pont}



feltétel nélküli vezérlésátadás

        {szabályos belépési pont}
        begin
        write('Sugár=');
        readln(r);
        if r<0 then goto hiba; {feltétel nélküli vezérlésátadás}
        k:=2*r*Pi;
        writeln('A kör kerülete: ', k:3:2);
        end;
        {elsõ, szabályos kilépési pont}
        ... {utasítások}
        hiba: {címke, amelyre hivatkozunk a goto utasításban}
        {második, nem szabályos kilépési pont}
        ... {utasítások}
modularitás

      utasítások
      utasításblokkok (több utasításból álló egységek ún. utasítás-zárójelekkel (Java: { ... }, TP: begin ... end) határolva,
       amelyeket a fordítóprogram formálisan egy utasításként kezel)
      alprogramok (az alprogramok névvel azonosított és a lokális változók egy meghatározott készletével rendelkezõ
       utasításblokkok szabványos i/o felülettel, ún. szignatúrával; az alprogramok két alapvetõ fajtája a függvény,
       amely pontosan egy visszatérési értékkel rendelkezik és az eljárás, amelynek (1) többnyire nincs visszatérési
       értéke, de (1a) egyes esetekben a program globális (TP) vagy statikus (J) változóinak az értékét módosítja, ill.
       (1b) objektum-orientált környezetben a legtöbb esetben az aktuális objektumpéldány mezõinek az értékét
       módosítja (J), és (2) ritkábban a híváskor megadott aktuális paraméterek értékét módosítja (azaz ilyenkor egy
       vagy több visszatérési értékkel rendelkezik); Java esetén önálló, az egyes objektumpéldányoktól független
       ("osztályszintû") alprogramokat statikus metódusokkal valósíthatunk meg; ezekre olyan, általánosan használt
       mûveletek esetén lehet szükség, amelyeknek a jelentésén már nem akarunk változtatni); egy alprogram
       megadásához a következõ adatokra van szükség:
            o név (függvények esetén kettõs funciója van: híváskor ezzel azonosítjuk magát a függvényt és a függvény
                visszatérési értékét is)
            o i/o felület
                     formális paraméterek (többnyire input adatokat azonosítanak; egyértelmû azonosításuk
                        szempontjából meghatározó a paraméterek száma, típusa és sorrendje)
                     visszatérési érték (függvények esetén pontosan egy visszatérési érték van; a Java esetén az
                        eljárásoknak nincs explicit módon deklarált visszatérési értéke (void), de referencia-típusú
                        formális paraméterek esetén az alprogram a hívásakor aktuális paraméterként megadott változó
                        értékét módosíthatja; a Turbo Pascal esetén ezzel szemben több deklarált visszatérési érték is
                        lehet (var); ebben az utóbbi esetben a formális paraméterek nemcsak input, hanem output
                        adatokat is azonosíthatnak)
            o az alprogram input értékeket vehet át, és output értékeket adhat át a szabványos i/o felületen kívül is: az
                alprogram kiolvashatja, ill. módosíthatja a program globális vagy statikus változóinak az értékét, és
                metódusként megvalósított alprogram esetén az alprogramot tartalmazó objektumpéldány
                elemváltozóinak az értékét is (megjegyzés: a globális vagy statikus változókat minden alprogram "látja",
                azaz kiolvashatja és módosíthatja, de ezzel célszerû óvatosan bánni, mert a globális változók ilyen
                használata az adatszerkezet szintjén pontosan a modularitással, azaz az egymástól függetlenül tesztelhetõ
                programegységek kilakításával ellentétes hatást, ún, mellékhatást eredményezhet)
                     objektumok vagy objektumpéldányok: olyan programegységek, amelyek meghatározott
                        adatszerkezettel, ún. elemváltozókkal rendelkeznek, és amelyeknek az elemváltozókon különbözõ
                        mûveleteket megvalósító, "kötegbe fogott" vagy egységbezárt alprogramjai, ún. metódusai
                        vannak
      programkönyvtárak, unitok (Turbo Pascal), csomagok (Java); ezek olyan állományok, amelyek elõre megírt
       programokat, ill. programrészleteket tartalmaznak, amelyekkel a programozási nyelvek "standard" lehetõségei
       kibõvíthetõek)
      végrehajtható vagy futtatható program, amely a fenti programegységekbõl épül fel (a Java nyelv esetén a
       futtatható progam formálisan egy (tetszõleges, általunk választott) osztály public static void main(String[] args)
       statikus metódusa; akár minden osztálynak lehet main metódusa, amely pl. az egyes osztályokban megvalósított
       funkciók tesztelésére kiválóan használható; ez azonban inkább módszertani segítséget jelent, mivel egy osztály
       main metódusa közvetlenül ugyanúgy nem éri el az osztályban megvalósított nem statikus elemeket, mintha egy
       másik osztály main metódusát használnánk)
            o megjegyzés: ha egy osztályban csak statikus változókat és metódusokat használunk, ezek a statikus main
                metódusból közvetlenül elérhetõek, így ebben az esetben az osztály lényegében egy "hagyományos"
                programozási nyelven megírt programnak felel meg - persze ekkor semmit sem használunk ki azokból a
                lehetõségekbõl, amelyeket az objektum-orientáltság lehetõvé tesz...


jegyezzük meg: az alprogramokat szignatúrájukkal azonosítjuk, amely az alprogram nevét, formális paramétereinek
számát, típusát és sorrendjét, valamint függvények esetén a visszaadott érték típusát jelenti
objektum-orientáltság
az objektum fogalma az objektum-orientált szemléletben alapvetõen két fõ absztrakciós szinten
fordul elõ (itt és a továbbiakban a Java terminológiáját használjuk):

      programfejlesztéskor dinamikus környezetben fordulnak elõ (ezen belül is rendszerint több absztrakciós
       szinten) az absztrakt objektumok, objektumtípusok vagy osztályok (class); ezek a programokban
       ténylegesen használható objektumok adatszerkezetének (a mezõknek) és az adatszerkezeten végezhetõ
       mûveleteknek (a metódusoknak) a leírásait tartalmazzák, amelyek jelentése az osztályhierarchia
       különbözõ szintjein dinamikusan változhat; az osztályokat felhasználhatjuk
           o további osztályok definiálására (öröklõdéssel), és
           o dinamikus vagy statikus környezetben (pl. metódusok formális paramétereinek vagy lokális
               változóinak megadásakor) használható objektumpéldányok létrehozására (ld. alább)
      statikus vagy dinamikus metódusokban, ill. programok futtatásakor (a main metódusban) statikus
       környezetben fordulnak elõ a (tényleges, vagyis a programban használható) objektumok,
       objektumpéldányok vagy objektumelõfordulások (instance); ezek magukban foglalják
           o az osztályok metódusainak megfelelõ, végrehajtható programkódot, és
           o a osztályok mezõinek megfelelõ ún. elemváltozók számára ténylegesen lefoglalt
               memóriaterületet (amelynek a címe az egyes objektumpéldányok ún. referenciája)
      kapcsolat a statikus és dinamikus környezet között

dinamikus környezetben (tipikusan programfejlesztéskor) az objektumok további absztrakciós szinteken
fordulhatnak elõ

      a dinamikus környezet elemei

a dinamikus környezet hatékonyságát néhány alapelv megvalósítása biztosítja


kapcsolat a statikus és dinamikus környezet között
az objektumpéldányok statikus környezetben való megkonstruálásához a Java nyelv esetén a
következõk szükségesek:

      a példány típusa (egy osztály neve)
      a példány neve (a késõbbiekben ezzel hivatkozunk majd az objektumra)
      az értékadó (=) és a new operátor
      a példány létrehozásához, a "példányosításhoz" használható konstruktorfüggvény (amely futtatáskor
       létrehozza a példány elemváltozóit, és beállítja az elemváltozók kezdõértékét)

a megkonstruált objektumpéldány már rendelkezik a statikus környezetben adattárolásra használható
elemváltozókkal, és metódusai ténylegesen végrehajthatóak (az elemváltozók és metódusok elérése az
objektumpéldány nevén keresztül lehetséges a minõsítõ (.) operátor és az elemváltozó, ill. metódus nevével, pl.
h.nev vagy s.length() módon)
a Java nyelv esetén a dinamikus környezet legfontosabb elemei a következõk:

      absztrakt osztályok (abstract class; olyan osztályok, amelyek nem példányosíthatóak; tipikusan olyan
       "õsosztályok", amelyek deklarálják, de többnyire nem definiálják a leszármaztatott osztályok alapvetõ
       közös metódusait)
           o ...
           o absztrakt metódusok szignatúrái (abstract)
           o ...
      interfészek (interface; olyan absztrakt osztályok, amelyek elõírják, hogy egy adott funkció
       megvalósításához milyen metódusok szükségesek; az interfészeket megvalósító osztályokat tipikusan az
       adott funkciót megvalósító metódus formális paramétereként szokás használni, mivel így (1) a metódust
       általánosan tudjuk megírni az interfészben elõírt (absztrakt) metódusokkal, de (2) a végrehajtás már a
       híváskor aktuális paraméterként megadott objektum ténylegesen megvalósított metódusaival fog majd
       megtörténni)
           o konstansok
           o absztrakt metódusok szignatúrái (abstract; a metódusokat azokban az osztályokban kell majd
               ténylegesen definiálnunk, amelyek megvalósítják ("implementálják") az interfészt)
      (nem absztrakt) osztályok (class)
           o statikus változók (static; globális vagy osztályszintû változók, amelyek minden osztályból vagy
               objektumból elérhetõek)
                    statikus konstansok (final; rögzített értékû statikus változók)
           o statikus metódusok (static; olyan metódusok, amelyek minden osztályból és objektumból
               elérhetõek; a statikus metódusok a statikus változókat közvetlenül elérhetik és egymásra
               közvetlenül hivatkozhatnak, de a dinamikus mezõket és metódusokat csak objektumpéldányokon
               keresztül érhetik el)
           o (nem statikus vagy dinamikus) mezõk
           o (nem statikus vagy dinamikus) metódusok (az adott osztály statikus és dinamikus mezõit
               közvetlenül elérhetik, és az adott osztály statikus és dinamikus metódusaira közvetlenül
               hivatkozhatnak)
                    absztrakt metódusok szignatúrái (abstract; ezeket egy leszármaztatott osztályban kell
                       majd leírnunk; ha egy ilyen is elõfordul, az egész osztályt absztraktként kell
                       deklarálnunk)
           o konstruktorfüggvény(ek) (példányosításkor rendszerint bizonyos kezdõértékeket adnak meg az
               objektum elemváltozói számára)
      csomagok (package; a hasonló funkciókat megvalósító osztályokat nagyobb egységekbe szervezhetjük,
       ezek az ún. csomagok; a csomagok az alkönyvtárakhoz hasonló, hierarchikus felépítésûek)
a dinamikus környezet hatékonyságát néhány alapelv megvalósítása biztosítja; ezek az alapelvek a következõk:

      adatszerkezet elrejtése (encapsulation; zártság, ill. különbözõ láthatósági szintek deklarálása (pl. private,
       public); az osztályok (védettként deklarált) mezõihez közvetlenül nem, csak az osztályok metódusain
       keresztül férhetünk hozzá)
      öröklõdés (inheritance; különbözõ absztrakciós szintû osztályok készítése; egy leszármazott osztály
       örökli a szülõ osztály mezõit és metódusait, és további mezõkkel, ill. metódusokkal egészítheti ki õket)
           o öröklõdési lánc (egy O absztrakt (õs)osztályból származtatunk egy nála konkrétabb O' osztályt,
               O'-bõl egy még konkrétabb O'' osztályt, stb.)
                                                                                    (n)
           o öröklõdési fa (egy O->O'->O''->... öröklõdési lánc bármelyik Q=O osztályából létrehozható
               egy újabb Q->Q'->Q''-> öröklõdési lánc, és ugyanez igaz ennek az öröklõdési láncnak minden
               P=Q(n) osztályára is, stb.; az így létrehozott öröklõdési fa minden osztályának az õsosztálya az O
               osztály, minden osztálynak pontosan egy közvetlen õse (szülõje) van és akárhány
               leszármazottja)
      többalakúság vagy polimorfizmus (polimorphism; az osztályok öröklõdési láncában egy leszármazott
       osztály átdefiniálhatja a szülõ osztálytól örökölt metódusokat (a mezõket általában nem), így az
       öröklõdési lánc különbözõ szintjein egy adott szignatúrájú metódus más-más jelentéssel rendelkezhet)
           o dinamikus öröklõdés (az átdefiniálás dinamikus metódusok esetén erõsebb hatású az eredeti
               definíciónál): egy dinamikus metódus átdefiniálása a leszármazott osztályban
               "visszamenõlegesen" is kihat az örökölt dinamikus metódusokra; tegyük fel, hogy egy O
               (õs)osztályban definiált m() metódus hivatkozik egy olyan, O-ban definiált d() metódusra,
               amelyet egy O-ból származtatott, vagyis O-nál konkrétabb P osztályban átdefiniáltunk; ekkor
                    ha az m() metódust O-ból vagy a P osztálynál absztraktabb osztályból hívjuk meg, akkor
                       az "eredeti", vagyis az O-ban definiált d()-t hajtja végre;
                    ha pedig az m() metódust a P osztályból vagy egy belõle leszármaztatott (tehát nála
                       konkrétabb) Q osztályból hívjuk meg, akkor a program az "új", vagyis az átdefiniált d()-t
                       fogja végrehajtani.

megjegyzés: statikus változók és metódusok esetén is beszélhetünk zártságról, öröklõdésrõl és
polimorfizmusról, utóbbi esetben azonban nem dinamikus, hanem statikus öröklõdés érvényesül (az eredeti
definíció statikus metódusok esetén erõsebb az átdefiniálásnál, annak nincs visszamenõleges hatása - még akkor
sem, ha az átdefiniált statikus metódust dinamikus metódusból hívjuk meg).
példa dinamikus öröklõdésre (ha ez most nem teljesen érthetõ, érdemes visszatérni a példára a harmadik lecke
áttanulmányozása után)
public class O { //õsosztály
public void d() {
 System.out.println("Az O-ban definialt d() metodus vagyok!");
 }
public void m() {
 d();
 }
}
public class P extends O { //az õsosztályból származtatott osztály
public void d() {
 System.out.println("A P-ben atdefinialt d() metodus vagyok!");
 }
}
public class Q extends P {
public static void main(String[] args) {
 O peldanyO=new O();
 P peldanyP=new P();
 Q peldanyQ=new Q();
 System.out.println("Az m() metodus futtatasa O-bol:");
 peldanyO.m();
 System.out.println();
 System.out.println("Az m() metodus futtatasa P-bol:");
 peldanyP.m();
 System.out.println();
 System.out.println("Az m() metodus futtatasa Q-bol:");
 peldanyQ.m();
 }
}
Az osztályok lefordításának és a Q osztály futtatásának eredménye itt látható.
a Turbo Pascal implementáció

      a Turbo Pascal (TP) programozási nyelv
          o standard nyelvi elemek
          o felhasználók által definiált nyelvi elemek (a nyelv továbbfejlesztése adott célok megvalósítására,
              pl. könyvtári célú programok írására)
                   felhasználók által létrehozott programegységek vagy unit-ok
      a TP rendszer komponensei
          o forrásprogram (pl. xxx.pas)
          o fordító- és szerkesztõprogram (turbo.exe)
                   a TP integrált fejlesztõi rendszere (IDE)
          o programegységek vagy unit-ok
                   System unit (alapvetõ alprogramok; megtalálási helyük a turbo.tpl, system.tpu,
                      system.tpp, vagy system.tpw)
                           read, readln, write, writeln
                           assign, reset, rewrite, append, close
                           length, copy, delete, insert, pos
                           ...
                   Crt (Cathode Ray Tube) unit (képernyõ- és billentyûzetkezelõ alprogramok, változók, és
                      konstansok; megtalálási helyük a turbo.tpl, crt.tpu, crt.tpp, vagy crt.tpw)
                           clrscr, clreol
                           wherex, wherey, gotoxy
                           readkey, keypressed
                           ...
                   további standard unit-ok (pl. Dos, Graph, Overlay, Printer, stb.)
                   a felhasználó által definiált unit-ok (pl. library.tpu)
          o végrehajtható program (pl. zzz.exe)
      programfejlesztés Turbo Pascal nyelven (egy példán keresztül)
          1. Pascal forrásprogram megírása a TP szövegszerkesztõjével (pl. Hello.pas)
                     program Hello;
                     BEGIN
                     writeln('**********');
                     writeln('* Hello! *');
                     writeln('**********');
                     END.
          2. forrásprogram mentése, elsõ mentéskor a program nevének megadásával (F2)
          3. Pascal forrásprogram lefordítása (Alt F9) és lefuttatása (Ctrl F9)
          4. felhasználói képernyõ megnézése (Alt F5)
                 1. visszalépés a forrásprogramot tartalmazó ablakba (Esc)
          5. forrásprogram módosítása és a 2-5 lépések ismétlése addig, míg a kívánt eredményt nem kapjuk.
a TP integrált fejlesztõi környezete (IDE: Integrated Development Environment; ha Borland Pascal
környezetben dolgozunk, a TP fejlesztõi környezetét turbo.exe, és ne bp.exe módon indítsuk el!)

      fájlkezelés (File)
           o új fájl létrehozása (New)
           o (létezõ) fájl megnyitása (Open; F3)
           o aktuális fájl kimentése (Save; F2)
           o aktuális fájl kimentése új néven (Save as)
           o alapértelmezett könyvtár beállítása (Change dir)
           o kilépés (Exit; Alt X)
      szövegszerkesztés (Edit)
           o visszavonás (Undo)
           o kijelölt szövegblokk kezelése (szövegblokk kijelölése a Shift billentyû lenyomása mellett a
               kurzormozgató billentyûkkel lehetséges)
                    kivágás a vágólapra (Cut; Shift Delete)
                    másolás a vágólapra (Copy; Ctrl Insert)
                    beillesztés a vágólapról (Paste; Shift Insert)
                    kijelölés törlése (Clear; Ctrl Delete)
           o vágólap tartalmának szerkesztése új ablakban (Show clipboard)
      keresés (Search)
           o szöveg keresése (Find; Ctrl Q+F)
           o szöveg keresése és helyettesítése (Replace; Ctrl Q+A)
           o szöveg következõ elõfordulásának keresése (és helyettesítése) (Search again; Ctrl L)
           o adott sorszámú sorra ugrás (Go to line number)
           o futásidejû hibaüzenetben megadott címû utasítás megkeresése (Find error)
      futtatás (Run)
           o futtatás (Run, Ctrl F9)
           o szemantikai hibák feltárása (tesztelés)
                    lépésenkénti futtatás az alprogramokat egy utasításnak véve (Step over; F8)
                    lépésenkénti futtatás az alprogramok utasításainak egyenkénti végigkövetésével (Trace
                       into; F7)
                    utasítások végrehajtása a kurzor aktuális pozíciójáig (Go to cursor; F4)
                    lépésenkénti végrehajtás befejezése (Program reset; Ctrl F2)
           o program indítási (vagy parancssori) paramétereinek megadása (Parameters); ha egy program
               parancssori paramétereket vár, a TP integrált fejlesztõi környezete az itt megadott és szóközzel
               elválasztott karakterláncokat string típusú parancssori paraméterekként átadja a programnak
               futtatás (Ctrl F9) során
      fordítás (Compile)
           o aktuális fájl lefordítása (Compile; Alt F9)
                    szintaktikus hibák feltárása
           o végrehajtható program létrehozása az aktuális fájl és a hozzá kapcsolódó felhasználói unitok
               lefordításával (Make; F9)
           o fordítás helyének meghatározása (Destination)
                    fordítás a memóriába (Destination=Memory)
                    fordítás diszkre (Destination=Disk); ennek beállításával egy EXE kiterjesztésû
                       végrehajtható program hozható létre (pl. F9 vagy Alt F9 lenyomása után), amely a TP
                       integrált fejlesztõi rendszere nélkül, MS-DOS ablakban önállóan is futtatható például a
                       következõ módon:
                            Windows 9x-ben                          kiválasztása a Start menübõl
                            belépés a lefordított programot tartalmazó alkönyvtárba (pl. a cd parancs
                             többszöri kiadásával)
                            a program elindítása az esetleges parancssori paraméterek megadásával
                                  példa: Hello.exe futtatása MS-DOS ablakban (egy parancssori paraméter
                                    megadásával: hello Kata)
                                  megjegyzés: a parancssori paraméterek a TP integrált fejlesztõi
                                    környezetében is megadhatóak, lásd a Run menü Parameters menüpontját
   hibakeresés vagy nyomkövetés (Debug)
        o nyomkövetõ képernyõ megjelenítése (Watch)
        o felhasználói képernyõ megjelenítése (Output)
        o váltás a felhasználói képernyõre (User screen; Alt F5)
                 visszalépés a forrásprogramot tartalmazó ablakba (bármelyik billentyûvel, pl. Esc)
        o kifejezések kiértékelése, ill. változók értékének módosítása lépésenkénti programfuttatás esetén
            (Evaluate/modify; Ctrl F4)
        o változók aktuális értékének kiiratása a nyomkövetõ képernyõn lépésenkénti programfuttatás
            esetén (Add watch; Ctrl F7)
   beállítások (Options)
        o a Turbo Pascal fordító beállításai (Compiler)
                 matematikai számítások beállításai (Numeric processing)
                         matematikai társprocesszor használata (8087/80287; ahhoz, hogy a Turbo Pascal
                           Single, Double és Extended valós típusait használhassuk, ezt az opciót be kell
                           kapcsolnunk)
        o a Turbo Pascal által használt alkönyvtárak beállítása (Directories)
                 EXE és TPU kiterjesztésû fájlok alkönyvtára (EXE & TPU directory; ha üresen hagyjuk,
                    a Compile.Destination=Disk beállítás mellett F9 vagy Alt F9 hatására az EXE
                    kiterjesztésû végrehajtható programot az alapértelmezett alkönyvtárban hozza létre a
                    Turbo Pascal; az alapértelmezett könyvtár beállítása a File.Chage dir menüpontban
                    lehetséges)
        o beállítások mentése (Save ... TURBO.TP)
   ablakok kezelése (Window)
        o összes ablak megjelenítése a képernyõn (Tile)
        o ablakok megjelenítése egymást kártyaszerûen lefedve (Cascade)
        o aktuális ablak megjelenítése a teljes képernyõn (Zoom; F5)
        o következõ ablak megjelenítése (Next; F6)
        o aktuális ablak lezárása (Close; Alt F3)
   segítség (Help)
        o onlájn dokumentáció tartalomjegyzéke (Contents; F1)
        o onlájn dokumentáció tárgyszójegyzéke (Index; Shift F1)
        o témakeresés (Topic search; Ctrl F1)
        o visszalépés az elõzõ témára (Previous topic; Alt F1)
a Java Development Kit

      a Java programozási nyelv
           o standard nyelvi elemek (a nyelv alapvetõ szintaxisa, és az alkalmazások készítését nagyban
               megkönnyítõ csomagok)
           o felhasználók által definiált nyelvi elemek (a nyelv továbbfejlesztése adott célok megvalósítására;
               pl. a weblapszerkesztéskor hasznos Java appletek vagy könyvtári célú programok írására)
                     felhasználók által létrehozott csomagok
      a JDK használata
      a JDK rendszer komponensei
           o forrásprogram (pl. xxx.java)
                     Java appletek esetén egy HTML forrásfájl, amely hivatkozik a lefordított Java appletre
                       (pl. xxx.html)
           o a JDK fordítóprogramja (javac.exe)
           o hierarchikus könyvtárstruktúrába szervezett programcsomagok (forráskódjuk megtalálható pl. a
               telepített JDK könyvtárában levõ src.zip fájlban)
                     java.applet (pl. tartalmazza az Applet osztályt)
                     java.awt (pl. tartalmazza a Button, Checkbox, Color, Component, Font, Graphics, Image,
                       Label, TextField, stb. osztályokat)
                             java.awt.event (pl. tartalmazza az ActionListener osztályt)
                     java.io (pl. tartalmazza az InputStream, OutputStream, stb. osztályokat)
                     java.lang (pl. tartalmazza a Character, Double, Integer, String, stb. osztályokat)
                     java.util (pl. tartalmazza a Calendar, Date, stb. osztályokat)
                     ...
           o lefordított, un. bájtkódú Java program (pl. xxx.class)
           o Java programok futtatása
                     önálló Java alkalmazások esetén a JDK Java interpreterével (JVM, Java Virtuális Gép;
                       java.exe)
                     Java appletek esetén egy HTML- vagy appletmegjelenítõ programmal
                             WWW böngészõprogram (pl. Netscape Communicator vagy Internet Explorer; ez
                               utóbbival csínján kell bánni, mert a Microsoft az IE újabb verzióiban nem
                               támogatja az <APPLET> HTML tagot!)
                             a JDK appletmegjelenítõ programja (appletviewer.exe)
a JDK használata

      a JDK-t tartalmazó fájlok letöltése a Sun weblapjáról (java.sun.com)
           o telepíthetõ program Windows platformra (pl. j2sdk-1_4_0-beta-win.exe)
           o a JDK teljes dokumentációja angol nyelven (j2sdk-1_4_0-beta-doc.zip)
      a JDK telepítése (pl. a c:\Program Files\j2sdk könyvtárba)
      alkönyvtár létrehozása a saját fejlesztésû programok számára (pl. C:\Temp\myclass)
      hasznos kötegelt (batch) programok létrehozása a saját fejlesztésû programokat tartalmazó
       alkönyvtárban
           o önálló Java programok fordítását végzõ batch program létrehozása (javac.bat)
                     "c:\Program Files\j2sdk\bin\javac.exe" %1.java
                     java %1 %2 %3 %4 %5 %6 %7 %8 %9
           o önálló Java programok fordítását és futtatását végzõ batch program létrehozása (proba.bat)
                     "c:\Program Files\j2sdk\bin\javac.exe" %1.java
                     "c:\Program Files\j2sdk\bin\java.exe" %1 %2 %3 %4 %5 %6 %7 %8 %9
           o Java appletek fordítását és futtatását végzõ batch program létrehozása (test.bat)
                     "c:\Program Files\j2sdk\bin\javac.exe" %1.java
                     "c:\Program Files\j2sdk\bin\appletviewer.exe" %1.html
           o a korábbi fejlesztésû böngészõkben is futtatható Java appletek fordítását és futtatását végzõ
               batch program létrehozása (test11.bat)
                     "c:\Program Files\j2sdk\bin\javac.exe" -target 1.1 %1.java
                     "c:\Program Files\j2sdk\bin\appletviewer.exe" %1.html
      a Java programfejlesztéshez szükséges ablakok megnyitása
           o a forrásprogramok létrehozására vagy módosítására szolgáló szövegszerkesztõ megnyitása,
               célszerûen pl. a Windows Commander-bõl (új fájl létrehozása: Shift F4, egy már meglévõ fájl
               szerkesztése: F4)
                     fontos: Windows 9x rendszerben célszerû hozzárendelni a társítási adatbázisban
                        (Sajátgép.Nézet.Beállítások.Fájltípus) a java kiterjesztésû fájlokhoz a Jegyzettömb
                        szövegszerkesztõt (C:\Windows\Notepad.exe)
           o a Java programfejlesztésre szolgáló ablak megnyitása (pl. Windows Commander-bõl a
               parancssorban kiadott command paranccsal; az így megnyitott DOS ablakot a munka végeztével
               az exit paranccsal zárhatjuk majd le)
      programfejlesztés Java nyelven (egy példán keresztül, Windows Commander használatát feltételezve)
           1. a Java forrásprogram megírása a Jegyzettömb-ben (Hello.java); SHIFT F4 után a megadott
               fájlnév és az osztálynév kötelezõen megegyezik (a nagy- és kisbetûk között különbséget téve), a
               fájl kiterjesztése pedig java kell, hogy legyen:
                     public class Hello {
                     public static void main(String[] args) {
                     System.out.println("**********");
                     System.out.println("* Hello! *");
                     System.out.println("**********");
                     }
                     }
          2. a Java forrásprogram kimentése (Fájl.Mentés vagy Ctrl S)
          3. a Java forrásprogram lefordítása és lefuttatása (proba Hello beírása a DOS ablak rendszerjele
             után és Enter)
          4. a Java forrásprogram módosítása, és a 2-4. lépések ismétlése addig, míg a kívánt eredményt nem
             kapjuk.


                                                                                  Boda István, 2003. december 17 .
képernyõkezelés, standard i/o

      képernyõkezelés szöveges felületen (Turbo Pascal)
      standard input (Turbo Pascal)
      standard output



képernyõkezelés szöveges felületen (Turbo Pascal; a Crt unit használatát igényli)

      képernyõtörlés
           o a teljes képernyõre (ClrScr)
           o a kurzor pozíciójától a sor végéig (ClrEol)
      színbeállítás
           o színmegadás színkonstansok segítségével
           o elõtér ("tinta") színének beállítása (TextColor; pl. TextColor(yellow); vagy
               TextColor(red+blink); )
                     alapértelmezés: lightgray (7)
           o háttér színének beállítása (TextBackground; pl. TextBackground(brown); )
                     alapértelmezés: black (0)
           o aktuális beállítások tárolása 8 biten (Crt.TextAttr; Bbbbffff formátumban)
                     B: villogást jelzõ bit
                     bbb: háttérszín (3 biten: 0..7)
                     ffff: elõtérszín (4 biten: 0..15)
      kiiratás a szöveges képernyõ tetszõleges pozíciójában (direkt képernyõkezelés)
           o szöveges képernyõ szerkezete (képernyõpozíciók azonosítása egy koordinátarendszer
               segítségével)
                     a középpont (origó) a képernyõ bal felsõ sarkában (1,1)
                     az x tengely a képernyõn vízszintesen, balról jobbra (1,...,80)
                             oszlopfelbontás (80 oszlop)
                     az y tengely a képernyõn függõlegesen, felülrõl lefelé (1,...,25)
                             sorfelbontás (25 sor)
                     a képernyõ (szöveges) képpontjainak koordinátái
                             képernyõ bal felsõ sarka (1,1)
                             képernyõ jobb alsó sarka (80,25)
                                     karakter kiíratásakor a képernyõ automatikus görgetése
                             képernyõ hozzávetõleges középpontjai (39,13) vagy (40,13)
           o következõ kiírandó karakter helyének (un. kurzor) lekérdezése (WhereX, WhereY; pl.
               x:=WhereX; )
                     példa: adat bekérése és szöveg kiiratása a bekérés sorában
           o kurzor pozícionálása (GotoXY; pl. GotoXY(x,1); )
színmegadás színkonstansok segítségével (Crt unit)

         háttérszínek (használhatóak az elõtérszín magadásakor is)
              o black (0)
              o blue (1)
                       XXXXXXXXXXXXXXX
              o green (2)
              o cyan (vagy aqua, zöldeskék; 3)
                       XXXXXXXXXXXXXXX
              o red (4)
              o magenta (vagy fuchsia, bíborvörös vagy "kékespiros"; 5)
                       XXXXXXXXXXXXXXX
              o brown (6)
                       XXXXXXXXXXXXXXX
              o lightgray (vagy lightgrey, világosszürke; 7)
                       XXXXXXXXXXXXXXX
         elõtér- vagy karakterszínek
              o a háttérszíneknél megadott színkonstansok itt is használhatóak (0..7)
              o darkgray (sötétszürke; 8)
                       XXXXXXXXXXXXXXX
              o lightblue (világoskék; 9)
                       XXXXXXXXXXXXXXX
              o lightgreen (10)
              o lightcyan (11)
              o lightred (12)
              o lightmagenta (13)
              o yellow (14)
              o white (15)
         villogás (az elõtérszínekhez adható hozzá; pl. TextColor(red+blink); )
              o blink (128)




példa: adat bekérése és szöveg kiiratása a bekérés sorában
program pelda1;
uses crt;
var s:string;
begin
clrscr;
write('Mi a neved? ');
readln(s);
gotoxy(1,wherey-1); {kurzor visszaléptetése az elõzõ sor elejére}
clreol;
writeln('Hello ',s,'!');
end.
standard input (Turbo Pascal)

         adatok beolvasása
              o karaktersorozat beolvasása (Enter leütéséig; mindkét eljárás soremeléssel jár!)
                      a billentyûzetpuffer törlésével (ReadLn)
                      a billentyûzetpuffer törlése nélkül (Read)
                              bevitelkor egy sorban megadott több adat beolvashatósága több lépésben (pl.
                                 "elõregépelés" vagy táblázatok kitöltése)
                      példa: több adat beolvasása egy sorban
              o egy (alfanumerikus) billentyû ASCII kódjának beolvasása (Crt.ReadKey)
              o egy vezérlõbillentyû kiterjesztett kódjának beolvasása (a ReadKey standard függvény meghívása
                 kétszer egymás után, ha az elsõ hívás #0-t ad; a második hívás a lenyomott vezérlõbillentyû
                 kiterjesztett kódját adja vissza; pl. ch:=readkey; if ch=#0 then ch:=readkey; )
         várakozás egy billentyû leütésére (Crt.KeyPressed; pl. repeat until keypressed; )
         hibakezelés (kivételkezelés nem megfelelõ adat beolvasásakor)
              o nem megfelelõ adattípus kezelése (a $I fordítói direktíva és az IOResult standard függvény
                 használata; pl. szöveg beírása szám helyett)
                      példa: nem megfelelõ típusú adat beírásából származó kivétel kezelése
              o a mûveletek által megengedett értelmezési tartományon kívül esõ érték kezelése (pl. a nulla érték
                 nem megengedett osztáskor, a negatív érték hatványozáskor, stb.)
                      példa: nullával való osztás elkerülése




példa: több adat beolvasása egy sorban
program pelda2;
uses crt;
var x,y,z:integer;
begin
clrscr;
write('A számok: ');
read(x);read(y);readln(z); {több adat beolvasása egy sorban; egyenértékû a readln(x,y,z); utasítással }
writeln('A beolvasott számok: ',x,' ',y,' ',z);
end.

példa: nem megfelelõ típusú adat beírásából származó kivétel kezelése
program pelda3a;
uses crt;
var i:integer;
begin
clrscr;
write('Kérek egy számot: ');
{$I-}readln(i);{$I+}
if ioresult<>0 then writeln('A beolvasott karaktersorozat nem szám!')
                  else writeln('A beolvasott szám: ',i);
end.
példa: nullával való osztás elkerülése
program pelda3b;
uses crt;
var i,j:integer;
begin
clrscr;
write('Kérek egy számot: ');
readln(i);
write('Kérek egy másik számot: ');
readln(j);
if j=0 then writeln('A két szám hányadosa nem értelmezhetõ!')
        else writeln('i : j = ',i/j:3:2);
end.


standard output

         adatok kiírása
             o karaktersorozat kiíratása (a kurzor pozíciójától kezdõdõen)
                       kiírás után soremeléssel (WriteLn (Turbo Pascal), System.out.println (Java))
                       soremelés nélkül (Write (Turbo Pascal), System.out.print (Java))
             o kiírási formátum megadása (Turbo Pascal; ha a megadott értékes számjegyek vagy karakterek
                 tényleges száma több, mint amennyit a formátumban megadtunk, minden értékes számjegy vagy
                 karakter kiíródik)
                       egész típusú adat esetén a kiírandó számjegyek száma (elõjellel együtt) (pl. i:4 az i egész
                         típusú változó értékét minimum 4 karakter hosszan írja ki)
                              példa: két egész szám beolvasása és az alapmûveletek értékének kiírása
                       valós típusú adat esetén a kiírandó összes karakter száma (a tizedesponttal, és
                         normálalakban történõ kiíráskor a karakterisztikával együtt) és a kiírandó tizedesjegyek
                         száma (pl. x:8:2 az x valós típusú változó értékét minimum 8 karakter hosszan és ezen
                         belül 2 tizedesjeggyel írja ki); a kiiratási formátumban a tizedesjegyek számát nem
                         kötelezõ megadnunk, ekkor a valós érték kiírása normálalakban történik (ld. alább)
                              az alapértelmezett kiíratási formátum az un. tízes normálalak, egy egész és tíz
                                 tizedesjeggyel, valamint két számjegyes karakterisztikával (m*10^k; pl. -
                                 1.2000000000E+00 vagy 3.3333333333E-05 )
                                      mantissza (egy egész és 10 tizedesjegy, 1<=|m|<10)
                                      karakterisztika (két számjegy)
                              példa: két valós szám beolvasása és az alapmûveletek értékének kiírása
                       karakteres vagy karakterlánc típusú adat esetén a kiírandó karakterek száma (a kiírás
                         jobbra igazítva történik, ha az értékes karakterek száma kevesebb, mint a megadott
                         karakterszám; pl. s:10 az s karakterlánc típusú változó értékét minimum 10 karakter
                         hosszan írja ki; ha s tartalma pl. 'Hello', azaz s 5 értékes karaktert tartalmaz, akkor s
                         értéke elõtt 5 szóközt helyez el)
         beépített hangszóró (Speaker) használata (Turbo Pascal; Crt unit)
példa: két egész szám beolvasása és az alapmûveletek értékének kiírása
program pelda4a;
uses crt;
var x,y:integer;
begin
clrscr;
write('Kérek egy számot: ');readln(x);
write('Kérek egy másik számot: ');readln(y);
writeln('x + y = ':10,(x+y):10);
writeln('x - y = ':10,(x-y):10);
writeln('x * y = ':10,(x*y):10);
if y<>0 then writeln('x / y = ':10,(x/y):13:2)
          else writeln('Nullával nem lehet osztani!');
if y<>0 then writeln('x div y = ':10,(x div y):10)
          else writeln('Nullával nem lehet maradékosan osztani!');
if y<>0 then writeln('x mod y = ':10,(x mod y):10)
          else writeln('Nullával nem lehet maradékot képezni!');
end.


példa: két valós szám beolvasása és az alapmûveletek értékének kiírása
program pelda4b;
uses crt;
var x,y:real;
begin
clrscr;
write('Kérek egy számot: ');readln(x);
write('Kérek egy másik számot: ');readln(y);
writeln('A számok összege: ',(x+y):3:2);
writeln('A számok különbsége: ',(x-y):3:2);
writeln('A számok szorzata: ',(x*y):3:2);
if y<>0 then writeln('A számok hányadosa: ',(x/y):3:2)
          else writeln('Nullával nem lehet osztani!');
end.
beépített hangszóró (Speaker) használata (Crt unit)

        hang megszólaltatása (Sound)
             o egyvonalas 'a' hang megszólaltatása (Sound(440); )
             o félhangköz (fh:=1.059463094359; vagy fh := exp(ln(2)/12); )
             o 'a' hang megemelése adott hangközökkel (Sound(trunc(440*x)); )
                        kis szekund (x:=fh)
                        nagy szekund (x:=fh*fh)
                        kis terc (x:=fh*fh*fh)
                        nagy terc (x:=fh*fh*fh*fh)
                        ...
                        oktáv (x:=2; ami egyenértékû az x:=exp(12*ln(fh)); értékadással)
             o kétvonalas 'a' hang megszólaltatása (Sound(880); )
             o ...
        késleltetés (Delay)
             o késleltetés egy másodpercig, azaz 1000 ezredmásodpercig (delay(1000); )
        hang megszüntetése (NoSound)
        példa: boci-boci tarka




példa: boci-boci tarka
program pelda5;
uses crt;
var fh:real;
    d,r,m,f,sz:word;
    t:word;
begin
fh:=exp(ln(2)/12);
d:=440; {dó: a-dúr...}
r:=trunc(fh*fh*d); {ré}
m:=trunc(fh*fh*r); {mi}
f:=trunc(fh*m); {fá}
sz:=trunc(fh*fh*f); {szó}
t:=5000; {egy negyedhang}
sound(d);delay(t);
sound(m);delay(t);
sound(d);delay(t);
sound(m);delay(t);
sound(sz);delay(2*t); {egy félhang}
nosound;delay(t div 4); {egy tizenhatod hangnyi szünet}
sound(sz);delay(2*t);
nosound;
end.

                                                                                            Boda István, 2003. május 10.
egyszerû adattípusok

      adattípusok általános jellemzõi
      a kettes (bináris) számrendszer használata
      a tizenhatos (hexadecimális) számrendszer használata
      a Turbo Pascal adattípusai
      a Java adattípusai



adattípusok általános jellemzõi

      értéktartomány
      helyfoglalás
      kódolás (adatábrázolás)
      szerkezet (összetett típusok esetén)
           o komponensek típusa (pl. egy rekord mezõinek típusa)




a kettes (bináris) számrendszer használata

      bináris számjegyek vagy bitek (0 és 1)
      helyiértékek (kettõ hatványai)
                 0       1     2      3     4       5        6       7          8
           o 2 = 1, 2 = 2, 2 = 4, 2 = 8, 2 = 16, 2 = 32, 2 = 64, 2 = 128, 2 = 256, ...
      bináris számrendszerben megadott egész szám átváltása decimális számrendszerbe
                                 3      2      1       0
           o példa: 10102 = 1*2 + 0*2 + 1*2 + 0*2 = 1*8 + 1*2 = 1010
      decimális számrendszerben megadott egész szám átváltása bináris számrendszerbe
           o példa: 17910 = 101100112 (a számítás menete)
      bináris számrendszerben megadott törtszám ("kettedestört") átváltása decimális számrendszerbe
       (megjegyzés: a helyiértékek a "kettedespont" után 2 negatív egész hatványai lesznek, például 2-1=1/2, 2-
       2
         =1/4, 2-3=1/8, stb.)
           o példa: 0.1012 = 1*(1/2) + 0*(1/4) + 1*(1/8) = (1/2) + (1/8) = 5/8 = 0.62510
      decimális számrendszerben megadott törtszám (tizedestört) átváltása bináris számrendszerbe
           o példa: 0.687510 = 0.10112 (a számítás menete)
      bináris számrendszerben megadott szám átváltása hexadecimális számrendszerbe (négyes számjegy-
       csoportok képzésével)
           o példa: 101100112 = (10112)(00112) = (1110)(310) = (B16)(316) = B316
      hexadecimális számrendszerben megadott szám átváltása bináris számrendszerbe
           o példa: A716 = (A16)(716) = (1010)(710) = (10102)(01112) = 101001112




decimális számrendszerben megadott egész szám átváltása bináris számrendszerbe: az eredmény
kiszámításának lépései

   1. a táblázat elsõ sorának elsõ oszlopába az átváltandó számot írjuk be, ennek a sornak a második oszlopát
      üresen hagyjuk;
   2. a táblázat további sorait - sorban egymás után - úgy számítjuk ki, hogy az utoljára kiszámított sor elsõ
      oszlopában szereplõ értéket (maradékosan) osztjuk 2-vel, és
          o az osztás (egész) eredményét a következõ sor elsõ oszlopába,
          o az osztás maradékát pedig ennek a sornak a második oszlopába írjuk;
   3. ezt az eljárást addig folytatjuk, ameddig az osztás eredménye 0 nem lesz.
179
89 1
44 1
22 0
11 0
5     1
2     1
1     0
0     1
az eredményt úgy kapjuk, hogy a második oszlopban szereplõ maradékokat "visszafelé", azaz alulról felfelé
olvassuk:
179 = 101100112

decimális számrendszerben megadott törtszám (tizedestört) átváltása bináris számrendszerbe: az eredmény
kiszámításának lépései

    1. a táblázat elsõ sorának elsõ oszlopába 0-t, második oszlopába a tizedespontot, harmadik oszlopába pedig az
       átváltandó szám tizedespont utáni számjegyeit írjuk be;
    2. a táblázat további sorait - sorban egymás után - úgy számítjuk ki, hogy az utoljára kiszámított sor elsõ oszlopában
       levõ egész értéket figyelmen kívül hagyjuk és csak a harmadik oszlopában szereplõ értéket szorozzuk 2-vel; a
       szorzás eredményét a következõ sorba írjuk:
           o az egész értéket az elsõ oszlopba,
           o a tizedespontot a második oszlopba, és
           o a tizedespont utáni számjegyeket a harmadik oszlopba;
    3. ezt az eljárást addig folytatjuk, ameddig a harmadik oszlopban 0-t nem kapunk.

0 . 6875
1 . 3750
0 . 7500
1 . 5000
1 . 0000
az eredményt úgy kapjuk, hogy az elsõ oszlopban szereplõ egész értékeket felülrõl lefelé olvassuk:
0.687510 = 0.10112

a tizenhatos (hexadecimális) számrendszer használata

         hexadecimális számjegyek
              o decimális számjegyek (0,1,...,9)
              o kiegészítõ számjegyek (A=10, B=11, C=12, D=13, E=14, F=15)
         hexadecimális helyiértékek (16 hatványai)
                    0        1         2           3        4
              o 16 = 1, 16 = 16, 16 = 256, 16 = 4096, 16 = 65536, ...
         hexadecimális számrendszerben megadott szám átváltása decimális számrendszerbe
                                         2       1       0
              o példa: A1916 = 10*16 + 1*16 + 9*16 = 10*256 + 1*16 + 9*1 = 258510
         decimális számrendszerben megadott szám átváltása hexadecimális számrendszerbe (a legegyszerûbb elõször a
          megadott számot bináris számrendszerbe átváltani, majd ezt négyes számjegy-csoportok képzésével egyszerûen
          hexadecimális számmá alakítani)
              o példa: 258510 = (átváltás bináris számrendszerbe) = 1010000110012 = (10102)(00012)(10012) =
                 (1010)(110)(910) = (A16)(116)(916) = A1916



a Turbo Pascal adattípusai
       egyszerû (elemi) típusok
            o sorszámozott vagy megszámlálható típusok (az értéktartomány elemeihez sorszámok rendelhetõek,
                amelyek természetes számok)
            o valós típusok
                                                       127   127
                       real (értéktartomány: kb. -2 ..+2 közötti valós számok max. 40 kettedesjegy pontossággal;
                         helyfoglalás: 6 bájt; kódolás: lebegõpontos számábrázolás)
                       matematikai társprocesszor használatát igénylõ valós típusok
                       példa: a Turbo Pascal különbözõ valós típusainak pontossága
            o karakterlánc típus (mivel a karakterláncot alkotó karakterek egyenként is elérhetõek, összetett típusnak is
                tekinthetõ!)
       összetett (strukturált) típusok (további típusokból, un. komponensekbõl épülnek fel)
            o tömb (array; a komponensek azonos típusúak)
            o rekord (record; a komponensek különbözõ típusúak)
            o ...




sorszámozott vagy megszámlálható típusok

       numerikus (egész) típusok
            o egész vagy elõjeles típusok (az értéktartomány egész értékekbõl áll)
            o elõjel nélküli típusok (az értéktartomány nemnegatív egész értékekbõl áll)
                      byte (értéktartomány: 0..255; helyfoglalás: 1 bájt; kódolás: un. egyenes kódolás, azaz az értékek
                          kettes számrendszerbeli alakja felel meg a biteknek)
                      word (értéktartomány: 0..65535; helyfoglalás: 2 bájt; kódolás: egyenes kódolás)
       karakter típus
            o char (értéktartomány: #0..#255, ahol pl. #65 az ASCII kódtábla 65-ös kódú karakterét jelenti (256
                 különbözõ karakter); helyfoglalás: 1 bájt; kódolás: ASCII, ill. a 7 bites ASCII kódrendszernek a
                 számítógépen beállított kódtáblának megfelelõ, a nemzetközi karakterkészleteket is tartalmazó 8 bites
                 kiterjesztése)
                      a Turbo Pascal kiterjesztett karakterkódjai
       logikai típus
            o Boolean (értéktartomány: False és True; helyfoglalás: 1 bájt; kódolás: a False értéknek a 00000000 érték
                 felel meg, a True értéknek pedig bármilyen, ettõl különbözõ érték, alapértelmezésben 00000001)



egész vagy elõjeles típusok

       shortint (értéktartomány: -128..127 közötti egész számok; helyfoglalás: 1 bájt; kódolás: kettes komplemens kód)
            o 1. példa: 1 kettes komplemens alakja 00000001 (egyenes kódolás pozitív számok esetén)
            o 2. példa: -1 kettes komplemens alakja 11111111 (kettes komplemens kódolás negatív számok esetén)
                      1. lépés: |-1| = 1 egyenes kódban 00000001
                      2. lépés: 00000001 egyes komplemens kódban (komplementálva) 11111110
                      3. lépés: 11111110 + 1 = 11111111 (O.K.)
            o 3. példa: a kettes komplemens kódban megadott 10101010 bitsorozatnak megfelelõ egész szám -86
                      1. lépés: 10101010 egyes komplemense 01010101
                      2. lépés: 01010101 + 1 = 01010110
                      3. lépés: egyenes kódolás esetén 01010110 = 64 + 16 + 4 + 2 = 86
                      4 lépés: az eredeti bitsorozat elõjelbitje 1 (negatív szám), tehát a végeredmény -86 (O.K.)
       integer (értéktartomány: -32768..32767 közötti egész számok; helyfoglalás: 2 bájt; kódolás: kettes komplemens
        kód)
       longint (értéktartomány: -231..(231-1) közötti egész számok; helyfoglalás: 4 bájt; kódolás: kettes komplemens
        kód)
lebegõpontos számábrázolás (a Turbo Pascal real típusa esetén)

      számábrázolás nem zérus érték esetén: kettes normálalakban (x = m*2k)
           o mantissza: 0.5 <= |m| < 1, m-et binárisan (kettedestört alakban) ábrázoljuk, elhagyva a kezdõ 0.1
              tagot, amely minden m esetén megegyezik
           o karakterisztika: -128 < k < 128, ahol k-t többleteskódban (k') ábrázoljuk (k' = k+128, ezért 0 < k'
              < 256)
      számábrázolás zérus érték esetén: az ábrázolt szám minden bitje 0
           o megjegyzés: ha a legalacsonyabb helyiértékû bájt (LSB) minden bitje 0 (azaz ha normálalakban
              ábrázoljuk a számot, a karakterisztika -128), akkor a többi bájt értékétõl függetlenül az ábrázolt
              szám zérus, vagyis 0.5*2-127-nél kisebb abszolút értékû számot a Turbo Pascal real típusa nem
              képes ábrázolni
      helyfoglalás: 6 bájt = 48 bit ( | 5. bájt = MSB | 4. bájt | ... | 1. bájt | 0. bájt = LSB | )
           o MSB (Most Significant Byte; a legnagyobb helyiértékû bájt, amely a memóriában a
              legmagasabb memóriacímen helyezkedik el; a valós számot bitsorozatként ábrázolva ez a bal
              szélsõ bájt)
                   bal szélsõ (legnagyobb helyiértékû) bit: elõjelbit (0 nemnegatív, 1 negatív számok
                      esetén)
                   további (alacsonyabb helyiértékû) 7 bit: a kettedestört alakban ábrázolt mantissza
                      "kettedespont" utáni bináris számjegyei az elsõ (1/2-es helyiértékû) bit elhagyásával,
                      azaz az 1/4-es helyiértéktõl kezdõdõen
                                                    -1      -2        -3
                   példa: ha m = 0.1012 = 1*2 + 0*2 + 1*2 = 1*0.5 + 0*0.25 + 1*0.125 = 0.62510, akkor
                      MSB = 00100000 (ha m nyolcnál kevesebb kettedesjegybõl áll, egyszerûen kiegészítjük
                      megfelelõ számú nullával, ha pedig több kettedesjegybõl áll, ezeket az MSB utáni
                      bájtokon ábrázoljuk, ld. alább)
           o az MSB 7 alacsonyabb helyiértékû bitje, és a következõ 4 bájt (összesen 39 bit)
                   az ábrázolt szám mantisszájának bináris számjegyei az 1/4-es helyiértéktõl kezdõdõen
                      (mivel 0.5 <= |m| < 1 teljesül, ezért minden mantissza kettedestört alakban 0.1 módon
                      kezdõdik, tehát elég csak az 1/2-es helyiérték utáni biteket ábrázolni)
           o LSB (Least Significant Byte; a legkisebb helyiértékû bájt, amely a memóriában a
              legalacsonyabb memóriacímen helyezkedik el)
                   az ábrázolt szám karakterisztikája többleteskódban (eltolva 128-cal)
      példák
          o   +2.9..*10-39 = 0.5*2-127 = |00000000|...|00000000|00000001|
                   megjegyzés: ez a real típussal ábrázolható legkisebb nem zérus érték
          o   +0.25 = +0.5*2-1 = |00000000|...|00000000|01111111|
          o   +0.5 = +0.5*20 = |00000000|...|00000000|10000000|
          o   -0.5 = -0.5*20 = |10000000|...|00000000|10000000|
          o   +0.625 = +0.625*20 = |00100000|...|00000000|10000000|
                   megjegyzés: 0.625 = 0.5 + 0.125 = 1/2 + 1/8, tehát a mantissza kettedestört alakban m = 0.101 (amelybõl
                     csak a kezdõ 0.1 utáni bináris számjegyeket ábrázoljuk)
          o   +1 = +0.5*21 = |00000000|...|00000000|10000001|
          o   -2 = -0.5*22 = |10000000|...|00000000|10000010|
          o   +1.7..*1038 = 0.99..*2127 = |01111111|...|11111111|11111111|
                   megjegyzés: ez a real típussal ábrázolható legnagyobb (pozitív) érték
matematikai társprocesszor használatát igénylõ valós típusok (az Options.Compiler menüpont kiválasztásakor
megjelenõ Compiler Options ablakban be kell kapcsolni a Numeric Processing csoportban levõ 8087/80287
opciót (vagy a forrásprogram elején, a program kulcsszó elõtt el kell helyeznünk egy {$N+} fordítói
direktívát), hogy használhassuk õket)

      Single (4 bájtos lebegõpontos típus, 8 bites karakterisztikával)
      Double (8 bájtos lebegõpontos típus, 12 bites karakterisztikával)
      Extended (10 bájtos lebegõpontos típus, 15 bites karakterisztikával)



a Turbo Pascal különbözõ valós típusainak pontossága (a Turbo Pascal, ha másként nem adjuk meg, a valós
számértékeket normálalakban 1 egész és 14 tizedesjeggyel, valamint 4 számjegyes karakterisztikával írja ki; ezt
felülbírálhatjuk pl. writeln(x:30); módon, ekkor 17 tizedesjegyet fog kiírni, de ennek csak extended típus
esetén van értelme)
Pi értéke: 3.14159265358979324E+0000


      Single:   3.14159274101257E+0000 (hat tizedesjegyig pontos)
      Real:     3.14159265358830E+0000 (tizenegy tizedesjegyig pontos)
      Double:    3.14159265358979312E+0000 (tizenöt tizedesjegyig pontos)
      Extended: 3.14159265358979324E+0000


'e' értéke: 2.71828182845904524E+0000


      Single:   2.71828174591064E+0000 (hat tizedesjegyig pontos)
      Real:     2.71828182846002E+0000 (tíz tizedesjegyig pontos)
      Double:    2.71828182845904509E+0000 (tizenöt tizedesjegyig pontos)
      Extended: 2.71828182845904524E+0000




karakterlánc típus

      string (értéktartomány: az üres (0 karakter hosszúságú) string, továbbá minden elképzelhetõ
       karakterkombináció min. egy, max. 255 számú karakterbõl; helyfoglalás: 256 bájt; kódolás: a string
       legelsõ (0-s sorszámú) bájtja a stringben ténylegesen tárolt karakterek számát adja meg, a többi (1..255
       sorszámú) bájton pedig a karakterek ASCII kódját tároljuk)
           o a string típus olyan összetett adattípusnak is tekinthetõ, amelynek a komponensei a stringet
               alkotó karakterek, amelyek sorszámuk alapján közvetlenül is elérhetõek (pl. s:='Hello!';
               értékadás után writeln(s[2]); az s string második karakterét, esetünkben az e karaktert fogja
               kiírni a képernyõre); azonban a karakter-típusú tömböktõl a stringeket megkülönbözteti a string
               aktuális hosszát megadó, 0-s sorszámú "karakter", amely karakter típusú tömbök esetén nem
               létezik
           o példa: egy string karaktereinek kiírása egymás alá, külön sorokba
      csökkentett hosszúságú string (string[n], ahol n egy 1 és 255 közötti természetes szám, amely a
       stringben tárolható karakterek max. számát adja meg)
egy string karaktereinek kiírása egymás alá, külön sorokba
program pelda1;
uses crt;
var s:string[40];
       i,k:byte;
begin
write('Kérek egy max. 40 karakterbõl álló szöveget: ');
readln(s);
k:=byte(s[0]); {ugyanezt kapnánk a k:=length(s); utasítással is}
writeln('A string hossza: ',k);
for i:=1 to k do
  writeln(s[i]);
end.


a Java adattípusai

        egyszerû, un. elemi típusok
            o numerikus (egész és karakter) típusok
                      byte (értéktartomány: -128..127; helyfoglalás: 1 bájt; kódolás: kettes komplemens kód)
                      short (értéktartomány: -32768..32767; helyfoglalás: 2 bájt; kódolás: kettes komplemens
                          kód)
                                                31   31
                      int (értéktartomány: -2 ..(2 -1); helyfoglalás: 4 bájt; kódolás: kettes komplemens kód)
                                                  63   63
                      long (értéktartomány: -2 ..(2 -1); helyfoglalás: 8 bájt; kódolás: kettes komplemens kód)
                      char (értéktartomány: 65536 különbözõ karakter; helyfoglalás: 2 bájt; kódolás: Unicode)
            o numerikus (valós) típusok
                                                      128   128
                      float (értéktartomány: kb. -2 ..2        közötti valós számok; helyfoglalás: 4 bájt; kódolás:
                          lebegõpontos számábrázolás)
                                                         1024 1024
                      double (értéktartomány: kb. -2        ..2   közötti valós számok; helyfoglalás: 8 bájt;
                          kódolás: lebegõpontos számábrázolás)
            o logikai típus
                      boolean (értéktartomány: true vagy false; helyfoglalás: 1 bájt)
        összetett, un. referencia típusok
            o objektum-típusok vagy osztályok (pl. String)
            o tömbök (pl. String[] args)
lebegõpontos számábrázolás (a Java double típusa esetén az IEEE 754 szabvány szerint)

      számábrázolás kettes normálalakban (x = m*2k)
           o karakterisztika: -1022 <= k < 1025, ahol k-t többleteskódban (k') ábrázoljuk (k' = k+1022, ezért
              0<= k' < 2047)
           o mantissza: m-et binárisan (kettedestört alakban) ábrázoljuk, és
                    ha -1021 <= k <= 1024 akkor 0.5 <= |m| < 1, ábrázoláskor elhagyjuk a kezdõ 0.1 tagot,
                       amely minden m esetén megegyezik (azaz csak a kettedespont és az utána, az 1/2
                       helyiértéken következõ 1 utáni bináris számjegyeket ábrázoljuk)
                    ha k= -1022 akkor 0<= |m| < 1, ábrázoláskor elhagyjuk a kezdõ 0. tagot, amely
                       minden m esetén megegyezik (azaz csak a kettedespont utáni bináris számjegyeket
                       ábrázoljuk)
      helyfoglalás: 8 bájt
           o MSB (Most Significant Byte; a legnagyobb helyiértékû bájt, amely a memóriában a
              legmagasabb memóriacímen helyezkedik el)
                    bal szélsõ (legnagyobb helyiértékû) bit: elõjelbit (0 nemnegatív, 1 negatív számok
                       esetén)
           o az MSB 7 alacsonyabb helyiértékû bitje, és a következõ 4 bit (összesen 11 bit)
                    az ábrázolt szám karakterisztikája többleteskódban (eltolva 1022-vel)
           o az MSB utáni bájt alacsonyabb helyiértékû 4 bitje és a következõ 6 bájt 6*8 = 48 bitje (összesen
              52 bit)
                    ha a karakterisztika = -1022, az ábrázolt szám mantisszájának bináris számjegyei az 1/2-
                       es helyiértéktõl kezdõdõen (0. után)
                                                                            -52   -1022
                            az ábrázolható legkisebb (nem 0) érték: 2 * 2              = 2-1074
                    ha a karakterisztika -1021 és +1024 közé esik, akkor az ábrázolt szám mantisszájának
                       bináris számjegyei az 1/4-es helyiértéktõl kezdõdõen (0.1 után)
                                                                                 1024
                            az ábrázolható legnagyobb érték: 0.99.....9 * 2          ~ 21024
                    ha a karakterisztika +1025, akkor vagy un. pozitív / negatív végtelen, vagy un. NaN
                       (Not-a-Number) értéket kapunk (ez kb. megfelel a lebegõpontos túlcsordulásnak)
      példák ( | 7. bájt = MSB | 6. bájt | ... | 1. bájt | 0. bájt = LSB | alakban megadva az ábrázolt értékeket)
          o   +4.9*10-324(Double.MIN_VALUE) = +1.0*2-1074 = |00000000|00000000|00000000|...|00000001|
          o   +0.25 = +0.5*2-1 = |00111111|11010000|00000000|...|00000000|
          o   +0.5 = +0.5*20 = |00111111|11100000|00000000|...|00000000|
          o   -0.5 = -0.5*20 = |10111111|11100000|00000000|...|00000000|
          o   +0.625 = +0.625*20 = |00111111|11100100|00000000|...|00000000|
                     megjegyzés: 0.625 = 0.5 + 0.125 = 1/2 + 1/8, tehát a mantissza kettedestört alakban m = 0.101
                      (amelybõl csak a kezdõ 0.1 utáni bináris számjegyeket ábrázoljuk)
          o   +1 = +0.5*21 = |00111111|11110000|00000000|...|00000000|
          o   -2 = -0.5*22 = |11000000|00000000|00000000|...|00000000|
          o   +1.7976931348623157*10308 (Double.MAX_VALUE) = +0.99...9*21024 =
              |01111111|11101111|11111111|...|11111111|
          o   +1.0/0.0 (Double.POSITIVE_INFINITY; formálisan +0.5*21025) =
              |01111111|11110000|00000000|...|00000000|
          o   -1.0/0.0 (Double.NEGATIVE_INFINITY; formálisan -0.5*21025) =
              |11111111|11110000|00000000|...|00000000|
          o   Not-a-Number (Double.NaN; formálisan +0.75*21025) = |01111111|11111000|00000000|...|00000000|



                                                                                          Boda István, 2003. november 2.
kódrendszerek

      az ASCII vagy US-ASCII kódtábla
           o fontosabb vezérlõ karakterek
           o módosító billentyûkkel bevihetõ vezérlõ karakterek
      az ASCII kódrendszer 8 bites kiterjesztései
      fontosabb kiterjesztett karakterkódok (Turbo Pascal)
      az Unicode kódrendszer



ASCII vagy US-ASCII kódtábla (American Standard Code for Information Interchange, ANSI X3.4-1986; az
ISO-7 (ISO 646-1973) hétbites nemzetközi kódszabvány amerikai (US) változata; az IBM PC-k megjelenésével
ennek nyolcbites kiterjesztése terjedt el, amelyre példa az MS-DOS 437-es kódtáblája)

      vezérlõ karakterek (#0..#31 és #127)
           o sorvége jel (szöveges fájlok esetén az Enter billentyû lenyomásával "írható be" az állományba és
              ugyanúgy törölhetõ, mint a többi, megjeleníthetõ karakter)
                   DOS: CR (Carriage Return: #13) + LF (Line Feed: #10)
                   UNIX: csak LF (Line Feed: #10)
           o módosító billentyûkkel bevihetõ vezérlõ karakterek
      megjeleníthetõ karakterek (#32..#126); néhány fontosabb karakter kódja, amit érdemes megjegyezni:
           o szóköz vagy space (#32)
           o " (quotation mark, dupla idézõjel; #34)
           o & (ampersand; #38)
           o ' (aposztróf; #39)
           o * (#42)
           o 0 (#48), ..., 9 (#57)
           o @ (At karakter, "kukac"; #64)
           o A (#65), ..., Z (#90)
           o \ (backslash, "visszaper"; #92)
           o a (#97), ..., z (#122)
      az ASCII kódtábla nyolcbites kiterjesztésében szereplõ karakterek (#128..#255); néhány fontosabb
       karakter kódja, amit érdemes megjegyezni (pl. a DOS 437-es kódtáblából):
           o é (#130), ä (#132), á (#160)
fontosabb vezérlõ karakterek

       NUL (null karakter) (#0)
       SOH (start of header, fejléc kezdete) (#1)
       STX (start of text, szöveg kezdete) (#2)
       ETX (end of text, szöveg vége) (#3)
       EOT (end of transmission, átvitel vége) (#4)
       ENQ (enquiry, érdeklõdés: kész-e a címzett adat küldésére vagy fogadására?) (#5)
       ACK (acknowledge, pozitív megerõsítés: a korábbi üzenetek rendben megérkeztek) (#6)
       BEL (bell, hangjelzés) (#7)
       BS (backspace, törlés a kurzor pozíciójától balra; Backspace billentyû kódja) (#8)
       HT (horizontal tabulation, vízszintes tabulátor; Tab billentyû kódja) (#9)
       LF (line feed, soremelés: kurzor átvitele a következõ sorba; Ctrl Enter billentyû kódja) (#10)
       VT (vertical tabulation, függõleges tabulátor) (#11)
       FF (form feed, lapdobás; nyomtatók esetén az aktuális lap nyomtatásának befejezése) (#12)
       CR (carriage return, kocsivissza: kurzor pozicionálása a sor elejére; ENTER billentyû kódja)
        (#13)
       SO (shift out, "nagybetûre" váltás kikapcsolása: az adatfolyamban következõ karakter(ek)
        értelmezésének visszaállítása normál módra) (#14)
       SI (shift in, "nagybetûre" váltás bekapcsolása: az adatfolyamban következõ karakter(ek) értelmezésének
        megváltoztatása) (#15)
       DLE (data link escape, a soron következõ karakter értelmezésének megváltoztatása; v.ö. ESC) (#16)
       ...
       NAK (negative acknowledge, negatív megerõsítés: a korábbi üzenetek nem érkeztek meg rendben, újra
        kell küldeni õket) (#21)
       SYN (sync caharacter, szinkronizáló karakter: az üzenetek elõtt küldött karakter(ek) a küldõ és fogadó
        eszközök órajelének szinkronizálása céljából) (#22)
       ETB (end of transmission block, az átviteli blokk vége) (#23)
       CAN (cancel, érvénytelenítés: a megelõzõ karakter(ek) figyelmen kívül hagyása) (#24)
       ...
       SUB (substitute, helyettesítés; DOS szöveges fájlok esetén ez a fájlvége, EOF (End Of File) karakter)
        (#26)
       ESC (escape, a soron következõ karakter értelmezésének megváltoztatása; ESC billentyû kódja)
        (#27)
       ...
       DEL (delete, törlés; a következõ karakter vagy adatblokk figyelmen kívül hagyása) (#127)



módosító billentyûkkel bevihetõ vezérlõ karakterek (egyes esetekben a vezérlõ karakterek is megjeleníthetõ karakterekként
viselkednek, pl. Ctrl Z (#26) hatására egy jobbra mutató nyíl jelenik meg)

       Ctrl A (#1), ..., Ctrl Z (#26)
             o Ctrl C karakterrel tudjuk a DOS vagy UNIX programok futását (általában) megszakítani
             o Ctrl D karakterrel tudjuk UNIX rendszerben befejezni a karakterek beírását a billentyûzetrõl egy szöveges
                 állományba
             o Ctrl Z karakterrel tudjuk DOS rendszerben befejezni a karakterek beírását a billentyûzetrõl egy szöveges
                 állományba
       Crrl [ vagy Ctrl õ (#27), Ctrl \ vagy Ctrl û (#28), Ctrl ] vagy Ctrl ú (#29), Ctrl 6 (#30), Ctrl - vagy Ctrl ü (#31)
       Ctrl BS (#127)
az ASCII kódrendszer 8 bites kiterjesztései (az eredetileg 7 bites, azaz 128 karakterkódot tartalmazó ASCII
kódrenszert az ISO 8859-es nemzetközi szabványsorozat további 128 karakterrel bõvíti ki)

       nyugat-európai kódrendszerek
           o ISO 8859-1: West Europe (Latin-1) /*Java kód: 8859_1*/
           o DOS 850 (PC Latin-1) /*Java kód: Cp850*/
           o Windows-1252: West Europe / Latin-1 /*Java kód: Cp1252*/
       közép vagy kelet-európai kódrendszerek
           o ISO 8859-2: Central / Eastern Europe (Latin-2) /*Java kód: 8859_2*/
                    megfelelõ kódtábla: Windows 28592
                    megjegyzés: a Windows magyar változata "természetesen" más kódrendszert használ
                      (Windows 1250); ezenkívül korábban más kódrendszereket is használtak (pl. a CWI
                      kódrendszert), nem beszélve a kényszer szülte megoldásokról, mint pl. a szellemes, de
                      kissé ijesztõ "repülõ" ékezetes karakterekrõl, amelyek leginkább az elektronikus
                      levelezésben terjedtek el (például a', o", u:, stb.)
           o DOS 852 (PC Latin-2) /*Java kód: Cp852*/
           o Windows-1250: Central Europe / Latin-2 /*Java kód: Cp1250*/
       egyéb (szabványos) kódrendszerek (itt már csak az ISO 8859-es szabványsorozatra szorítkozva; a Java
        nyelvben több, mint száz kódszabvány van felsorolva...)
           o ISO 8859-3: (Latin-3)
           o ISO 8859-4: (Latin-4)
           o ISO 8859-5: Cyrillic, cirill
           o ISO 8859-6: Arabic, arab
           o ISO 8859-7: Greek, görög
           o ISO 8859-8: Hebrew, héber
           o ISO 8859-9: Turkish, török (Latin-5)
           o ISO 8859-10: Samian (nincs szabványos nyelvkódja(!), de a különbözõ dialektusait több
               országban, így pl. Norvégiában sokan beszélik) (Latin-6)



fontosabb kiterjesztett karakterkódok (a Turbo Pascal-ban a #0 karakterkód beolvasása a Crt unit Readkey standard függvényével azt
jelzi, hogy egy második 1 bájtos karakterkód következik)

       Shift TAB (#15)
       funkcióbillentyûk
             o F1 (#59), ..., F10 (#68)
             o Shift F1 (#84), ..., Shift F10 (#93)
             o Ctrl F1 (#94), ..., Ctrl F10 (#103)
             o Alt F1 (#104), ..., Alt F10 (#113)
       kurzormozgató billentyûk
             o fel (#72), balra (#75), jobbra (#77), le (#80)
       kiemelt vezérlõbillentyûk
             o Home (#71), Ctrl Home (#119)
             o PageUp (#73), Ctrl PageUp (#132)
             o End (#79), Ctrl End (#117)
             o PageDown (#81), Ctrl PageDown (#118)
             o Insert (#82)
             o Delete (#83)
       a billentyûzet "normál" karaktereinek kiterjesztett kódjai
a billentyûzet "normál" karaktereinek kiterjesztett kódjai

        elsõ (felsõ) billentyûsor
              o Alt 1 (#120), ..., Alt 9 (#128), Alt 0 vagy Alt ö (#129), Alt - vagy Alt ü (#130), Alt = vagy Alt ó (#131)
        második billentyûsor
              o Alt Q (#16), ..., Alt P (#25)
        harmadik billentyûsor
              o Alt A (#30), ..., Alt L (#38)
        negyedik (alsó) billentyûsor
              o Alt Z vagy Alt Y (#44), Alt X (#45), ..., Alt M (#50)




az Unicode kódrendszer (az Unicode egy "univerzális" 16 bites kódrendszer, amely felülrõl kompatibilis a 7
bites ASCII kódrendszerrel; a világ összes nyelvének karakterkészletét tartalmazza, de egyes "holt" nyelvek
ábécéje is megtalálható benne, pl. a szanszkrit nyelvé)

        \u0020..\007e (a hexadecimálisan megadott 0020 és 007e közötti kódokhoz rendelt Unicode karakterek
         megegyeznek az ASCII kódtábla 32..126 kódú elemeivel)
        magyar ékezetes kisbetûk és gyakori helyettesítõik
             o \u00e1 (a'), \u00e9 (e'), \u00ed (i')
             o \u00f3 (o'), \u00f6 (o:), \u00fa (u'), \u00fc (u:)
             o a különbözõ kódrendszerekben általában "problémás" karakterek
                     \u00f4 (o>; o with circumflex, "kupakos" o)
                     \u00f5 (o?; o with tilde, "hullámos" o; HTML-ben - jobb híján - ezt használjuk &otilde;
                        entitáskóddal megadva)
                     \u0151 (o"; o with double acute, magyar ékezetes "hosszú õ" betû, pl. fõzés)
                     \u00fb (u>; u with circumflex, "kupakos" u; HTML-ben - jobb híján - ezt használjuk
                        &ucirc; entitáskóddal megadva)
                     \u0169 (u?; u with tilde, "hullámos" u)
                     \u0171 (u"; u with double acute, magyar ékezetes "hosszú û" betû, pl. zûrös)
        magyar ékezetes nagybetûk és gyakori helyettesítõik
             o \u00c1 (A'), \u00c9 (E'), \u00cd (I')
             o \u00d3 (O'), \u00d6 (O:), \u00da (U'), \u00dc (U:)
             o a különbözõ kódrendszerekben általában "problémás" karakterek
                     \u00d4 (O>; O with circumflex, "kupakos" O)
                     \u00d5 (O?; O with tilde, "hullámos" O; HTML-ben - jobb híján - ezt használjuk
                        &Otilde; entitáskóddal megadva)
                     \u0150 (O"; O with double acute, magyar ékezetes "hosszú Õ" betû)
                     \u00db (U>; U with circumflex, "kupakos" U; HTML-ben - jobb híján - ezt használjuk
                        &Ucirc; entitáskóddal megadva)
                     \u0168 (U?; U with tilde, "hullámos" U)
                     \u0170 (U"; O with double acute, magyar ékezetes "hosszú Û" betû)
        \u0368..\03f5 (görög betûk)
        \u0401..\0491 (cirill betûk)
        \u05d0..\05ea (héber betûk)
        \u060c..\06f9 (arab betûk)
        ...


                                                                                                          Boda István, 2003. május 13.
konstansok

      értékkonstansok
      szimbolikus (nevesített) konstansok (a hozzájuk rendelt érték nem változtatható meg)
           o példa: késedelmi díj kiszámítása (Turbo Pascal)
           o példa: késedelmi díj kiszámítása (Java)
                    elsõ példa
                    második példa
      logikailag konstansként használt változók (a hozzájuk rendelt érték a programban az alapértékek
       beállításakor megváltoztatható, pl. parancssori paraméterek megadásával és rossz érték megadása esetén
       a hiba kezelésével)
           o tipizált vagy típusos konstansok (Turbo Pascal; tulajdonképpen kezdõértékkel rendelkezõ
               változók)
                    példa: késedelmi díj kiszámítása az alapdíj megadásával
           o osztályszintû (statikus) változók (Java)
                    példa: késedelmi díj kiszámítása az alapdíj megadásával
                           harmadik példa
                           negyedik példa
                    példa: késedelmi díj kiszámítása az alapdíj és lejárat megadásával
                           ötödik példa
                           hatodik példa
      gyakorló feladatok



értékkonstansok (un. literálok)

      sorszámozott típusok esetén
           o egész típusok esetén
                   decimális számok: pl. 1, -3
                           long típusú egész számok: pl. 255L vagy 255l (Java)
                   oktális számok: pl. 0377 (Java)
                   hexadecimális számok: pl. $FF (Turbo Pascal), 0xff (Java)
           o karakteres típus esetén:
                   karakterek közvetlen megadása (Turbo Pascal, Java): pl. 'A' (megjegyzés: Turbo
                      Pascalban egy egykarakteres stringet ugyanúgy adunk meg, mint egy karaktert; tehát pl.
                      'A' stringnek és karakternek is tekinthetõ)
                   karakterek megadása kódok segítségével
                           ASCII karakter (Turbo Pascal): #ddd ahol ddd egy (max.) háromjegyû decimális
                               szám, a megfelelõ karakter ASCII kódja (pl. #65 = 'A')
                           Unicode karakter (Java): \uhhhh ahol hhhh egy (pontosan) négyjegyû
                               hexadecimális szám, a megfelelõ karakter UNICODE kódja (pl. \u0041 == 'A')
                   speciális karakterek megadása szimbolikus konstansokkal (Java)
           o logikai típus esetén: True, False (Pascal); true, false (Java)
      valós típusok esetén: pl. 0.12, 3.0, -2.5, 1e4, -13.4e-5
           o float típusú valós számok: pl. 12.3e4F vagy 12.3e4f (Java)
           o double típusú valós számok: pl. 12.3e4D vagy 12.3e4d (Java)
      karakterlánc (String) típus esetén: pl. 'Hello!' (Pascal); "Hello!" (Java)
      objektumtípus (vagy referenciatípus) esetén: null (Java)
speciális karakterek megadása szimbolikus konstansokkal: a \ (backslash) karakter után (Java)

         karakter törlése (backspace): \b (Turbo Pascal: #8)
         tabulátor (tabulation): \t (Turbo Pascal: #9)
         lapdobás (form feed): \f (Turbo Pascal: #12)
         új sor, sorvége (new line, eoln): \n (Turbo Pascal: #13#10, esetleg #10)
               o példa: System.out.println("Hello\nKata!");
         sorvissza, kocsivissza (return, carriage return): \r (Turbo Pascal: #13)
         dupla idézõjel (quotation mark): \" (Turbo Pascal: #34)
               o példa: System.out.println("Az idézõjel (\") egy fontos karakter a Java nyelvben");
         szimpla idézõjel, aposztróf (apostrophe): \' (Turbo Pascal: #39)
         "visszaper" karakter (backslash): \\ (Turbo Pascal: #92)




példa: késedelmi díj kiszámítása (Turbo Pascal)
program Dij1;
uses crt;
const dij=100; {naponta ennyi késedelmi díjat kell fizetni; a dij szimbolikus konstans értéke nem
változtatható meg}
          lejarat=10; {ennyi napig lehet egy könyvet kölcsönözni késedelmi díj fizetése nélkül}
var n:integer;
        f:real;
procedure beolvas;
   begin
   clrscr;
   write('Napok szama: ');
   readln(n);
   end;
procedure kiszamit;
   begin
   if n<= lejarat then f:=0 else f:=(n-lejarat)*dij;
   end;
BEGIN
beolvas;
kiszamit;
writeln('Eltelt napok szama: ',n);
writeln('Kolcsonzesi ido lejarata: ',lejarat,' nap');
writeln('Kesedelmi dij: ',dij,' Ft/nap');
writeln('Fizetendo: ',f:3:2,' Ft');
END.
1. példa: késedelmi díj kiszámítása (Java)
public class Pelda1 {
public static final int DIJ=100;         /*naponta ennyi késedelmi díjat kell fizetni; a DIJ konstansra a definiáló (Pelda1) osztályból bárhonnan
közvetlenül is hivatkozhatunk, más osztályokból pedig az osztálynév megadásával a DIJ konstans elõtt (lásd a Pelda2 osztályt)*/
public static final int LEJARAT=10;            /*ennyi napig lehet egy könyvet kölcsönözni késedelmi díj fizetése nélkül*/

public int n;
public double f;
public void beolvas() {
    n=20;
    }
public void kiszamit() {
    if (n<=LEJARAT)
        { f=0; }
    else
        { f=(n-LEJARAT)*DIJ; }
    }
public static void main(String[] args) {
    Pelda1 p=new Pelda1();
    p.beolvas();
    p.kiszamit();
    System.out.println("Eltelt napok szama: "+p.n);
    System.out.println("Kolcsonzesi ido lejarata: "+LEJARAT+" nap");
    System.out.println("Kesedelmi dij: "+DIJ+" Ft/nap");
    System.out.println("Fizetendo: "+p.f+" Ft");
    }
}


2. példa: késedelmi díj kiszámítása (Java)
public class Pelda2 {
public static void main(String[] args) {
    Pelda1 p=new Pelda1();          /*A Pelda1 osztálynak elérhetõnek kell lennie, pl. a Pelda1.class fájlnak ugyanabban az alkönyvtárban kell lennie,
mint a Pelda2.java forrásállománynak*/
    p.beolvas();
    p.kiszamit();
    System.out.println("Eltelt napok szama: "+p.n);
    System.out.println("Kolcsonzesi ido lejarata: "+Pelda1.LEJARAT+" nap");
    System.out.println("Kesedelmi dij: "+Pelda1.DIJ+" Ft/nap");
    System.out.println("Fizetendo: "+p.f+" Ft");
    }
}


Figyeljük meg:
a Pelda1 osztály nem statikus mezõit vagy elemváltozóit a Pelda2 osztály main statikus metódusában a Pelda1 osztály p példányán
keresztül érhetjük el, például p.n vagy p.f módon; a Pelda1 osztályban deklarált osztályszintû, statikus változókra pedig az osztály
nevén keresztül hivatkozhatunk, például Pelda1.LEJARAT vagy Pelda1.DIJ módon
példa: késedelmi díj kiszámítása az alapdíj megadásával (Turbo Pascal)
program Dij2;
uses crt;
const dij:integer=100; {naponta ennyi késedelmi díjat kell fizetni; a dij típusos konstans értéke
megváltoztatható}
       lejarat=10; {ennyi napig lehet egy könyvet kölcsönözni késedelmi díj fizetése nélkül}
var n:integer;
     x,errcode:integer;
     f:real;
procedure beolvas;
  begin
  clrscr;
  write('Napok szama: ');
  readln(n);
  end;
procedure kiszamit;
  begin
  if n<= lejarat then f:=0 else f:=(n-lejarat)*dij;
  end;
BEGIN
if paramcount>0 then begin {ha nullánál több parancssori paraméter volt megadva, feldolgozzuk a megadott
paramétereket; a parancssori paramétereket megadhatjuk a TP integrált fejlesztõi környezetében (ld.
bevezetés), vagy a diszkre lefordított program futtatásakor MS-DOS parancssori ablakban pl. dij2.exe 1000
módon}
  val(paramstr(1),x,errcode); {megpróbáljuk az elsõ parancssori paramétert (integer típusú) számmá
konvertálni; ha ez lehetséges, az átalakított érték az x változóba kerül és az errcode változó értéke 0 lesz;
hiba esetén az x változó értéke 0, az errcode változó értéke pedig nullától különbözõ lesz}
  if errcode=0 then dij:=x
  else writeln(#7'Hibas parameter!'#7); {ha a megadott parancssori paraméter átkonvertálása hiba nélkül
megtörtént, a késedelmi díj alapértékét megváltoztatjuk; egyébként a késedelmi díj alapértékét változatlanul
hagyjuk, és hangjelzések között hibaüzenetet írunk ki}
  end;
beolvas;
kiszamit;
writeln('Eltelt napok szama: ',n);
writeln('Kolcsonzesi ido lejarata: ',lejarat,' nap');
writeln('Kesedelmi dij: ',dij,' Ft/nap');
writeln('Fizetendo: ',f:3:2,' Ft');
END.
3. példa: késedelmi díj kiszámítása az alapdíj megadásával (Java)
public class Pelda3 {
public static int DIJ=100;         /*naponta ennyi késedelmi díjat kell fizetni; a DIJ statikus változó értéke most megváltoztatható*/

public static final int LEJARAT=10;             /*ennyi napig lehet egy könyvet kölcsönözni késedelmi díj fizetése nélkül; a LEJARAT konstans értéke
nem változtatható meg*/
public int n;
public double f;
public void beolvas() {
    n=20;
    }
public void kiszamit() {
    if (n<=LEJARAT)
        { f=0; }
    else
        { f=(n-LEJARAT)*DIJ; }
    }
public static void main(String[] args) {            /*a main metódus formális paramétereként egy args nevû, String típusú értékeket tároló tömböt
deklarálunk*/
    Pelda3 p=new Pelda3();
    if (args.length>0) {       /*ha nullánál több parancssori paraméter volt megadva, feldolgozzuk a megadott paraméter(eke)t; az args (String típusú
értékeket tároló) tömb azokat a parancssori paramétereket tartalmazza, amelyeket a program indításakor a programnév után (szóközökkel elválasztva)
beírtunk; a tömb hosszát, vagyis a tömbben tárolt értékek számát args.length adja meg*/
        try {   /*azokat az utasításokat, amelyekben a végrehajtás során valamilyen hiba ("kivétel", angolul exception) léphet fel, a try utáni
utasításblokkban helyezzük el*/
            DIJ=Integer.parseInt(args[0]);          /*megpróbáljuk az elsõ parancssori paramétert, args[0]-t integer típusú számmá konvertálni az Integer
standard osztály int parseInt(String) statikus függvényével; ha az átalakítás lehetséges (ti. számot adtunk meg az elsõ parancssori paraméterben), az
átalakított érték a DIJ statikus változóba kerül; ha az átalakítás nem lehetséges, az utasítás végrehajtása során egy hiba (kivétel) lép fel, és az utasítás
végrehajtása helyett a catch utasításblokkban elhelyezett kivételkezelõ utasítások fognak végrehajtódni (ilyenkor a DIJ változó alapértelmezett értéke
változatlan marad)*/
            }
        catch (NumberFormatException e) {                /*ha a megelõzõ try blokkban levõ utasítás(ok)ban NumberFormatException típusú hiba lépett fel,
azaz a megadott parancssori paraméter átkonvertálása egész számmá nem lehetséges, egy hibaüzenetet írunk ki ("Hibás paraméter!"), és a
hibaüzenet mellett az e formális paraméter kiiratásával a hiba típusát és a hibás paraméter értékét is megjelenítjük*/
            System.out.println("Hibas parameter! "+e);
            }
        }
    p.beolvas();
    p.kiszamit();
    System.out.println("Eltelt napok szama: "+p.n);
    System.out.println("Kolcsonzesi ido lejarata: "+LEJARAT+" nap");
    System.out.println("Kesedelmi dij: "+DIJ+" Ft/nap");
    System.out.println("Fizetendo: "+p.f+" Ft");
    }
}
4. példa: késedelmi díj kiszámítása az alapdíj megadásával (Java)
public class Pelda4 {
public static void main(String[] args) {
    Pelda3 p=new Pelda3();
    if (args.length>0) {
        try {
            Pelda3.DIJ=Integer.parseInt(args[0]);
            }
        catch (NumberFormatException e) {
            System.out.println("Hibas parameter! "+e);
            }
        }
    p.beolvas();
    p.kiszamit();
    System.out.println("Eltelt napok szama: "+p.n);
    System.out.println("Kolcsonzesi ido lejarata: "+Pelda3.LEJARAT+" nap");
    System.out.println("Kesedelmi dij: "+Pelda3.DIJ+" Ft/nap");
    System.out.println("Fizetendo: "+p.f+" Ft");
    }
}


5. példa: késedelmi díj kiszámítása az alapdíj és lejárat megadásával (Java)
public class Pelda5 {
public static int DIJ=100;     /*naponta ennyi késedelmi díjat kell fizetni; a DIJ statikus változó értéke most
megváltoztatható*/
public static int LEJARAT=10;        /*ennyi napig lehet egy könyvet kölcsönözni késedelmi díj fizetése nélkül; a
LEJARAT statikus változó értéke most szintén megváltoztatható*/
public static void alapKiir() {    /*a késedelmi díj kiszámításához szükséges alapértékek kiiratása; figyeljük meg,
hogy az alapKiir() statikus metódusban csak a DIJ és LEJARAT statikus változókra hivatkozunk*/
    System.out.println("***** Alapertekek: *****");
    System.out.println("Kesedelmi dij: "+DIJ+" Ft/nap");            /*az alapKiir() osztályszintû (statikus) metódusban
közvetlenül hivatkozhatunk a DIJ és LEJÁRAT statikus változókra*/
    System.out.println("Kolcsonzesi ido lejarata: "+LEJARAT+" nap");
    }
public int n;
public double f;
public void beolvas() {
    n=20;
    }
public void kiszamit() {
    if (n<=LEJARAT)
        { f=0; }
    else
        { f=(n-LEJARAT)*DIJ; }
    }
public void kiir() {
    System.out.println("***** Kiszamitott ertekek: *****");
    System.out.println("Eltelt napok szama: "+n);
    System.out.println("Fizetendo: "+f+" Ft");
    }
public static void main(String[] args) {
    Pelda5 p=new Pelda5();
    if (args.length>0) {
        try {
            DIJ=Integer.parseInt(args[0]);        /*az elsõ paraméter a késedelmi díj értéke*/

            }
        catch (NumberFormatException e) {
            System.out.println("Hibas DIJ parameter! "+e);
            }
        }
    if (args.length>1) {      /*azt vizsgáljuk meg, hogy van-e második parancssori paraméter*/

        try {
            LEJARAT=Integer.parseInt(args[1]);            /*a második paraméter a lejárat értéke*/

            }
        catch (NumberFormatException e) {
            System.out.println("Hibas LEJARAT parameter! "+e);
            }
        }
    p.beolvas();
    p.kiszamit();
    alapKiir();     /*az alapKiir() osztályszintû (statikus) metódus közvetlenül meghívható*/

    p.kiir();
    }
}
6. példa: késedelmi díj kiszámítása az alapdíj és lejárat megadásával (Java)
public class Pelda6 {
public static void main(String[] args) {
    Pelda5 p=new Pelda5();
    if (args.length>0) {
        try {
            Pelda5.DIJ=Integer.parseInt(args[0]);
            }
        catch (NumberFormatException e) {
            System.out.println("Hibas DIJ parameter! "+e);
            }
        }
    if (args.length>1) {
        try {
            Pelda5.LEJARAT=Integer.parseInt(args[1]);
            }
        catch (NumberFormatException e) {
            System.out.println("Hibas LEJARAT parameter! "+e);
            }
        }
    p.beolvas();
    p.kiszamit();
    Pelda5.alapKiir();      /*a Pelda6 osztályból csak az osztálynéven keresztül hívhatjuk meg a Pelsa5 osztályban
deklarált alapKiir() statikus metódust*/
    p.kiir();
    }
}


Figyeljük meg:
a Pelda5 osztály nem statikus metódusait a Pelda6 osztály main statikus metódusában a Pelda5 osztály p
példányán keresztül érhetjük el, például p.beolvas(), p.kiszamit() vagy p.kiir() módon; a Pelda5 osztályban
deklarált osztályszintû, statikus metódusokra pedig az osztály nevén keresztül hivatkozhatunk, például
Pelda5.alapKiir() módon

                                                                                             Boda István, 2003. októbet 29.
Konstansok, parancssori paraméterek, kivételkezelés

public class Dij1 { //részletesebben lásd Konstansok
public static final int DIJ=100;
public static final int LEJARAT=10;
public int n;
public double f;
public void beolvas() {
    n=20;
    }
public void kiszamit() {
    if (n<=LEJARAT) //kétirányú elágazás
        { f=0; }
    else
        { f=(n-LEJARAT)*DIJ; }
    }
public static void main(String[] args) {
    Dij1 d=new Dij1();
    d.beolvas();
    d.kiszamit();
    System.out.println("Eltelt napok szama: "+d.n);
    System.out.println("Kolcsonzesi ido lejarata: "+LEJARAT+" nap");
    System.out.println("Kesedelmi dij: "+DIJ+" Ft/nap");
    System.out.println("Fizetendo: "+d.f+" Ft");
    }
}


public class Dij11 extends Dij1 {
public void beolvas() {
    n=40; //átdefiniáljuk az eltelt napok számát
    }
public void kiszamit() {
    f=0;
    if (n>LEJARAT) { //egyirányú elágazás
    f=(n-LEJARAT)*DIJ;
    }
    }
public static void main(String[] args) {
    Dij11 d=new Dij11();
    d.beolvas();
    d.kiszamit();
    System.out.println("Eltelt napok szama: "+d.n);
    System.out.println("Kolcsonzesi ido lejarata: "+LEJARAT+" nap");
    System.out.println("Kesedelmi dij: "+DIJ+" Ft/nap");
    System.out.println("Fizetendo: "+d.f+" Ft");
    }
}
public class Dij2 { //részletesebben lásd Konstansok
public static void main(String[] args) {
    Dij1 d=new Dij1();
    d.beolvas();
    d.kiszamit();
    System.out.println("Eltelt napok szama: "+d.n);
    System.out.println("Kolcsonzesi ido lejarata: "+Dij1.LEJARAT+" nap");
    System.out.println("Kesedelmi dij: "+Dij1.DIJ+" Ft/nap");
    System.out.println("Fizetendo: "+d.f+" Ft");
    }
}



public class Dij3 { //részletesebben lásd Konstansok
public static int DIJ=100;
public static final int LEJARAT=10;
public int n;
public double f;
public void beolvas() {
    n=20;
    }
public void kiszamit() {
    if (n<=LEJARAT)
        { f=0; }
    else
        { f=(n-LEJARAT)*DIJ; }
    }
public static void main(String[] args) {
    Dij3 d=new Dij3();
    if (args.length>0) {
        try {
            DIJ=Integer.parseInt(args[0]);
            }
        catch (NumberFormatException e) {
            System.out.println("Hibas parameter! "+e);
            }
        }
    d.beolvas();
    d.kiszamit();
    System.out.println("Eltelt napok szama: "+d.n);
    System.out.println("Kolcsonzesi ido lejarata: "+LEJARAT+" nap");
    System.out.println("Kesedelmi dij: "+DIJ+" Ft/nap");
    System.out.println("Fizetendo: "+d.f+" Ft");
    }
}
public class OtParam {
public static void main(String[] args) {
 java.util.List alist=java.util.Arrays.asList(args);
 /* az args tömböt listává alakítjuk, amelynek az elemei egyszerre
        is kiirathatóak az alist objektumpéldányon keresztül */
 System.out.println("A parameterek szama: "+args.length);
 System.out.println("Az osszes parameter egyben: "+alist);
 System.out.println("A elso parameter: "+args[0]);
 System.out.println("A masodik parameter: "+args[1]);
 System.out.println("A harmadik parameter: "+args[2]);
 System.out.println("A negyedik parameter: "+args[3]);
 System.out.println("Az otodik parameter: "+args[4]);
 }
/* a program futásának az eredménye itt látható */
}



public class OtParam1 {
public static final int MAXPAR=5; //ennyi parametert hasznalunk
public static void main(String[] args) {
 java.util.List alist=java.util.Arrays.asList(args);
 int i;
 System.out.println("A parameterek szama: "+args.length);
 System.out.println("Az osszes parameter egyben: "+alist);
 i=MAXPAR;
 try {
    System.out.println("A elso parameter: "+args[0]);
    i--;
    System.out.println("A masodik parameter: "+args[1]);
    i--;
    System.out.println("A harmadik parameter: "+args[2]);
    i--;
    System.out.println("A negyedik parameter: "+args[3]);
    i--;
    System.out.println("Az otodik parameter: "+args[4]);
    i--;
    }
 catch(ArrayIndexOutOfBoundsException e) {
    System.out.println("Keves parameter (meg "+i+" kellene)! "+e);
    }
 }
}
public class OtParam2 {
public static void main(String[] args) {
 java.util.List alist=java.util.Arrays.asList(args);
 int i=0;
 System.out.println("A parameterek szama: "+args.length);
 System.out.println("Az osszes parameter egyben: "+alist);
 try {
    System.out.println("Az elso szam: "+Integer.parseInt(args[i]));
    i++;
    System.out.println("A masodik szam: "+Integer.parseInt(args[i]));
    i++;
    System.out.println("A harmadik szam: "+Integer.parseInt(args[i]));
    i++;
    System.out.println("A negyedik szam: "+Integer.parseInt(args[i]));
    i++;
    System.out.println("Az otodik szam: "+Integer.parseInt(args[i]));
    i++;
    }
 catch(Exception e) { //több hibalehetõség is van!
    System.out.println("Hibas "+(i+1)+". parameter! "+e);
    }
 }
}


public class OtParam3 {
public static void main(String[] args) {
 java.util.List alist=java.util.Arrays.asList(args);
 int i=0;
 System.out.println("A parameterek szama: "+args.length);
 System.out.println("Az osszes parameter egyben: "+alist);
 try {
    System.out.println("Az elso szam: "+Integer.parseInt(args[i++]));
    /* az elõzõ utasítás ekvivalens a következõ három utasítással:
        int x=i;
        i=i+1; //vagy i++;
        System.out.println("Az elso szam: "+Integer.parseInt(args[x]));
        fontos: a harmadik utasításban i "korábbi" (növelés elõtti) értéke
        szerepel, de i növelése még a harmadik utasítás végrehajtása elõtt
        megtörténik, ezért a hibaüzenet kiírásakor nem (i+1), hanem i adja
        majd a hibás paraméter sorszámát! */
    System.out.println("A masodik szam: "+Integer.parseInt(args[i++]));
    System.out.println("A harmadik szam: "+Integer.parseInt(args[i++]));
    System.out.println("A negyedik szam: "+Integer.parseInt(args[i++]));
    System.out.println("Az otodik szam: "+Integer.parseInt(args[i++]));
    }
 catch(Exception e) {
    System.out.println("Hibas "+i+". parameter! "+e);
    }
 }
}
public class OtParam4 {
public static final int MAXPAR=5; //ennyi parametert hasznalunk
public static void main(String[] args) {
    java.util.List alist=java.util.Arrays.asList(args);
    int i=0;
    /* i-nek kötelezõ kezdõértéket adni a try blokk elõtt, mivel
        más helyen is elõfordul a programban! */
    System.out.println("A parameterek szama: "+args.length);
    System.out.println("Az osszes parameter egyben: "+alist);
    try {
    for(i=0;i<MAXPAR;i++) {
        System.out.println("Az "+(i+1)+". szam: "+Integer.parseInt(args[i]));
        /* ha a kiíró utasítás sikeresen végrehajtódott, a for ciklus itt
            automatikusan megnöveli i értékét, ha viszont hiba történt,
            idáig már nem jut el a program, mert a catch blokkban levõ
            hibaüzenet-kiíró utasítás fog végrehajtódni! */
        }
    }
    catch(Exception e) {
    System.out.println("Hibas "+(i+1)+". parameter! "+e);
    /* itt viszont ismét (i+1)-nek kell szerepelni, mivel a for ciklus
            csak a ciklusmag végrehajtása után növeli az i értékét! */
    }
    }
}



public class Dij4 { //részletesebben lásd Konstansok
public static void main(String[] args) {
        Dij3 d=new Dij3();
        if (args.length>0) {
             try {
                 Dij3.DIJ=Integer.parseInt(args[0]);
                 }
             catch (NumberFormatException e) {
                 System.out.println("Hibas parameter! "+e);
                 }
             }
        d.beolvas();
        d.kiszamit();
        System.out.println("Eltelt napok szama: "+d.n);
        System.out.println("Kolcsonzesi ido lejarata: "+Dij3.LEJARAT+" nap");
        System.out.println("Kesedelmi dij: "+Dij3.DIJ+" Ft/nap");
        System.out.println("Fizetendo: "+d.f+" Ft");
        }
}
public class Dij5 { //részletesebben lásd Konstansok
public static int DIJ=100;
public static int LEJARAT=10;
public static void alapKiir() {
    System.out.println("***** Alapertekek: *****");
    System.out.println("Kesedelmi dij: "+DIJ+" Ft/nap");
    System.out.println("Kolcsonzesi ido lejarata: "+LEJARAT+" nap");
    }
public int n;
public double f;
public void beolvas() {
    n=20;
    }
public void kiszamit() {
    if (n<=LEJARAT)
        { f=0; }
    else
        { f=(n-LEJARAT)*DIJ; }
    }
public void kiir() {
    System.out.println("***** Kiszamitott ertekek: *****");
    System.out.println("Eltelt napok szama: "+n);
    System.out.println("Fizetendo: "+f+" Ft");
    }
public static void main(String[] args) {
    Dij5 d=new Dij5();
    if (args.length>0) {
        try {
            DIJ=Integer.parseInt(args[0]);
            }
        catch (NumberFormatException e) {
            System.out.println("Hibas DIJ parameter! "+e);
            }
        }
    if (args.length>1) {
        try {
            LEJARAT=Integer.parseInt(args[1]);
            }
        catch (NumberFormatException e) {
            System.out.println("Hibas LEJARAT parameter! "+e);
            }
        }
    d.beolvas();
    d.kiszamit();
    alapKiir();
    d.kiir();
    }
}
public class Dij6 { //részletesebben lásd Konstansok
public static void main(String[] args) {
    Dij5 d=new Dij5();
    if (args.length>0) {
        try {
            Dij5.DIJ=Integer.parseInt(args[0]);
            }
        catch (NumberFormatException e) {
            System.out.println("Hibas DIJ parameter! "+e);
            }
        }
    if (args.length>1) {
        try {
            Dij5.LEJARAT=Integer.parseInt(args[1]);
            }
        catch (NumberFormatException e) {
            System.out.println("Hibas LEJARAT parameter! "+e);
            }
        }
    d.beolvas();
    d.kiszamit();
    Dij5.alapKiir();
    d.kiir();
    }
}

                                                                 Boda István, 2003. novembet 13.
változók, összetett adattípusok

A megvalósítandó algoritmus lépéseit egy programban utasításokkal írjuk le (részletesen ld. bevezetés, szemantika). Az utasítások
végrehajtása során

          a bemeneti adatok és részeredmények tárolása változókban történik,
          a részeredményeket úgy kapjuk, hogy a változókon meghatározott mûveleteket hajtunk végre, és ezek eredményét a
           változókban értékadással eltároljuk.



változók

          változók fogalma
                o magasszinten (a változók szimbólumok, amelyekhez értékeket rendelünk; egy változóhoz rendelt érték a program
                     végrehajtása során tetszõleges sokszor megváltoztatható)
                o alacsonyszinten (a változók névvel ellátott memóriahelyek, amelyek adatok tárolására szolgálnak; a
                     memóriahelyekben tárolt tartalom értékadással tetszõleges sokszor megváltoztatható)
          változók jellemzõi
                o név
                o (memória)cím
                o típus (értéktartomány, helyfoglalás, kódolás)
                o érték
          (lokális) változók deklarálása
                o név megadása
                o típus megadása



típus megadása változók deklarációjakor

          egyszerû vagy elemi típusok
               o egész típusok
                          pl. var i:integer; (TP) int i; (J)
               o karakter típus
                          pl. var ch:char; (TP) char ch; (J)
               o logikai típus
                          pl. var errcode:Boolean; (TP) boolean errcode; (J)
               o valós típusok
                          pl. var x:real; (TP) double x; (J)
               o karakterlánc típus (megjegyzés: Java esetén a String nem egyszerû típus, hanem osztálytípus!)
                          pl. var s:string; t:string[20]; (TP) String s=new String(); (J)
          összetett vagy referenciatípusok
               o tömb típus
                          példák (Turbo Pascal): var szamok:array [1..10] ofinteger; vagy var nevek:array['A'..'Z'] of string;
                                   1. példa: lottószámok megadása értékadással (Turbo Pascal)
                                   2. példa: nevek megadása (Turbo Pascal)
                          példák (Java): int[] szamok=new int[20]; vagy int[] szamok={1,2,3,4};
                                   3. példa: lottószámok megadása közvetlenül (Java)
                                            3.1 példa: lottószámok megadása értékadással
               o rekordtípus
                          pl. var cedulka:record raktjel:word; szerzo,cim:string; end; (TP)
                                   4. példa: egy katalóguscédula adatainak megadása (Turbo Pascal)
               o objektumtípus vagy osztály
                          pl. Pelda6 p=new Pelda6(); (J)
                                   5. példa: egy katalóguscédula adatainak megadása (Java)
               o fájltípus
          többszörösen összetett típusok
               o rekordtípusú tömbök
                          pl. var katalogus:array [1..100] of bibl; (TP)
               o tömbtípusú mezõk
                          pl. var cedula:record raktjel:word; szerzo:array [1..3] of string[40]; cim,impr:string; end; (TP)
1. példa: lottószámok megadása értékadással (Turbo Pascal)
program Pelda1;
uses crt;
const crlf=#13#10; {soremelés}
var lotto:array [1..5] of byte;
procedure beallit;
   begin
   lotto[1]:=8;
   lotto[2]:=23;
   lotto[3]:=29;
   lotto[4]:=55;
   lotto[5]:=81;
   end;
BEGIN
clrscr;
beallit;
writeln('A javasolt lottoszamok:');
writeln(lotto[1],crlf,lotto[2],crlf,lotto[3],crlf,lotto[4],crlf,lotto[5]);
END.

2. példa: nevek megadása (Turbo Pascal)
program Pelda2;
uses crt;
var nevek:array ['A'..'Z'] of string[40];
    ch:char;
procedure beallit;
   begin
   nevek['A']:='Alex'; {egy tömb elemeire a Turbo Pascal nyelvben bármilyen, sorszámozott típusú értékkel hivatkozhatunk
a deklarációban megadott résztartományon (itt: 'A'..'Z') belül}
   nevek['B']:='Balazs';
   nevek['L']:='Lilu';
   nevek['P']:='Philip';
   nevek['Z']:='Zsu';
   end;
BEGIN
clrscr;
beallit;
write('A nev kezdobetuje: ');
readln(ch);
if ('A'<=ch) and (ch<='Z') then
   writeln('A megadott kezdobetuvel kezdodo nev: ',nevek[ch])
else
   writeln('A nevek nagybetuvel kezdodnek!');
END.
3. példa: lottószámok megadása közvetlenül (Java)
public class Pelda3 {
public static void main(String[] args) {
    int[] lotto={8,23,29,55,81}; /*a Java nyelvben így tudunk kezdõértékeket adni egy tömbnek*/
    System.out.println("A javasolt lottoszamok:");
    System.out.println(lotto[0]); /*a Java nyelvben a tömbindexek mindig 0-val kezdõdnek*/
    System.out.println(lotto[1]);
    System.out.println(lotto[2]);
    System.out.println(lotto[3]);
    System.out.println(lotto[4]);
    }
}


3.1 példa: lottószámok megadása értékadással
public class Pelda31 {
    public static final String LF="\n"; /*soremelés: String típusú nevesített konstans*/
    public int[] lotto=new int[5];
    public void beallit() {
    lotto[0]=8;     /*most a beallit() metódus meghívásával fogunk kezdõértékeket adni a tömb elemeinek; a tömbindexek
0-val kezdõdnek*/
    lotto[1]=23;
    lotto[2]=29;
    lotto[3]=55;
    lotto[4]=81;
    }
    public void kiir() {
    System.out.println("A javasolt lottoszamok:");
    System.out.println(lotto[0]+LF+lotto[1]+LF+lotto[2]+LF+lotto[3]+LF+lotto[4]);
    }
public static void main(String[] args) {
    Pelda31 p=new Pelda31();
    p.beallit();
    p.kiir();
    }
}
4. példa: egy katalóguscédula adatainak megadása (Turbo Pascal)
program Pelda4;
uses crt;
type bibl=record
   raktjel:longint;
   szerzo:array [1..3] of string[40]; {többszörösen összetett típus: tömbtípusú rekordmezõ}
   cim:string;
   impr:string;
   end;
var cedula:bibl;
procedure beallit;
   begin
   cedula.raktjel:=1234;
   cedula.szerzo[1]:='Kortvelyesi Gezane';
   cedula.szerzo[2]:='';
   cedula.szerzo[3]:='';
   cedula.cim:='Turbo Pascal 4.0';
   cedula.impr:='Muszaki Konyvkiado, Budapest, 1990.';
   end;
BEGIN
clrscr;
beallit;
with cedula do begin {ha a with ... do begin ... end szerkezetben a with után megadjuk egy
rekordtípusú változó nevét, a begin ... end blokkban közvetlenül hivatkozhatunk a megadott
rekordtípusú változó mezõire}
   writeln(raktjel);
   write(cim,'. / ',szerzo[1]);
   if length(szerzo[2])>0 then write(' - ',szerzo[2]); {egy string típusú változó vagy rekordmezõ hosszát
a length() függvény adja meg}
   if length(szerzo[3])>0 then write(' - ',szerzo[3]);
   writeln('.');
   writeln(impr);
   end;
END.
5. példa: egy katalóguscédula adatainak megadása (Java)
public class Pelda5 {
    public long raktjel;
    public String[] szerzo=new String[3];        /*String típusú tömböt is deklarálhatunk*/

    public String cim,impr;
    public void beallit() {
        raktjel=1234;
        szerzo[0]="Kortvelyesi Gezane";
        szerzo[1]="";
        szerzo[2]="";
        cim="Turbo Pascal 4.0";
        impr="Muszaki Konyvkiado, Budapest, 1990.";
        }
    public void kiir() {
        System.out.println(raktjel);
        System.out.print(cim+". / "+szerzo[0]);
        if (szerzo[1].length()>0) {
            System.out.print(" - "+szerzo[1]);    /*egy String típusú változó vagy mezõ hosszát a String osztály
length() metódusa adja meg*/
            }
        if (szerzo[2].length()>0) {
            System.out.print(" - "+szerzo[2]);
            }
        System.out.println(".");
        System.out.println(impr);
        }
public static void main(String[] args) {
    Pelda5 p=new Pelda5();
    p.beallit();
    p.kiir();
    }
}

                                                                                              Boda István, 2003 november 2.
Változók, összetett adattípusok (példák)

public class Lotto { //részletesebben lásd változók, összetett adattípusok
public static void main(String[] args) {
    int[] lotto={8,23,29,55,81};
    System.out.println("A javasolt lottoszamok:");
    System.out.println(lotto[0]);
    System.out.println(lotto[1]);
    System.out.println(lotto[2]);
    System.out.println(lotto[3]);
    System.out.println(lotto[4]);
    }
}


public class Lotto1 {
public static void main(String[] args) {
    int[] lotto={8,23,29,55,81};
    int i;
    System.out.println("A javasolt lottoszamok:");
    for(i=0;i<5;i++) {
    System.out.println(lotto[i]);
    }
    }
}



public class Lotto2 { //részletesebben lásd változók, összetett adattípusok
    public static final String LF="\n"; //soremelés
    public int[] lotto=new int[5];
    public void beallit() {
    lotto[0]=8;
    lotto[1]=23;
    lotto[2]=29;
    lotto[3]=55;
    lotto[4]=81;
    }
    public void kiir() {
    System.out.println("A javasolt lottoszamok:");
    System.out.println(lotto[0]+LF+lotto[1]+LF+lotto[2]+LF
                   +lotto[3]+LF+lotto[4]);
    }
public static void main(String[] args) {
    Lotto2 p=new Lotto2();
    p.beallit();
    p.kiir();
    }
}
public class Lotto3 extends Lotto2 {
        public void beallit() {
        int i;
        for(i=0;i<5;i++) {
        lotto[i]=(int)(90*Math.random())+1; //1 és 90 közötti véletlen szám
        }
        /* a számok nincsenek rendezve, és közöttük lehetnek azonosak is! */
        }
public static void main(String[] args) {
        Lotto3 p=new Lotto3();
        p.beallit();
        p.kiir();
        }
}



public class Lotto4 extends Lotto2 {
public static final int MAXL=5; //ennyi lottószámot húzunk
public static final int MAXN=90; //ennyi számmal dolgozunk
public boolean[] szamok=new boolean[MAXN]; //milyen számokat generáltunk?
public void torol() {
    int i;
    for(i=0;i<MAXN;i++) {
    szamok[i]=false;
    }
    }
public void beallit() {
    int i,n;
    torol(); //új számokat húzunk
    for(i=0;i<MAXL;) {
    n=(int)(MAXN*Math.random())+1; //1 és 90 közötti véletlen szám
    if(!szamok[n-1]) { //még nem volt ilyen szám
        lotto[i++]=n; //csak itt növeljük a ciklusváltozó értékét!
        szamok[n-1]=true; //ez többet nem húzható ki!
        }
    }
    }
public static void main(String[] args) {
Lotto4 p=new Lotto4();
p.beallit();
p.kiir();
}
}
public class Lotto5 extends Lotto4 {
public void beallit() {
    int i,n;
    torol(); //új számokat húzunk
    for(i=0;i<MAXL;) {
    n=(int)(MAXN*Math.random())+1; //1 és 90 közötti véletlen szám
    if(!szamok[n-1]) { //még nem volt ilyen szám
        i++; //ciklusváltozó növelése
        szamok[n-1]=true; //ez többet nem húzható ki!
        }
    }
    i=0;
    for(n=1;n<=MAXN;n++) {
    if(szamok[n-1]) { //ezt a számot kihúztuk
        lotto[i++]=n; //eltároljuk nagyság szerint rendezetten!
        if(i>=MAXL) break; //megvan az öt lottószám
        }
    }
    }
public static void main(String[] args) {
Lotto5 p=new Lotto5();
p.beallit();
p.kiir();
}
}


public class Lotto6 extends Lotto5 {
public int kihuz(int i) {
    if(1<=i && i<=5) return lotto[i-1];
    return -1;
    }
public void kiir() {
    int i;
    for(i=1;i<=MAXL;i++) {
    System.out.println("A(z) "+i+". lottoszam: "+kihuz(i));
    }
    }
public static void main(String[] args) {
Lotto6 p=new Lotto6();
p.beallit();
p.kiir();
}
}
public class LottoSzamok {
/* a LottoSzamok osztály ugyanaz, mint a Lotto6 osztály, csak minden mezõ
    és metódus "egyben" megtalálható benne */
public static final int MAXL=5; //ennyi lottószámot húzunk
public static final int MAXN=90; //ennyi számmal dolgozunk
public boolean[] szamok=new boolean[MAXN]; //milyen számokat generáltunk?
public int[] lotto=new int[MAXL]; //a beállított lottószámok
public void torol() {
 int i;
 for(i=0;i<MAXN;i++) {
    szamok[i]=false;
    }
 }
public void beallit() {
 int i,n;
 torol(); //új számokat húzunk
 for(i=0;i<MAXL;) {
    n=(int)(MAXN*Math.random())+1; //1 és 90 közötti véletlen szám
    if(!szamok[n-1]) { //még nem volt ilyen szám
     i++; //ciklusváltozó növelése
     szamok[n-1]=true; //ez többet nem húzható ki!
     }
    }
 i=0;
 for(n=1;n<=MAXN;n++) {
    if(szamok[n-1]) { //ezt a számot kihúztuk
     lotto[i++]=n; //eltároljuk nagyság szerint rendezetten!
     if(i>=MAXL) break; //megvan az öt lottószám
    }
    }
 }
public int kihuz(int i) {
 if(1<=i && i<=5) return lotto[i-1];
 return -1;
 }
public void kiir() {
 int i;
 for(i=1;i<=MAXL;i++) {
    System.out.println("A(z) "+i+". lottoszam: "+kihuz(i));
    }
 }
public static void main(String[] args) {
 LottoSzamok lotto=new LottoSzamok();
 lotto.beallit();
 lotto.kiir();
 }
}
public class Katced { //részletesebben lásd változók, összetett adattípusok
public long raktjel;
public String[] szerzo=new String[3];
public String cim,impr;
public void beallit() {
 raktjel=1234;
 szerzo[0]="Kortvelyesi Gezane";
 szerzo[1]="";
 szerzo[2]="";
 cim="Turbo Pascal 4.0";
 impr="Muszaki Konyvkiado, Budapest, 1990.";
 }
public void kiir() {
 System.out.println(raktjel);
 System.out.print(cim+". / "+szerzo[0]);
 if (szerzo[1].length()>0) { //ha van második szerzõ
    System.out.print(" - "+szerzo[1]);
    }
 if (szerzo[2].length()>0) { //ha van harmadik szerzõ
    System.out.print(" - "+szerzo[2]);
    }
 System.out.println(".");
 System.out.println(impr);
 }
public static void main(String[] args) {
 Katced p=new Katced();
 p.beallit();
 p.kiir();
 }
}


public class Katced1 extends Katced {
public void beallit() { //átdefiniáljuk a beallit() metódust
 raktjel=5678;
 szerzo[0]="Veg Csaba";
 szerzo[1]="dr. Juhasz Istvan";
 szerzo[2]="";
 cim="Java - Start!";
 impr="Logos Konyvkiado, Budapest, 2000.";
 }
public static void main(String[] args) {
 Katced p=new Katced();
 Katced1 p1=new Katced1();
 System.out.println("--------------------------------");
 System.out.println("Elso rekord:");
 p.beallit();
 p.kiir();
 System.out.println("--------------------------------");
 System.out.println("Masodik rekord:");
 p1.beallit();
 p1.kiir();
 }
}

                                                                              Boda István, 2003. november 13.
kifejezések, mûveletek

A megvalósítandó algoritmus lépéseit egy programban utasításokkal írjuk le (részletesen ld. bevezetés, szemantika). Az
utasítások végrehajtása során

       a bemeneti adatok és részeredmények tárolása változókban történik,
       a részeredményeket úgy kapjuk, hogy a változókon meghatározott mûveleteket hajtunk végre, és ezek eredményét
        a változókban értékadással eltároljuk.



mûveletek
A mûveletek segítségével kifejezéseket képezünk. A legegyszerûbb kifejezések egy operátorból és egy vagy
két operandusból állnak, pl. a + b. Általános esetben a kifejezések operandusok és operátorok sorozatai, ahol

       az operandusok lehetnek
            o konstansok
            o változók
            o a kifejezésekbe ágyazott további kifejezések (pl. zárójelek között vagy függvények segítségével
                megadva); ilyenkor összetett kifejezéseket kapunk
       az operátorok vagy mûveletek lehetnek
            o zárójelek vagy függvények amelyekkel
                     összetett kifejezéseket tudunk képezni, és
                     a mûveletek végrehajtásának sorrendjét tudjuk meghatározni
            o unáris (egyoperandusú) mûveletek
            o bináris (kétoperandusú) mûveletek

A legfontosabb operátorokat precedenciájuk sorrendjében soroltuk fel. Az operátorok között nem szerepeltek például az
értékadó operátorok (pl. == vagy +=), az ún. postfix növelõ és csökentõ mûveletek (pl. i++ vagy j--), és a prefix növelõ és
csökentõ mûveletek (pl. ++i vagy --j), mivel ezeket az értékadással kapcsolatos fejezetben tárgyaljuk. Ha azonban mégis
el akarjuk helyezni ezeket az operátorokat is az operátorok "precedencia-hierarchiájában", akkor a következõket
állapíthatjuk meg:

       a postfix növelõ és csökentõ mûveletek nagyon nagy precedenciával rendelkeznek, kiértékelésük közvetlenül a
        zárójelek kiértékelése után, az unáris operátorok kiértékelése elõtt történik
       a prefix növelõ és csökentõ mûveletek precedenciájukat tekintve (is) az unáris operátorok csoportjába tartoznak;
       az értékadások rendelkeznek az operátorok közül a legkisebb precedenciával, kiértékelésük az összes felsorolt
        operátor kiértékelése után történik.

Mindamellett összetett esetekben inkább zárójelezzünk, és így sok kellemetlenségtõl kímélhetjük meg magunkat; például
ha az i=i+1; és System.out.println("?"+i); (J) utasításokat össze akarjuk vonni

        System.out.println("?"+++i);

módon, a zárójelek közötti kifejezés kiértékelésekor a Java fordító szintaktikai hibát jelez (ti. az idézõjelek közötti
kifejezésre próbálná a Java fordító a ++ postfix növelõ operátort alkalmazni, ami nyilván lehetetlen). Célszerûbb - és
egyszerûbb, áttekinthetõbb - tehát a

        System.out.println("?"+(++i));

alakot használnunk.
Ezek után nézzünk meg egy példaprogramot, amely az egyes operátorok használatát szemlélteti, majd
néhány további példát összetett kifejezésekre.
a mûveletek végrehajtásának sorrendje

      elõször mindig a zárójelben levõ kifejezéseket értékeljük ki (pl. 5*(2+3) = 5*5 = 25 vagy 1+sin(Pi/6) =
       1+sin(0.52359877...) = 1+0.5 = 1.5 )
      ha nincs zárójel, a kifejezésben szereplõ legmagasabb precedenciájú mûveletet hajtjuk elõször végre (pl.
       3+5*2=3+(5*2)=3+10=13)
      ha a mûveletek precedenciája megegyezik, a mûveleteket rendszerint balról jobbra hajtjuk végre (pl.
       1+2+3=(1+2)+3=3+3=6)


Jegyezzük meg: ha nincs zárójel, az összetett kifejezések kiértékelésének sorrendjét az operátorok prioritása
vagy precedenciája (elsõbbsége) határozza meg. Különbözõ precedenciájú operátorok esetén mindig elõször
a legmagasabb precedenciájú operátorhoz tartozó kifejezést értékeljük ki, és így folytatjuk a megmaradt
kifejezések kiértékelését tovább, amíg az operátorok elfogynak, vagy csak azonos precedenciájú operátorok
maradnak. Azonos precedencia esetén az operátorok kiértékelését pedig rendszerint balról jobbra hajtjuk
végre.


unáris, egy operandussal rendelkezõ mûveletek (rendszerint magasabb precedenciával rendelkeznek, mint a
bináris, két operandussal rendelkezõ mûveletek)

      elõjelváltás: - (TP, J); megjegyzés: kivonáskor a kivonandó kifejezést elõjelváltáskor zárójelezni kell,
       hogy a kivonást és elõjelváltást a magasabb precedenciájú -- prefix csökkentõ operátortól
       megkülönböztessük, azaz pl. a szintaktikusan hibás a--b kifejezés helyett a-(-b)-t kell írnunk
           o használható a pozitív elõjel is: + (TP, JP); megjegyzés: a + operátornak gyakorlatilag semmilyen
               hatása nincs; összeadáskor zárójelezni kell, hogy a magasabb precedenciájú ++ prefix növelõ
               operátortól megkülönböztessük, azaz pl. a szintaktikusan hibás a++b kifejezés helyett a+(+b)-t
               kell írnunk
      logikai nem (negáció): not (TP); ! (J)
      típusváltás vagy típuskényszerítés: pl. byte(...), char(...) (TP); pl. (char), (int) (J)


bináris (kétoperandusú) mûveletek (mûveletcsoportonként precedencia szerint csökkenõ sorrendben; egy
mûveletcsoporton belül a megadott operátorok precedenciája megegyezik)

      multiplikatív mûveletek
           o szorzás: * (TP, J)
           o osztás: / (TP, J)
           o maradékos osztás
           o logikai és mûvelet a Turbo Pascalban (konjunkció): and (TP)
      additív mûveletek
           o összeadás: + (TP, J)
           o konkatenáció, azaz karakterláncok összefûzése: + (TP,J); megjegyzés: mivel az összeadás és a
                konkatenáció operátora egyaránt + és precedenciájuk megegyezik, ezért szükség esetén
                zárójeleznünk kell, például
                     System.out.println("?"+2+3); (J) nem 2 és 3 összegét írja ki a ? után (azaz nem ?5-öt),
                        hanem ?23-at, de
                     System.out.println(2+3+"?"); (J) már 2 és 3 összegét írja ki, azaz ?5-öt.
           o kivonás: - (TP, J)
           o logikai vagy mûvelet a Turbo Pascalban (diszjunkció): or (TP)
      relációs vagy összehasonlító mûveletek
      logikai és mûvelet a Javában (konjunkció): && (J)
      logikai vagy mûvelet a Javában (diszjunkció): || (J)
      feltételes kifejezés: ? : (J)
maradékos osztás

        egészosztás (az egész típusú operandusokkal végzett maradékos osztás egész típusú hányadosa; pl. 5 div
         2 (TP) vagy 5 / 2 (J) eredménye egyaránt 2): div (TP); / (J)
        maradékképzés (az egész típusú operandusokkal végzett maradékos osztás egész típusú maradéka; pl. 5
         mod 2 (TP) vagy 5%2 (J) eredménye egyaránt 1): mod (TP); % (J)



relációs vagy összehasonlító mûveletek

        összehasonlítások
            o kisebb, kisebb egyenlõ, nagyobb, nagyobb egyenlõ: <, <=, >, >=(TP, J)
        egyenlõség-vizsgálatok
            o egyenlõ: = (TP); == (J)
            o nem egyenlõ: <> (TP); != (J)

Megjegyzések:
(1) a Java nyelvben az összehasonlítások precedenciája magasabb, mint az egyenlõség-vizsgálatoknak, Turbo
Pascalban viszont nincs különbség;
(2) Java esetén csak numerikus típusokra alkalmazhatóak az összehasonlítások és egyenlõség-vizsgálatok,
Turbo Pascal esetén viszont karakterláncokra is.


példaprogram az egyes operátorok használatának szemléltetésére
public class Muveletek {
  public static void main(String[] args) {
       int i=0;
       double j=0D;
       try {
          i=Integer.parseInt(args[0]);
          j=Double.parseDouble(args[1]);
          }
       catch(Exception e) {
          System.out.println("Hibas parameter(ek)! "+e);
          }
       System.out.println("i = "+i+", j = "+j);
       System.out.println("***** Unaris muveletek: *****");
       System.out.println("i++ = "+i+++", i = "+i);
       System.out.println("i-- = "+i--+", i = "+i);
       System.out.println("i = "+i+", ++i ="+(++i));
       System.out.println("i = "+i+", --i ="+--i);
       System.out.println("+i = "+(+i)+", i = "+i+" (a ketto ugyanaz...)");
       System.out.println("-i = "+-i);
       System.out.println("(i < j) = "+(i<j)+", !(i < j) = "+!(i<j));
       System.out.println("(char)i = "+(char)i);
       System.out.println("(double)i = "+(double)i);
       System.out.println("(int)j = "+(int)j);
       System.out.println("***** Binaris muveletek: *****");
       System.out.println("(i + j) = "+(i+j)+", (i - j) = "+(i-j));
       System.out.println("(i * j) = "+(i*j)+", (i / j) = "+(i/j));
       System.out.println("(i / (int)j) = "+(i/(int)j));
       System.out.println("(i % (int)j) = "+(i%(int)j));
       System.out.println("(i <= j) = "+(i<=j)+", (i > j) = "+(i>j));
       System.out.println("(i == j) = "+(i==j)+", (i != j) = "+(i!=j));
       System.out.println("(i <= j) && (i > j) = "+(i<=j && i>j));
       System.out.println("(i <= j) || (i > j) = "+(i<=j || i>j));
       System.out.println("(i<j ? \"i kisebb\" : \"j kisebb\") = "+(i<j?"i kisebb":"j kisebb"));
       /* a program futásának eredménye itt látható */
       }
  }


példák összetett kifejezésekre

      1. a Turbo Pascalban, ha j integer típusú változó, akkor a (4<j) and (j<6) kifejezés értéke
             o ha j=5 akkor True
             o ha j<=4 vagy j>=6 akkor False
      2. a Turbo Pascalban, ha j integer típusú változó, akkor a 4<j and j<6 kifejezés szintaktikailag hibás,
         mivel a logikai "és" (and) mûvelet magas precedenciája miatt Turbo Pascal fordító elõször a j and j
         mûveletet értékelné ki, és nem az összehasonlító mûveleteket
      3. a Javaban, ha j int típusú változó, akkor a (4<j) && (j<6) kifejezés értéke
             o ha j==5 akkor true
             o ha j<=4 vagy j>=6 akkor false
      4. a Javaban, ha j int típusú változó, akkor a 4<j && j<6 kifejezés szintaktikailag helyes, mivel a logikai
         "és" (&&) mûvelet alacsony precedenciája miatt a Java elõször az összehasonlító mûveleteket fogja
         kiértékelni

Megjegyzés: a példákból is látszik, hogy összetett kifejezésekben a mûveletek kiértékelésének sorrendje
lényegében a kifejezés megfelelõ zárójelezésével egyenértékû; például a 2. példában szereplõ kifejezés esetén

           4<j and j<6

kiértékelése formálisan a

           ((4<(j and j)1)2<6)3

zárójelezés által meghatározott sorrendben történik. (Itt az alsó indexekkel a zárójeles kifejezések
kiértékelésének sorrendjét adtuk meg.)

                                                                                       Boda István, 2003 november 13.
értékadás, típuskonverzió

A megvalósítandó algoritmus lépéseit egy programban utasításokkal írjuk le (részletesen ld. bevezetés, szemantika). Az
utasítások végrehajtása során

       a bemeneti adatok és részeredmények tárolása változókban történik,
       a részeredményeket úgy kapjuk, hogy a változókon meghatározott mûveleteket hajtunk végre, és ezek eredményét
        a változókban értékadással eltároljuk.


értékadás
A kifejezések értékét legtöbbször értékadással eltároljuk egy változóban. Az értékadó utasítás rendszerint egy
változóból, egy értékadó operátorból és egy kifejezésbõl áll, pl. x := a + b; (Turbo Pascal) vagy x = a + b;
(Java). Általános esetben az értékadó utasítás szerkezete a következõ:

       az értékadás bal oldala: egy változó nevének megadása
       az értékadás jelölése: az értékadó operátor megadása
            o általános esetben ez a := vagy a = operátor ("legyen egyenlõ"): pl. x:=3; (TP) x=3; (J),
            o azonban lehetõség van egyes gyakran elõforduló értékadás-típusok rövidítésére is
       az értékadás jobb oldala: egy kifejezés megadása, amelynek az értékét a kifejezés kiszámítása vagy kiértékelése
        után eltároljuk a baloldalon megadott változóban (megjegyzés: egyes programozási nyelvek, pl. a C és Java lehetõvé teszik pl.
        több értékadó utasítás megadását is egy sorban, de mi ezzel csak igen ritkán élünk, mert a forráskód áttekinthetõségét fontosabbnak tartjuk,
        mint a tömörségét)

Az általunk vizsgált programozási nyelvekben szükséges a baloldal és jobboldal típusának egyeztetése. Emellett az
értékadó utasítás jobb oldalán megadott kifejezésen belül is óvatosan kell eljárnunk a kifejezésben elõforduló
operandusok típusának megválasztáskor, mert egyes esetekben túlcsordulás léphet fel a kifejezés kiértékelése közben.

gyakran elõforduló értékadás-típusok rövidítése; példák:

       j++; vagy ++j; (J; ha önállóan használjuk, mindkettõ megfelel a j=j+1; értékadásnak); azonban ha egy kifejezésen
        belül használjuk õket, a ++ mûveletekkel megadott értékadó utasítást tömören belefoglaljuk a kifejezésbe, de
        természetesen ez nem kötelezõ és mindig helyettesíthetõ a kifejezés elõtt vagy után egy külön megadott értékadó
        utasítással:
             o ++j esetén az értékadás a kifejezés kiértékelése elõtt,
             o j++ esetén az értékadás a kifejezés kiértékelése után történik meg.
       j--; vagy --j; (J; ha önállóan használjuk, mindkettõ megfelel a j=j-1; értékadásnak); azonban ha egy kifejezésen
        belül használjuk õket, a -- mûveletekkel megadott értékadó utasítást a ++ mûvelethez hasonlóan tömören
        belefoglaljuk a kifejezésbe, de természetesen ez sem kötelezõ és mindig helyettesíthetõ a kifejezés elõtt vagy után
        egy külön megadott értékadó utasítással:
             o --j esetén az értékadás a kifejezés kiértékelése elõtt,
             o j-- esetén az értékadás a kifejezés kiértékelése után történik meg.
       inc(j); (TP, sorszámozott típusú változók esetén; megfelel a j=j+1; értékadásnak)
       dec(j); (TP, sorszámozott típusú változók esetén; megfelel a j=j-1; értékadásnak)
       j+=k; (J; megfelel a j=j+k; értékadásnak; k tetszõleges kifejezés is lehet)
       j-=k; (J; megfelel a j=j-k; értékadásnak; k tetszõleges kifejezés is lehet)
       j*=k; (J; megfelel a j=j*k; értékadásnak; k tetszõleges kifejezés is lehet)
       j/=k; (J; megfelel a j=j/k; értékadásnak; k tetszõleges kifejezés is lehet)
       j%=k; (J; megfelel a j=j%k; értékadásnak; k tetszõleges kifejezés is lehet)
       inc(j,k); (TP, sorszámozott típusú változók esetén; megfelel a j=j+k; értékadásnak)
       dec(j,k); (TP, sorszámozott típusú változók esetén; megfelel a j=j-k; értékadásnak)
a baloldal és jobboldal típusának egyeztetése

       típuskompatibilitás esetén az értékadás automatikusan megtörténik; típuskompatibilitásról olyankor beszélünk, ha
            o a baloldalon megadott változó és a jobboldalon megadott kifejezés típusa megegyezik, vagy
            o a baloldalon megadott változó típusának értéktartománya bõvebb, mint a jobboldalon megadott kifejezésé
                (ilyenkor automatikus típuskonverzió történik). Nézzünk erre néhány példát:
                      Turbo Pascal:
                              bal oldal: real, jobb oldal: integer
                              bal oldal: string, jobb oldal: char
                      Java:
                              bal oldal: double, jobb oldal: int
                              bal oldal: int, jobb oldal: char
       nem kompatibilis típusok esetén típuskonverzió végrehajtása szükséges. Ez lehetséges
            o típusváltással vagy típuskényszerítéssel, valamint
            o Turbo Pascal esetén konverziós függvények és konverziós eljárások alkalmazásával,
            o Java esetén pedig konverziós függvények alkalmazásával.


típusváltás vagy típuskényszerítés (a típus nevének közvetlen megadásával a kifejezés elõtt; ez esetenként nem várt
eredményekre vezethet, amely eredhet az adatábrázolás különbségébõl vagy a különbözõ típusok eltérõ helyfoglalásából)

       Turbo Pascal esetén csak sorszámozott típusra lehetséges; példák:
            o char(65) (értéke 'A')
            o byte('A') (értéke 65)
                     ha az integer típusú i változó értéke 256, akkor byte(i) értéke 0
            o word(-1) (értéke 65535)
                     ha a word típusú w változó értéke 65535, akkor integer(w) értéke -1
            o Boolean(0) (értéke False)
       Java esetén elvileg bármilyen (és nem csak elemi) típusra lehetséges; példák:
            o (char)65 (értéke 'A')
            o (short)'A' (értéke 65)
            o (int)2.71 (értéke 2)
            o (long)3.14 (értéke 3)
            o (double)'A' (értéke 65.0)


konverziós függvények alkalmazása (Turbo Pascal esetén)

       integer (karakterkód) -> char; példa:
            o Chr(65) (értéke 'A')
       char -> longint (karakterkód); példa:
            o Ord('A') (értéke 65)
    
       longint -> real (automatikusan megtörténik)
       real -> longint (a törtrész levágásával); példák:
             o Trunc(-2.5) (értéke -2)
             o Trunc(Pi) (értéke 3)
       real -> longint (kerekítéssel); példák:
             o Round(-2.5) (értéke -3)
             o Round(1000*Pi)/1000 (értéke 3.142; megjegyzés: így kerekíthetünk pl. három tizedesjegyre)
    
       char -> string (automatikusan megtörténik)
       szám (word, integer, real, stb.) -> string és string -> szám (word, integer, real, stb.)
            o konverziós eljárásokkal lehetséges
konverziós eljárások alkalmazása (Turbo Pascal esetén)

        egész (word, integer, stb.) -> string; példák:
               o Str(-25,s); (s értéke '-25' lesz)
               o Str(3:2,s); (s értéke ' 3' lesz)
        real -> string; példák:
               o Str(3.14:3:2,s); (s értéke '3.14' lesz)
               o Str(-2.5:6:2,s); (s értéke ' -2.50' lesz)
        string -> szám (word, integer, real, stb.); példák:
               o Val('3.14',x,errcode); (x értéke 3.14, errcode értéke 0 lesz)
               o Val('-2',i,errcode); (i értéke -2, errcode értéke 0 lesz)
               o Val('2 alma',i,errcode); (i értéke 0, errcode értéke 2 lesz)



konverziós függvények alkalmazása (Java esetén)

        int típusú karakterkód -> char: típuskényszerítéssel történhet; példa:
               o (char)65 (értéke 'A')
        char -> int típusú karakterkód: automatikusan megtörténik
    
        egész (int, long, stb.) -> valós (double, float): automatikusan megtörténik
        valós (double, float) -> egész (int, long, stb.): a törtrész levágása típuskényszerítéssel történhet; példák:
              o (int)(-2.5) (értéke -2)
              o (long)(Math.PI*1000)/1000.0 (értéke 3.141; megjegyzés: így vághatjuk le egy valós szám esetén pl. három tizedesjegy után a
                    további tizedesjegyeket, de nagyon kell vigyáznunk, mivel a (long)(Math.PI*1000)/1000 kifejezésben a / operátor az int típusú
                    operandusok következtében egészosztást jelentene, így ennek a kifejezésnek az értéke 3 és nem 3.141 lenne!)
        valós (double, float) -> long: a konverzió kerekítéssel is lehetséges; példák:
              o Math.round(-2.1) (értéke -2)
              o Math.round(1.5) (értéke 2)
              o Math.round(1000*Math.PI)/1000D (értéke 3.142; megjegyzés: így kerekíthetünk pl. három tizedesjegyre, de itt is nagyon kell
                    vigyáznunk, mivel az elõzõ példához hasonlóan a Math.round(1000*Math.PI)/1000 kifejezésben a / operátor az int típusú
                    operandusok következtében egészosztást jelentene, így ennek a kifejezésnek az értéke 3 és nem 3.142 lenne!)
    
        bármilyen elemi típus (int, double, boolean, char, stb.) -> String: konverziós függvényekkel, amelyek rendszerint statikusak, tehát a
         megfelelõ osztálynévvel minõsítve hívhatóak meg; példák:
             o String.valueOf(-25) (értéke "-25")
                        Integer.toString(-25) (értéke "-25")
                                              Integer.toBinaryString(65) (értéke 65 binárisan, azaz "1000001")
                                              Integer.toHexString(65) (értéke 65 hexadecimálisan, azaz "41")
                           Long.toString(-25) (értéke "-25")
               o     String.valueOf(3.14) (értéke "3.14")
                           Float.toString(3.14) (értéke "3.14")
                           Double.toString(3.14) (értéke "3.14")
               o     String.valueOf(true) (értéke "true")
                            Boolean.toString(true) (értéke "true")
               o     String.valueOf('A') (értéke "A")
                                 Character.toString('A') (értéke "A")
        String -> szám (int, double, stb.): konverziós függvényekkel, amelyek rendszerint statikusak, tehát a megfelelõ osztálynévvel minõsítve
         hívhatóak meg; példák:
              o Integer.parseInt("3") (értéke 3)
                        másik lehetõség: (new Integer("3")).intValue() (értéke 3)
              o Integer.parseInt("3.14") (konverziós hiba!)
                        NumberFormatException kivétel történik
              o Double.parseDouble("3.14") (értéke 3.14)
                        másik lehetõség: (new Double("3.14")).doubleValue() (értéke 3.14)
              o Double.parseDouble("2 alma") (konverziós hiba!)
                        NumberFormatException kivétel történik
    
        elemi típusok csomagoló osztálytípusai (pl. Integer, Double, stb.) -> String: a konvertálandó osztály toString() dinamikus metódusával, amelyet az osztály példányán keresztül
         kell meghívnunk (nem keverendõ össze a csomagoló osztályok statikus toString(...) metódusával, amelyet az osztálynévvel minõsítve kell meghívnunk!); példák:
               o i.toString() (ha pl. Integer i=new Integer(3), akkor a függvény értéke "3" lesz)
               o d.toString() (ha pl. Double d=new Double(3.14), akkor a függvény értéke "3.14" lesz)
        String -> elemi típusok csomagoló osztálytípusai (Integer, Double, stb.): használhatjuk az egyes osztályok konstruktorfüggvényeit, vagy pedig az osztályok valueOf() statikus
         függvényét; példák:
                o new Integer("3") (konverziós hiba esetén NumberFormatException kivétel történik)
                o Integer.valueOf("3") (értéke new Integer(3); konverziós hiba esetén NumberFormatException kivétel történik)
                o new Double("3.14") (konverziós hiba esetén NumberFormatException kivétel történik)
                o Double.valueOf("3.14") (értéke new Double(3.14); konverziós hiba esetén ebben az esetben is NumberFormatException kivétel történik)
túlcsordulás kiértékelés közben (egyes esetekben az értékkonstansok alapértelmezett típusának korlátozott
értéktartománya miatt a kifejezés kiértékelése hibás eredményt adhat)
program tulcsord;
uses crt;
var x:integer;
    y:real;
BEGIN
clrscr;
x:=10000;
y:=x*5/5; {helytelen eredményt ad, mivel 5 alapértelmezett típusa integer, így x*5 is integer típusú
kifejezésként lesz kiértékelve, azonban x*5 értéke x=10000 mellett az integer típus maximális
értéktartományán (32767) kívül esik, ezért a "felsõ bitek" el fognak veszni; ezért y értéke az
értékadás után -3.1072...e+03 lesz}
writeln('x = ',x,' y = ',y);
y:=x*5.0/5; {helyes: eredménye +1.0000...e+04}
writeln('x = ',x,' y = ',y);
{a program futásának eredménye itt látható}
END.

                                                                                    Boda István, 2003 november 12.
standard eljárások és függvények

       számokkal végzett (matematikai) mûveletek
       karakterekkel végzett mûveletek
       karakterláncokon végzett mûveletek (külön fájlban!)


számokkal végzett (matematikai) mûveletek

       páratlan szám kiválasztása; például
             o Odd(j) (TP; ha pl. j=1 akkor értéke True)
                      Odd(j) megfelel a (j mod 2) = 1 logikai kifejezésnek
             o j%2 == 1 (J; ha pl. j==2 akkor értéke false)
       kisebb vagy nagyobb szám kiválasztása
       valós szám egész- és törtrésze (valós típusú értékként megadva); például
             o Int(-2.5) (TP; értéke -2.5 egész része, azaz -2.0)
             o (double)(long)(3.14) (J; értéke 3.14 egész része, azaz 3.0)
             o Frac(-2.5) (TP; értéke -2.5 törtrésze, azaz -0.5)
             o x - (long)x (J; ha pl. x=3.14; akkor értéke 3.14 törtrésze, azaz 0.14000...)
       valós vagy egész szám abszolút értéke; például
             o Abs(-2) (TP; értéke 2)
             o Math.abs(-2.0) (J; értéke 2.0)
       felsõbb matematikai mûveletek
       hatványozás és gyökvonás; például
             o Sqr(2) (TP; értéke 2 a négyzeten, azaz 4)
             o x*x (TP,J; megadja x2 értékét)
                      Math.pow(3.0,2.0) (J; értéke 3.0 a négyzeten, azaz 9.0)
             o Sqrt(4.0) (TP; értéke négyzetgyök 4.0, azaz 2.0)
             o Math.sqrt(4.0) (J; értéke négyzetgyök 4.0, azaz 2.0)
                      Math.pow(4.0,0.5) (J; értéke négyzetgyök 4.0, azaz 2.0)
             o Exp(y*ln(x)) (TP; megadja xy értékét; Turbo Pascalban csak így lehet két valós szám hatványát kiszámítani!)
             o Math.pow(x,y) (J; megadja xy értékét)
       véletlen számok generálása; például
             o Random (TP; véletlen valós szám generálása a [0,1) intervallumból)
                      példa: Lottószámok véletlen generálása (Turbo Pascal)
             o Math.random() (J; véletlen valós szám generálása a [0,1) intervallumból)


kisebb vagy nagyobb szám kiválasztása; például

       if x<y then z:=x else z:=y; (TP; ha az x<y logikai kifejezés igaz, akkor x-et, egyébként y-t adja vissza a z változó
        értékeként)
       if(x<y) {z=x;} else {z=y;} (J; ha az x<y logikai kifejezés igaz, akkor x-et, egyébként y-t adja vissza a z változó értékeként; a
        {} zárójelek el is hagyhatóak)
       Math.min(1,2) (J; a megadott két szám közül a kisebbet adja vissza, tehát 1-et)
             o (x<y ? x : y) (J; ha az x<y logikai kifejezés igaz, akkor x-et, egyébként y-t adja vissza, tehát hatása ugyanaz, mint a
                 Math.min(x,y) függvénynek)
       if x>y then z:=x else z:=y; (TP; ha az x>y logikai kifejezés igaz, akkor x-et, egyébként y-t adja vissza a z változó
        értékeként)
       if(x>y) {z=x;} else {z=y;} (J; ha az x>y logikai kifejezés igaz, akkor x-et, egyébként y-t adja vissza a z változó értékeként; a
        {} zárójelek el is hagyhatóak)
       Math.max(1.4,2.8) (J; a megadott két szám közül a nagyobbat adja vissza, tehát 2.8-at)
             o (x>y ? x : y) (J; ha az x>y logikai kifejezés igaz, akkor x-et, egyébként y-t adja vissza, tehát hatása ugyanaz, mint a
                 Math.max(x,y) függvénynek)
       példák:
             o min() és max() függvények definiálása Turbo Pascalban
             o min() és max() függvények definiálása Javaban
min() és max() függvények definiálása Turbo Pascalban
program MinMax;
uses crt;
var i,j:integer;
function min(x,y:integer):integer; {x és y un. formális paraméterek, amelyeken keresztül értéket
tudunk átadni a min() függvénynek; a min() függvény a formális paraméterek aktuális értéke alapján
számítja ki majd a visszatérési értékét, amely x és y aktuális értéke közül a kisebbik lesz}
  var z:integer;
  begin
  if x<y then z:=x else z:=y;
  min:=z;
  end;
function max(x,y:integer):integer;
  var z:integer;
  begin
  if x>y then z:=x else z:=y;
  max:=z;
  end;
BEGIN
write('Az elso szam: '); readln(i);
write('A masodik szam: '); readln(j);
writeln('A kisebbik szam: ',min(i,j)); {i és j a min() függvény hívásakor a formális paraméterek helyén
szereplõ aktuális paraméterek, amelyeknek az értéke "átadódik" a min() függvény definíciójában
szereplõ x és y formális paramétereknek (ez az un. paraméterátadás), és ezután ezekkel az
értékekkel fogja a min() függvény kiszámítani a visszatérési értékét}
writeln('A nagyobbik szam: ',max(i,j));
END.
min() és max() függvények definiálása Javaban
public class MinMax {
public static int min(int x,int y,int z) {         /*x, y és z un. formális paraméterek, amelyeken keresztül értéket tudunk
átadni a min() függvénynek; a min() függvény a formális paraméterek aktuális értéke alapján számítja ki majd a
visszatérési értékét, amely x, y és z aktuális értékei közül a legkisebb lesz*/
    int w;
    w=Math.min(x,y);            /*a w változó x és y értéke közül a kisebbiket fogja tartalmazni*/

    return Math.min(w,z);
    }
public static int max(int x,int y,int z) {
    return Math.max(Math.max(x,y),z); /*így tömörebb, mint a min() függvény esetén, de ugyanazt a hatást érjük
el*/
    }
public static void main(String[] args) {
    int i,j,k;
    try {
            i=Integer.parseInt(args[0]);
            j=Integer.parseInt(args[1]);
            k=Integer.parseInt(args[2]);
            System.out.println("A legkisebb szam: "+min(i,j,k)); /*i, j és k a min() függvény hívásakor a formális
paraméterek helyén szereplõ aktuális paraméterek, amelyeknek az értéke "átadódik" a min() függvény definíciójában
szereplõ x, y és z formális paramétereknek (ez az un. paraméterátadás), és ezután ezekkel az értékekkel fogja a min()
függvény kiszámítani a visszatérési értékét*/
            System.out.println("A legnagyobb szam: "+max(i,j,k));
            }
    catch(Exception e) {
            System.out.println("Legkozelebb adj meg harom szamot!");
            }
    }
}


felsõbb matematikai mûveletek

               szögfüggvények használata (a szögértékeket radiánban kell megadni!); például
                   o Pi (TP; értéke a Pi szám, azaz 3.14159....)
                   o Math.PI (J; értéke a Pi szám, azaz 3.14159....)
                   o Sin(Pi/6), Cos(Pi/3) (TP; értékük 0.5)
                           példa: a szinuszfüggvények táblázatának kiiratása (Turbo Pascal)
                   o Math.sin(Math.PI/6), Math.cos(Math.PI/3) (J; elvi értékük 0.5)
                           példa: a szinuszfüggvények táblázatának kiiratása (Java)
                   o Math.tan(Math.PI/4) (J; elvi értéke 1.0)
                   o ArcTan(1) (TP; értéke 0.785398...=Pi/4)
              o  Math.atan(1) (J; értéke 0.785398...=Pi/4)
                     megjegyzés: az elõzõ példában az arkusz tangens függvény radiánban adja meg azt az x
                        szöget, amelyre tg(x)=sin(x)/cos(x) értéke éppen 1; ezt a szöget fokban is megkaphatjuk
                        például Math.atan(1)*180/Math.PI módon (Java), ekkor a kifejezés értéke 45.0 lesz,
                        mivel 45 fokra egyezik meg a szinusz és koszinusz szögfüggvények értéke, amelyek
                        hányadosa a tangens függvény)
         az exponenciális és a (természetes alapú) logaritmusfüggvény használata; például
              o Math.E (J; értéke "e", a természetes logaritmus alapszáma, azaz 2.71828...)
                                                                            1
              o Exp(1) (TP; értéke "e" az elsõ hatványon, azaz (2.71828...) = 2.71828...)
                                                                                1
              o Math.exp(1) (J; értéke "e" az elsõ hatványon, azaz (2.71828...) = 2.71828...)
              o Ln(2.71828) (TP; 2.71828 természetes alapú logaritmusa, értéke az argumentum pontatlansága
                 miatt "majdnem" 1.0, azaz 0.99999...)
              o Math.log(2.71828) (J; 2.71828 természetes alapú logaritmusa, értéke 0.99999...)




radián (ívmérték: a körív nyílásszögét megadhatjuk a körív és a hozzá tartozó sugár hányadosával)

         jegyezzük meg: a teljes kör "nyílásszöge" egy tetszõleges r sugár mellett
              o 360 fok = 2*r*Pi / r (radián) = 2*Pi (radián), tehát
              o 180 fok = Pi radián
         átváltás fokból radiánba: x fok = x * Pi / 180 radián; például
              o Math.toRadians(180.0) (J; értéke Pi, azaz 3.14159...)
         átváltás radiánból fokba: x radián = x * 180 / Pi fok; például
              o Math.toDegrees(Math.PI) (J; értéke 180.0)




a szinuszfüggvények táblázatának kiiratása (Turbo Pascal)
program Szinusz;
uses crt;
var f:integer;
    r:real;
BEGIN
clrscr;
f:=0;
writeln('SZINUSZFUGGVENYEK TABLAZATA');
writeln;
writeln('FOK':20,'RADIAN':20,'SZINUSZ':20);
repeat
  r:=f/180*Pi;
  writeln(f:20,r:20:4,sin(r):20:4);
  f:=f+15;
until f>90;
{a program futásának eredménye itt látható}
END.
a szinuszfüggvények táblázatának kiiratása (Java)
megjegyzés: az adatok formázott kiiratásához szükség van egy Formats osztályra is, amelynek a
metódusait a Szinusz osztályban fogjuk felhasználni
public class Formats {
public static String format(String s,int n) { /*szignatúra: String format(String,int)*/
   int k;
   StringBuffer sb=new StringBuffer();           /*a String és StringBuffer osztályok egyaránt karakterláncok
reprezentálására szolgálnak, azonban ellentétben a String osztályba tartozó változókkal, a StringBuffer osztályba tartozó
változók értéke (és hossza) módosítható, így itt ilyen osztály-típusú változót érdemes használni. Ha String osztályba
tartozó változót használnánk, akkor a változó értékének minden módosítása egy új karakterlánc létrehozását
eredményezné (pl. a változó aktuális értékének átmásolásával egy új memóriaterületre), és a már nem használt
memóriaterültek felszabadítását a Java un. szemétgyûjtõ algoritmusára kellene hagynunk, ami (elvileg) rosszabb
hatékonyságú megoldást eredményezne.*/
   for(k=s.length()+1;k<=n;k++) {
       sb.append('_'); /*sb feltöltése '_' karakterekkel; az s String típusú változót használva ide az s='_'+s értékadó
utasítást írhatnánk*/
       }
   sb.append(s);        /*sb aktuális értékéhez s értékének hozzáírása jobbról; a kapott karakterlánc hossza a "vezetõ" '_'
karakterekkel együtt így legalább n lesz (ha s hossza eredetileg nem volt nagyobb, mint n, akkor pontosan n lesz)*/
   return sb.toString(); /*sb aktuális értékének String típusúvá alakítása*/
   }
public static String format(int i,int n) {      /*szignatúra: String format(int,int)*/

   return format(String.valueOf(i),n); /*az int típusú i változó String típusúvá alakítása után a format(String,int)
metódus meghívása*/
   }
public static String format(double d,int n,int m) { /*szignatúra: String format(double,int,int)*/
   double x;
   StringBuffer s=new StringBuffer();
   if (m>0) {
       x=Math.pow(10,m); /*10m kiszámítása*/
       d=Math.round(d*x)/x; /*d kerekítése m számú tizedesjegyre*/
       s.append(d); /*a double típusú d változó String típusúvá alakítása*/
       }
   else if (m==0) {
       s.append(Math.round(d)); /*d kerekítése egész számmá, ha m értéke nulla*/
       }
   else {
       s.append(d); /*ha m negatív, a harmadik paraméter értékét figyelmen kívül hagyjuk*/
                    }
            return format(s.toString(),n); /*a format(String,int) metódus meghívása*/
            }
public static void main(String[] args) {
    System.out.println("Teszt:");
    System.out.println("                    "+format("Hello",10));
    System.out.println("                    "+format("Kata",10));
    System.out.println("                    "+format("!",10));
    System.out.println("                    "+format("Misztotfalusi Kiss Miklos",10));
    System.out.println("                    "+format(3000,10));
    System.out.println("                    "+format(23,10));
    System.out.println("                    "+format(Math.E,10,8));
    System.out.println("                    "+format(Math.PI,10,6));
    System.out.println("                    "+format(5D,10,1));
    System.out.println("                    "+format(2.0/3,10,0));
    System.out.println("                    "+format(2.0/3,10,-1));
    /*a program futásának eredménye itt látható*/
    }
}

Figyeljük meg: a Formats osztályban deklarált három statikus metódus neve megegyezik, de a metódusok
formális paraméterei különbözõ típusúak, ill. számúak, ezért a metódusok hívásakor a Java a metódusok
szignatúrája (=a metódus neve, formális paramétereinek száma, típusa és sorrendje, valamint függvények
esetén a visszaadott érték típusa) alapján egyértelmûen el tudja dönteni, melyik metódusról van szó. Így a
hasonló funkciójú, de különbözõ paraméterekkel végrehajtott mûveletekre ugyanazzal a névvel tudunk
hivatkozni. Esetünkben a format nevû metódus a hívásakor megadott String, int vagy double típusú
paramétert egyaránt adott, legalább n hosszúságú Stringgé konvertálja (double típusú paraméter esetén
legfeljebb m tizedesjegy pontossággal). Ilyen esetekben azt mondjuk, hogy a metódus neve túl van terhelve
(overloading).
public class Szinusz {
public static void main(String[] args) {
        int f;
        double r;
        System.out.println(Formats.format("FOK",20)+Formats.format("RADIAN",20)+
                         Formats.format("SZINUSZ",20));
        for(f=0;f<=90;f+=15) {
                r=f/180.0*Math.PI;   /*fok átváltása radiánba*/
                System.out.println(Formats.format(f,20)+Formats.format(r,20,4)+
                           Formats.format(Math.sin(r),20,4));
                }
        /*a program futásának eredménye itt látható*/
        }
}
példa: Lottószámok véletlen generálása (Turbo Pascal)
program Lotto;
uses crt;
var x:array [1..5] of integer;
       i:integer;
BEGIN
clrscr;
randomize; {"megkeverjük" a véletlenszám elõállító algoritmust (=a rendszeróra alapján a TP elõállít egy
véletlen számot, amelyet paraméterként átad az algoritmusnak), így minden programfuttatáskor más és más
véletlen számokat fogunk kapni}
for i:=1 to 5 do begin
   x[i]:=trunc(random*90)+1; {véletlen egész szám generálása az [1,90] intervallumból; persze az elõfordulhat,
hogy már volt ilyen szám...}
   end;
for i:=1 to 5 do writeln(i,'. lottoszam: ',x[i]:2);
END.

karakterekkel végzett mûveletek

            konvertálás nagybetûre; például
                 o UpCase('a') (TP; értéke 'A'; csak az angol ábécé betûire mûködik jól)
                 o Character.toUpperCase('a') (J; értéke 'A'; elvileg minden Unicode karakterre mûködik)
                             Character.isUpperCase('A') (J; megvizsgálja, hogy 'A' nagybetû-e, tehát értéke true)
            konvertálás kisbetûre; például
                 o példa: LowCase() függvény deklarálása (Turbo Pascal)
                 o Character.toLowerCase('A') (J; értéke 'a'; elvileg minden Unicode karakterre mûködik)
                             Character.isLowerCase('A') (J; megvizsgálja, hogy 'A' kisbetû-e, tehát értéke false)


példa: LowCase() függvény deklarálása (Turbo Pascal)
program Kisbetuk;
uses crt;
function LowCase(c:char):char;
var i:integer;
begin
i:=ord(c);
if ('A'<=c) and (c<='Z') then i:=i-ord('A')+ord('a');
LowCase:=chr(i);
end;
var ch:char;
BEGIN
clrscr;
writeln('Nyomjon le egy nagybetût!');
ch:=readkey;
writeln('A lenyomott betunek (',ch,') megfelelo kisbetu: ',LowCase(ch));
END.

                                                                                                                     Boda István, 2003 november 18.
karakterláncokon végzett mûveletek

      karakterláncok ábrázolása
      karakterláncok összefûzése ("konkatenációja")
      karakterlánc hosszának lekérdezése
      karakterláncok összehasonlítása
      karakterláncok rendezése (külön fájlban!)
      karakterlánc egy adott karakterének lekérdezése
      részláncokon végezhetõ mûveletek
           o karakterlánc részláncának képzése
           o karakterlánc részláncának keresése
      karakterláncokon végezhetõ további mûveletek

Végezetül tekintsük át a karakterláncokon végezhetõ fontosabb mûveleteket, eljárásokat és függvényeket egy
táblázatban.


karakterláncok ábrázolása
megvalósítás:
(1) a karakterláncok vagy stringek karaktereit mindkét osztály egy private char value[];
karaktertömbben tárolja;
(2) a karakterek számát az osztályok egy private int count; mezõben tartják nyilván, amely megfelel a
karakterlánc hosszának, és nem feltétlenül azonos a tömb hosszával.

      String osztály (ebben az osztályban a karakterláncok karaktereit tároló tömb mérete és tartalma nem
       változtatható, vagyis a String osztály konstans stringek tárolására alkalmas; értékadáskor rendszerint
       egy új karaktertömb jön létre új tartalommal, a nem használt memóriaterületet pedig a Java un.
       szemétgyûjtõ algoritmusa felszabadítja)
           o konstans stringek létrehozása
                    String s=new String(); (üres string létrehozása, amely megfelel az s=""; értékadásnak;
                       egy 0 elemszámmal rendelkezõ 0 hosszúságú karaktertömb létrehozását jelenti)
                    String s=new String("alma"); (megadott tartalommal rendelkezõ string létrehozása,
                       amely megfelel az s="alma"; értékadásnak; a példa egy 4 elemszámmal rendelkezõ, 4
                       karakter hosszú karaktertömb létrehozását jelenti)
           o más típusok konstans stringgé konvertálása (részletesebben lásd a konverziós függvények
               alkalmazása címszónál)
                    elemi típusokra pl. String.valueOf(4) módon (a függvény értéke "4" lesz)
                    osztálytípusokra pl. obj.toString(); módon (ahol obj egy tetszõleges osztálytípus egy
                       példánya)
           o konstans stringek konvertálása más típusokká (részletesebben lásd a konverziós függvények
               alkalmazása címszónál)
                    elemi típusokra a megfelelõ csomagoló osztály konverziós függvényével, pl.
                       Integer.parseInt("3") módon (a függvény értéke 3 lesz)
                    elemi típusok csomagoló osztályaira az adott csomagoló osztály konverziós
                       függvényével, pl. Integer.valueOf("3") módon
                    egyes osztálytípusokra az adott osztály megfelelõ konstruktorfüggvényével, pl. Float
                       f=new Float("3.14"); vagy StringBuffer s=new StringBuffer("hello"); módon
      StringBuffer osztály (ebben az osztályban a karakterláncok karaktereit tároló tömb mérete, a tömb un.
       kapacitása valamivel mindig nagyobb, mint a tárolandó karakterek tényleges száma, és a tömb tartalma
       is változtatható, így a StringBuffer osztály változó tartalmú stringek tárolására alkalmas; egy
       értékadáskor csak akkor jön létre egy új karaktertömb az új tartalommal, ha a string bõvülésére
       fenntartott szabad tömbkapacitás nem elegendõ az új karakterek tárolására)
          o   változó stringek létrehozása
                   StringBuffer s=new StringBuffer(); (üres változó string létrehozása; egy 0
                     elemszámmal rendelkezõ 16 karakter hosszúságú karaktertömb létrehozását jelenti)
                   StringBuffer s=new StringBuffer(255); (üres változó string létrehozása; egy 0
                     elemszámmal rendelkezõ 255 karakter hosszúságú karaktertömb létrehozását jelenti)
                   StringBuffer s=new StringBuffer("alma"); (megadott tartalommal rendelkezõ változó
                     string létrehozása; a példa egy 4 elemszámmal rendelkezõ, 4+16=20 karakter hosszú
                     karaktertömb létrehozását jelenti)
          o   konstans stringek változó stringgé konvertálása
                   kezdõértékadáskor a konstruktorfüggvénnyel, pl. StringBuffer s=new
                     StringBuffer("alma"); módon
                   hozzáfûzéskor az append() metódussal, pl. s.append("fa"); módon (ha s.toString()
                     értéke "alma" volt, a hozzáfûzés után "almafa" lesz)
                            megjegyzés: az append() metódus aktuális paramétereként nemcsak konstans string, hanem
                             bármilyen típusú (elemi) érték megadható
          o   változó stringek konstans stringgé konvertálása
                   a toString() metódussal, pl. s.toString() módon
                   a String osztály megfelelõ konstruktorfüggvényének hívásával, pl. StringBuffer
                     sb=new StringBuffer("Hello"); esetén a String s=new String(sb); utasítás után az s
                     változó értéke "Hello" lesz

megjegyzés: a Java a String típusú értékekre alkalmazható + konkatenációs mûveletet a StringBuffer osztály
segítségével valósítja meg; pl. az s ="alma"+"fa"; értékadás megfelel az
s=new StringBuffer().append("alma").append("fa").toString(); értékadásnak

Tipp: ha egy program a következõ fázisokat tartalmazza: (1) beolvasunk egy karakterláncot, majd (2)
változtatjuk a tartalmát, és (3) miután megkaptuk a karakterlánc "végleges" tartalmát, kiiratjuk (vagy olyan
mûveleteket végzünk rajta, amelyek csak konstans stringekre alkalmazhatóak, pl. konvertáljuk valamilyen
elemi típusra), a következõképpen célszerû eljárnunk:

   1. a beolvasást konstans stringekre végezzük
   2. alakítsuk át a konstans stringeket változó stringekké, és végezzük el a megfelelõ módosító mûveleteket
      (a StringBuffer osztály erre jóval több és hatékonyabb lehetõséget kínál!)
   3. alakítsuk vissza a változó stringeket konstans stringekké.


karakterláncok összefûzése ("konkatenációja"); például

      'Buda'+'pest' (TP; értéke 'Budapest' lesz)
      "Buda"+"pest" (J; értéke "Budapest" lesz)
      s.append("pest"); (J; ellentétben az eddigi legtöbb metódussal, append() metódus eljárásként (is)
       használható; ha a StringBuffer típusú s nevû változó értéke "Buda", akkor az eljárás végrehajtása után
       s értéke megváltozik, és "Budapest" lesz)
           o megjegyzés: az append() eljárás aktuális paramétereként nemcsak karakterlánc, hanem
               gyakorlatilag bármilyen típusú (elemi) érték vagy változó megadható


karakterlánc hosszának lekérdezése; például

      Length(s) (TP; ha a string típusú s nevû változó értéke 'abc', akkor értéke 3)
           o Ord(s[0]) (TP; a string típusú s nevû változó hosszát a változó nulladik karaktere tartalmazza
              karakter típusú változóként, azaz a nulladik karakter kódja adja a string hosszát, lásd egyszerû
              adattípusok)
      s.length() (J; ha a String vagy StringBuffer típusú s nevû változó értéke "abc", akkor értéke 3)
karakterláncok összehasonlítása; például

      s < t (TP; ha pl. s = 'Buda' és t = 'Budapest' vagy t = 'Firenze', akkor értéke True)
      s = 'Budapest' (TP; ha s = 'Budapest', akkor értéke True, egyébként False)
      s.compareTo("Buda") (J; egyfajta "lexikografikus különséget" számít ki a String típusú s nevû változó
       aktuális értéke és a zárójelekben megadott karakterlánc között; ha s értéke "nagyobb", mint a
       paraméterben megadott karakterlánc, a különbség pozitív, ha megegyeznek, akkor 0, egyébként a
       különbség negatív)
            o az s.compareTo() függvény által visszaadott értékek
            o példa: min() és max() függvények definiálása String típusú paraméterekkel
      s.equals("Debrecen") (J; ha a String típusú s nevû változó értéke "Debrecen", akkor értéke true,
       egyébként false; megjegyzés: az equals() függvény használható ugyan StringBuffer típusú változókra
       is, de ilyenkor csak formális egyezéskor ad vissza true értéket (tehát pl. s.equals(s) esetén), így sok
       gyakorlati haszna nincs)
            o s.equalsIgnoreCase("Debrecen") (J; ha a String típusú s nevû változó értéke kis- vagy
                nagybetûkkel írva "Debrecen", pl. "DEBRECEN", akkor értéke true, egyébként false)
      s.startsWith("Buda") (J; ha a String típusú s nevû változó értéke "Buda"-val kezdõdik, pl. "Budapest",
       akkor értéke true, egyébként false)
      s.endsWith("pest") (J; ha a String típusú s nevû változó értéke "pest"-re végzõdik, pl. "Budapest",
       akkor értéke true, egyébként false)



az s.compareTo("Buda") függvény által visszaadott értékek (a String típusú, s nevû változó különbözõ értékei
mellett)

      "@Hello" esetén -2, azaz negatív (64-66)
      "Arad" esetén -1, azaz negatív (65-66)
      "Buda" esetén 0
           o "Bt" esetén -1, azaz negatív (116-117)
           o "Buta" esetén 16, azaz negatív (116-100)
           o ...
           o "Budai" esetén 1, azaz pozitív ("Buda"+1 karakter)
           o "Budapest" esetén 4, azaz pozitív ("Buda"+4 karakter)
           o "Budapesti" esetén 5, azaz pozitív ("Buda"+5 karakter)
           o ...
      "Cegled" esetén 1, azaz pozitív (67-66)
      "Debrecen" esetén 2, azaz pozitív (68-66)
      ...
      "Zahony" esetén 24, azaz pozitív (90-66), stb.)
példa: min() és max() függvények definiálása String típusú paraméterekkel
public class Parameterek {
    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) {
    String s=new String();
    String t=new String();
    String u=new String();
    if (args.length>2) {
            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 kozepso parameter: "+min(t,u));
            System.out.println("A legnagyobb parameter: "+max(t,u));
            }
    else System.out.println("Maskor adjon meg harom parancssori parametert!");
    }
}


karakterlánc egy adott karakterének lekérdezése; például

               s[1] (TP; ha a string típusú s nevû változó értéke 'alma', akkor értéke 'a', mivel az elsõ karakter indexe
                1)
               s.charAt(3) (J; ha a String vagy StringBuffer típusú s nevû változó értéke "alma", akkor értéke 'a',
                mivel az elsõ karakter indexe 0)
               példák
                    o szöveg karaktereinek kiírása szóközökkel elválasztva (Turbo Pascal)
                    o szöveg karaktereinek kiírása szóközökkel elválasztva (Java)
szöveg karaktereinek kiírása szóközökkel elválasztva (Turbo Pascal)
program Kiemel;
uses crt;
var s,t:string;
         i:integer;
BEGIN
write('Irjon valamit: '); readln(s);
t:='';
for i:=1 to length(s)-1 do
    t:=t+s[i]+' ';
t:=t+s[length(s)];
writeln(t);
END.


szöveg karaktereinek kiírása szóközökkel elválasztva (Java)
public class Kiemel {
public static String kiemel(String s) {
    StringBuffer sb=new StringBuffer();
    int i;
    for(i=0; i<s.length(); i++) {
         sb.append(s.charAt(i)).append('_');      /*az s String típusú változó minden karaktere után egy '_' karakter
beszúrása; az utasítás két utasítással is megadható a következõképpen: sb.append(s.charAt(i)); sb.append('_'); */
         }
    sb.setLength(2*s.length()-1);       /*az utolsó '_' karakter levágása*/

    return sb.toString();
    }
public static void main(String[] args) {
    if (args.length>0) {
         System.out.println(kiemel(args[0]));
         }
    else System.out.println("Maskor adjon meg egy parancssori parametert!");
    /*a program futásának eredménye itt látható*/
    }
}
karakterlánc részláncának képzése

       Copy('Debrecen - Józsa',1,8) (TP; a megadott string 8 karakter hosszú részláncát adja meg az elsõ pozíciótól kezdõden, tehát
        értéke 'Debrecen' lesz)
             o Copy('Debrecen - Józsa',12,255) (TP; a megadott string 12-ik indexpozíciótól kezdõdõ teljes részláncát adja vissza,
                 tehát értéke 'Józsa' lesz)
       s.substring(4,8) (J; a String vagy StringBuffer típusú s nevû változó 4. indexpozíciótól kezdõdõ és 8-1=7. indexpozícióban
        végzõdõ részláncát adja vissza, tehát ha s aktuális értéke "Budapest", a függvény értéke "pest" lesz; megjegyzés: a részlánc
        hosszát a megadott értékek különbsége, azaz esetünkben 8-4=4 adja; megjegyzés: ha a kezdõpozíció vagy végpozíció értéke
        nem megfelelõen van megadva, az StringIndexOutOfBoundsException kivételhez vezet)
             o s.substring(4) (J; a String vagy StringBuffer típusú s nevû változó 4-ik indexpozíciótól kezdõdõ teljes részláncát
                 adja vissza, tehát ha s aktuális értéke "Budapest", a függvény értéke "pest" lesz)




karakterlánc részláncának keresése

       Pos('al','kalap') (TP; az 'al' elsõ elõfordulásának pozícióját adja a 'kalap' stringben, tehát értéke 2 lesz)
             o Pos('e','kalap') (TP; mivel 'e' nem fordul elõ a 'kalap' stringben, értéke 0 lesz)
       s.indexOf('e') (J; az 'a' karakter elsõ elõfordulásának pozícióját adja a String típusú s nevû változóban, tehát ha s értéke pl.
        "Debrecen", a függvény értéke 1 lesz; megjegyzés: ha a keresett karakter nem fordul elõ a karakterláncban, a függvény értéke
        -1 lesz)
             o s.indexOf('e',2) (J; az 'a' karakter elsõ elõfordulásának pozícióját adja a String típusú s nevû változóban a második
                   indexpozíciójú karaktertõl kezdve, tehát ha s értéke pl. "Debrecen", a függvény értéke 4 lesz)
             o s.indexOf("rec") (J; a "rec" karakterlánc elsõ elõfordulásának pozícióját adja a String típusú s nevû változóban,
                   tehát ha s értéke pl. "Debrecen", értéke 3 lesz)
             o s.indexOf("rec",4) (J; a "rec" karakterlánc elsõ elõfordulásának pozícióját adja a String típusú s nevû változóban a
                   4. indexpozíciótól kezdve, tehát ha sértéke pl. "Debrecen", a függvény értéke -1 lesz, mivel a 4. pozítiótól kezdve
                   "rec" már nem fordul elõ a "Debrecen" karakterláncban)




karakterláncokon végezhetõ további mûveletek
megjegyzés: Java esetén az indexek értékeinek nem megfelelõ beállítása rendszerint StringIndexOutOfBoundsException
kivételhez vezet

       karakterlánc beszúrása adott pozíciótól kezdõdõen; például
            o Insert('Buda',s,1); (TP; ha az Insert eljárás meghívása elõtt a string típusú s nevû változó értéke 'pest' volt, akkor
                 az eljárás végrehajtása után s értéke 'Budapest' lesz, mivel az eljárás beszúrja a 'Buda' karakterláncot az s string elsõ
                 karaktere elé)
            o s.insert(0,"Buda"); (J; ha az insert() eljárás meghívása elõtt a StringBuffer típusú s nevû változó értéke "pest"
                 volt, akkor az eljárás végrehajtása után s értéke "Budapest" lesz, mivel az eljárás beszúrja a "Buda" karakterláncot
                 az s string elsõ (0 indexû) karaktere elé; megjegyzés: az insert() eljárás második paramétereként gyakorlatilag
                 bármilyen típusú érték vagy változó megadható)
       karakterlánc törlése adott pozíciótól kezdõdõen; például
            o Delete(s,5,4); (TP; ha a Delete eljárás meghívása elõtt a string típusú s nevû változó értéke 'Budapest' volt, akkor
                 az eljárás végrehajtása után s értéke 'Buda' lesz, mivel az eljárás az 5. pozíciótól kezdõdõen kivág az s stringbõl 4
                 karaktert)
            o s[0]:=#4; (TP; ha az értékadás végrehajtása elõtt a string típusú s nevû változó értéke 'Budapest' volt, akkor az
                 eljárás végrehajtása után s értéke 'Buda' lesz, mivel az eljárás beállítja a karakterlánc hosszát 4 karakterre)
            o s.delete(4,8); (J; ha a delete() eljárás meghívása elõtt a StringBuffer típusú s nevû változó értéke "Budapest" volt,
                 akkor az eljárás végrehajtása után s értéke "Buda" lesz, mivel az eljárás az 4. pozíciótól a 8-1=7. pozícióig (itt: a
                 karakterlánc végéig) kivág az s karakterláncból 8-4=4 karaktert)
            o s.deleteCharAt(6); (J; ha a deleteCharAt() eljárás meghívása elõtt a StringBuffer típusú s nevû változó értéke
                 "Budapest" volt, akkor az eljárás végrehajtása után s értéke "Budapet" lesz, mivel az eljárás a 6. pozícióban levõ
                 karaktert (itt: 's') kivágja az s karakterláncból)
            o s.setLength(4); (J; ha a setLength() eljárás meghívása elõtt a StringBuffer típusú s nevû változó értéke
                 "Budapest" volt, akkor az eljárás végrehajtása után s értéke "Buda" lesz, mivel az eljárás beállítja a karakterlánc
                 hosszát 4 karakterre)
       karakterlánc karaktereinek kicserélése; például
            o s.replace(4,8,"var") (J; ha a replace() eljárás meghívása elõtt a StringBuffer típusú s nevû változó értéke
                 "Budapest" volt, akkor az eljárás végrehajtása után s értéke "Budavar" lesz, mivel az eljárás az 4. pozíciótól a 8-
                 1=7. pozícióig (itt: a karakterlánc végéig) tartó 8-4=4 hosszú részláncot kicseréli a "var" karakterláncra)
             o  s.setCharAt(4,'P') (J; ha a setCharAt() eljárás meghívása elõtt a StringBuffer típusú s nevû változó értéke
                "Budapest" volt, akkor az eljárás végrehajtása után s értéke "BudaPest" lesz, mivel az eljárás az 4. pozícióban levõ
                karaktert (itt: 'p') kicseréli a 'P' karakterre)
           o s.replace('a','A') (J; az 'a' karakter minden elõfordulását 'A'-ra cseréli, tehát ha pl. a String típusú s nevû változó
                értéke "kalap", akkor a függvény értéke "kAlAp" lesz)
           o s.toLowerCase() (J; a String típusú s nevû változó karaktereit kisbetûre konvertálja, tehát ha s értéke "KALAP",
                akkor a függvény értéke "kalap" lesz)
           o s.toUpperCase() (J; a String típusús nevû változó karaktereit nagybetûre konvertálja, tehát ha s értéke "kalap",
                akkor a függvény értéke "KALAP" lesz)
      szóközök (és sorvége karakterek, tabulátorok, stb., azaz un. elválasztó, angolul white space karakterek) levágása egy
       karakterlánc elejérõl és végérõl; például
           o s.trim() (J; ha a String típusú s nevû változó értéke " kalap ", akkor a függvény értéke "kalap" lesz)




Áttekintõ táblázat


Funkció                                        String                                          StringBuffer
összefûzés                                     +                                               StringBuffer append(...)
hossz lekérdezése                              int length()                                    int length()
karakter lekérdezése                           char charAt(...)                                char charAt(...)
összehasonlítás (<,=,>)                        int compareTo(...)
                                               boolean equals(...)
összehasonlítás (=)
                                               boolean equalsIgnoreCase(...)
                                               boolean startsWith(...)
részlánc összehasonlítása (=)
                                               boolean endsWith(...)
részlánc képzése                               String substring(...)                           String substring(...)
karakter vagy részlánc keresése                int indexOf(...)

beszúrás                                                                                       StringBuffer insert(...)

részlánc törlése                                                                               StringBuffer delete(...)

hossz beállítása                                                                               void setLength(...)

részlánc cseréje                                                                               StringBuffer replace(...)

karakter cseréje                                                                               void setCharAt(...)

karakterek cseréje                             String replace(...)
                                               String toLowerCase()
kis- és nagybetûk cseréje
                                               String toUpperCase()
szóközök levágása                              String trim()
                                                                            lila szín: mûvelet
                                                                                               kék szín: eljárás
                                                                          zöld szín: függvény
                   karakterláncokon végezhetõ fontosabb mûveletek, eljárások és függvények

                                                                                                     Boda István, 2003 november 18.
vezérlési szerkezetek

A programok végrehajtása során a következõ végrehajtandó utasítás kiválasztása többféleképpen történhet:

      az utasításokat rendszerint egymás után, szekvenciálisan hajtjuk végre; ekkor a következõ végrehajtandó
       utasítás mindig a korábban végrehajtott utasítás után közvetlenül következõ utasítás lesz (tehát az,
       amely a programszövegben a korábban végrehajtott utasítás után következik)
      a szekvenciális végrehajtási sorrendet az utasítások végrehajtása során kapott részeredményektõl
       függõen vezérlésátadással megváltoztathatjuk; ekkor a következõ végrehajtandó utasítást a
       vezérlésátadás típusa (és feltétele) határozza meg
      Java esetén a kivételek kezelését megvalósító szerkezet szintén vezérlésátadást valósít meg a try
       blokkban elõforduló kivétel (pl. hiba) esetén a kivételnek megfelelõ catch blokkra
      alprogramok esetén egy utasítással (ti. az alprogramot meghívó utasítással) az utasítások egy "kötegbe
       fogott" (és névvel ellátott) csoportjára egyszerre hivatkozunk; ilyenkor a következõ végrehajtandó
       utasítás az alprogram definíciójában szereplõ elsõ utasítás lesz, és az alprogramot hívó utasítás után
       következõ utasítás csak az alprogram visszatérése után hajtódik végre.

A vezérlésátadás néhány esetben igényli, hogy egyes utasításokat megjelöljünk a programszövegben. Ehhez a
programozási nyelvekben rendszerint un. címkéket használunk, amelyeket közvetlenül a megjelölendõ
utasítások elõtt kell elhelyeznünk.
A vezérlésátadás lehetséges típusai, példákon keresztül:

      feltétel nélküli vezérlésátadás, ugrás
      feltételes elágazás vagy elágaztatás (szelekció)
           o egyirányú elágazás
           o kétirányú elágazás
           o többirányú elágazás
      iteráció vagy ciklus
           o elöltesztelõ ciklus
                     tipikus hiba ciklus szervezésekor (Turbo Pascal)
           o hátultesztelõ ciklus
           o rögzített lépésszámú ciklus
      ugrás a ciklusfeltételre
      kilépés egy programblokkból
           o kilépés egy ciklusból
           o kilépés egy alprogramból
           o kilépés a programból
      kivételek kezelése (Java)
           o kivételek kiváltása
           o saját kivételek kiváltása
      függvények hívása
           o másodfokú egyenlet megoldása
      eljárások hívása
           o másodfokú egyenlet megoldása
           o eljárások hívása esetszétválasztással (Turbo Pascal)
feltétel nélküli vezérlésátadás (használata a legtöbb programozási nyelvben nem javasolt; a Turbo Pascal nyelvben
megvalósították, a Java nyelvben viszont ilyen utasítás egyáltalán nincs)
program ugras;
uses crt;
label vege; {a vege nevû címke deklarálása}
var i,utolso:integer;
BEGIN
clrscr;
write('Legnagyobb kiiratando szam: ');readln(utolso);
for i:=1 to 20 do begin
  if i>utolso then goto vege; {ha az i ciklusváltozó értéke nagyobb, mint az általunk megadott utolso szám,
ugrás a vege címkére (figyeljük meg, hogy ezzel kilépünk a ciklusból!)}
  writeln(i);
  end;
vege: {annak a pontnak az azonosítása a programszövegben, ahol a végrehajtás folytatódni fog egy goto
vege; ugrás végrehajtása után; figyeljük meg, hogy a vege: címke (=címkenév és kettõspont) az utána
következõ (esetünkben writeln(...);) utasítást jelöli ki}
writeln('Kiiratas vege');
{a program végrehajtásának eredménye itt látható}
END.


egyirányú elágazás (egy jó nagy szám kiíratása)
program elagazas1;
uses crt;
const marNagy=23;
var i:integer;
BEGIN
clrscr;
write('Adjon meg egy nagy szamot: ');readln(i);
if i<marNagy then begin
  i:=MaxInt; {a Turbo Pascalban a MaxInt konstans adja meg a legnagyobb integer típusú értéket; ebben a
programban kis szám megadása esetén ez lesz az i változó alapértelmezett értéke}
  writeln('(alapertelmezett ertek hasznalata)');
  end;
writeln('A szam erteke: ',i);
END.
public class Elagazas1 {
public static int MAR_NAGY=23;
public static void main(String[] args) {
int i=Integer.parseInt(args[0]);
if (i<MAR_NAGY) {
    i=Integer.MAX_VALUE;          /*a Javaban az Integer csomagoló osztályban definiált MAX_VALUE konstans adja meg a
legnagyobb int típusú értéket; ebben a programban kis szám megadása esetén ez lesz az i változó alapértelmezett értéke*/
    System.out.println("(alapertelmezett ertek hasznalata)");
    }
System.out.println("A szam erteke: "+i);
}
/*a program futásának eredménye itt látható*/

}


kétirányú elágazás (két megadott szám kiíratása nagyság szerint)
program elagazas2;
uses crt;
var i1,i2:integer;
BEGIN
clrscr;
write('Elso szam: ');readln(i1);
write('Masodik szam: ');readln(i2);
if i1<i2 then begin
            writeln('A kisebbik szam: ',i1);
            writeln('A nagyobbik szam: ',i2);
          end
         else begin
           writeln('A kisebbik szam: ',i2);
            writeln('A nagyobbik szam: ',i1);
          end;
END.
public class Elagazas2 {
public static void main(String[] args) {
int i1=Integer.parseInt(args[0]);
int i2=Integer.parseInt(args[1]);
if (i1<i2) {
    System.out.println("A kisebbik szam: "+i1);
    System.out.println("A nagyobbik szam: "+i2);
    }
else {
    System.out.println("A kisebbik szam: "+i2);
    System.out.println("A nagyobbik szam: "+i1);
    }
}
}
többirányú elágazás (egy érdemjegy kiírása szöveges formában)
program elagazas3;
uses crt;
var i:integer;
BEGIN
clrscr;
write('Adja meg a programozas jegyet: ');readln(i);
write('A jegy erteke: ');
case i of {a case szerkezet un. szelektorának (itt: i) aktuális értéke határozza meg, melyik utasítás fog
végrehajtódni a többirányú elágazás során; a szelektor nemcsak változó, hanem tetszõleges sorszámozott
típusú kifejezés lehet}
    1: writeln('elegtelen'); {ha i=1, ez az utasítás fog végrehajtódni}
    2: writeln('elegseges'); {ha i=2, ez az utasítás fog végrehajtódni}
    3: writeln('kozepes'); {ha i=3, ez az utasítás fog végrehajtódni}
    4: writeln('jo'); {ha i=4, ez az utasítás fog végrehajtódni}
    5: writeln('jeles'); {ha i=5, ez az utasítás fog végrehajtódni}
    6..MaxInt: writeln('ez tul szep, hogy igaz legyen...'); {ha i értéke 6 és MaxInt (=32767) közé esik, ez az
utasítás fog végrehajtódni}
    else writeln('nem ertelmezheto'); {minden más esetben ez az utasítás fog végrehajtódni}
    end;
END.
public class Elagazas3 {
public static void main(String[] args) {
int i=Integer.parseInt(args[0]);
System.out.print("A jegy erteke: ");
switch(i) {    /*a switch szerkezet un. szelektorának (itt: i) aktuális értéke határozza meg, melyik utasítás fog végrehajtódni a
többirányú elágazás során; a szelektor nemcsak változó, hanem tetszõleges int típuskompatibilis kifejezés lehet*/
    case 1:System.out.println("elegtelen");break; /*ha i==1, ez az utasítás fog végrehajtódni*/
    case 2:System.out.println("elegseges");break; /*ha i==2, ez az utasítás fog végrehajtódni*/
    case 3:System.out.println("kozepes");break; /*ha i==3, ez az utasítás fog végrehajtódni*/
    case 4:System.out.println("jo");break; /*ha i==4, ez az utasítás fog végrehajtódni*/
    case 5:System.out.println("jeles");break; /*ha i==5, ez az utasítás fog végrehajtódni*/
    default:System.out.println("nem ertelmezheto");              /*minden más esetben ez az utasítás fog végrehajtódni*/

    }
}
}
elöltesztelõ ciklus (számok négyzetének kiíratása)
program eloltesztelo;
uses crt;
var i,n:integer;
BEGIN
clrscr;
write('Kerek egy egesz szamot: ');readln(n);
writeln('SZAM':20,'SZAM NEGYZETE':20);
i:=1; {ciklusváltozó kezdeti értékének beállítása; mindig a ciklusmagon kívül történik!}
while i<=n do {elöltesztelõ ciklus: a ciklusfeltétel kiértékelése a ciklusmag végrehajtása elõtt történik
meg; ha a ciklusfeltétel igaz, a ciklusmag (újra) végrehajtódik, ha pedig hamis, a program
végrehajtása a ciklus után következõ utasítással folytatódik (a ciklusfeltétel tehát az elõltesztelõ
ciklusban un. bentmaradási feltétel)}
       begin {ciklusmag kezdete}
       writeln(i:20,sqr(i):20);
       inc(i); {ciklusváltozó értékének növelése}
       end; {ciklusmag vége}
{a program végrehajtásának eredménye itt látható}
END.
public class Eloltesztelo {
public static String hosszBeallit(String s,int hossz) {
/*erre a metódusra azért van szükség, hogy a System.out.println() kiíró metódusban adott hosszon (hossz) tudjuk kiírni az
egyes String típusú változók vagy konstansok (s) értékét*/
   int i;
   StringBuffer s1=new StringBuffer(hossz); /*s1 "kapacitása" (ti. a benne tárolható karakterek száma) hossz
lesz*/
   for(i=s.length();i<hossz;i++) {
         s1.append(" "); /*feltöltés szóközökkel*/
         }
   return s1.append(s).toString();
   }
public static String hosszBeallit(int i,int hossz) {
/*erre a metódusra pedig azért van szükség, hogy a System.out.println() kiíró metódusban adott hosszon (hossz) tudjuk
kiírni az egyes int típusú változók vagy konstansok (i) értékét*/
   return hosszBeallit(String.valueOf(i),hossz);
   }
public static void main(String[] args) {
int i,n;
n=Integer.parseInt(args[0]);
System.out.println(hosszBeallit("SZAM",20)+hosszBeallit("SZAM NEGYZETE",20));
i=1;      /*ciklusváltozó kezdeti értékének beállítása; mindig a ciklusmagon kívül történik!*/

while(i<=n) { /*elöltesztelõ ciklus: a ciklusfeltétel kiértékelése a ciklusmag végrehajtása elõtt történik meg; ha a
ciklusfeltétel igaz, a ciklusmag (újra) végrehajtódik, ha pedig hamis, a program végrehajtása a ciklus után következõ
utasítással folytatódik (a ciklusfeltétel tehát az elõltesztelõ ciklusban un. bentmaradási feltétel); a ciklusmag kezdetét a {
nyitó, végét pedig a } záró kapcsos zárójel jelzi*/
    System.out.println(hosszBeallit(i,20)+hosszBeallit(i*i,20));
    i++;     /*ciklusváltozó értékének növelése*/

    } /*ciklusmag vége*/
/*a program végrehajtásának eredménye itt látható*/

}
}

tipikus hiba ciklus szervezésekor (Turbo Pascal)
program hibas_eloltesztelo;
uses crt;
var i,n:integer;
BEGIN
clrscr;
write('Kerek egy egesz szamot: ');readln(n);
writeln('SZAM':20,'SZAM NEGYZETE':20);
while i<=n do {ciklusfeltétel: ha n>=1, sosem lesz hamis (azaz sosem fogunk kilépni a ciklusból), mivel a
ciklusmagban állandóan visszaállítjuk i értékét 1-re}
     begin {ciklusmag kezdete}
     i:=1; {az i ciklusváltozó kezdeti értékének HIBÁS beállítása; végtelen ciklushoz vezet!}
     writeln(i:20,sqr(i):20);
     inc(i); {ciklusváltozó értékének növelése; naív dolog, hiszen a ciklusmag következõ végrehajtása során
úgyis visszaáll 1-re...}
     end;
{a program végrehajtásának eredménye itt látható}
END.
megjegyzés: ha mégis elkövettük a fenti hibát, a következõképpen tudunk visszalépni a Turbo Pascal
szövegszerkesztõjébe:

          lenyomjuk a CTRL Break billentyûkombinációt (a Pause/Break gomb általában a billentyûzet felsõ sorának jobb
           szélén, a Scroll Lock billentyû után található)
               o a megszakítás hatására egy hibaüzenetet kapunk
          Enter hatására a Turbo Pascal automatikusan lépésenkénti utasításvégrehajtás üzemmódba kapcsol, amit egy kék
           színû inverz kurzor jelez
          kilépünk a lépésenkénti végrehajtás üzemmódjából a CTRL F2 billentyûkombinációval
          javítjuk a hibát...
hátultesztelõ ciklus (számok négyzetének kiíratása)
program hatultesztelo;
uses crt;
var i,n:integer;
BEGIN
clrscr;
write('Kerek egy egesz szamot: ');readln(n);
writeln('SZAM':20,'SZAM NEGYZETE':20);
i:=1; {ciklusváltozó kezdeti értékének beállítása; mindig a ciklusmagon kívül történik!}
repeat {hátultesztelõ ciklus: a ciklusfeltétel kiértékelése a ciklusmag végrehajtása után történik majd meg (until
után), ennek következtében a ciklusmag egyszer mindenképpen le fog futni; figyeljük meg, hogy a
hátultesztelõ ciklusban ciklusmagot nem szükséges a begin és end kulcsszavak közé zárni, mivel a ciklusmag
kezdetét a ciklus repeat tagja, a ciklusmag végét pedig a ciklus until zárótagja egyértelmûen jelzi}
writeln(i:20,sqr(i):20);
inc(i); {ciklusváltozó értékének növelése}
until i>n; {ha a ciklusfeltétel igaz, a program végrehajtása a ciklus után következõ utasítással folytatódik, ha
pedig hamis, a ciklusmag újra végrehajtódik (a ciklusfeltétel tehát a Turbo Pascal hátultesztelõ ciklusában un.
kilépési feltétel)}
{a program végrehajtásának eredménye itt látható}
END.
public class Hatultesztelo {
public static void main(String[] args) {
int i,n;
n=Integer.parseInt(args[0]);
System.out.println(Eloltesztelo.hosszBeallit("SZAM",20)+Eloltesztelo.hosszBeallit("SZAM NEGYZETE",20));
i=1;       /*ciklusváltozó kezdeti értékének beállítása; mindig a ciklusmagon kívül történik!*/

do { /*hátultesztelõ ciklus: a ciklusfeltétel kiértékelése a ciklusmag végrehajtása után történik majd meg (a } záró kapcsos zárójel
után), ennek következtében a ciklusmag egyszer mindenképpen le fog futni; a ciklusmag kezdetét a { nyitó, végét a } záró kapcsos
zárójel jelzi*/
    System.out.println(Eloltesztelo.hosszBeallit(i,20)+Eloltesztelo.hosszBeallit(i*i,20));
    i++;      /*ciklusváltozó értékének növelése*/

    }while(i<=n); /*ha a ciklusfeltétel hamis, a program végrehajtása a ciklus után következõ utasítással folytatódik, ha pedig igaz, a
ciklusmag újra végrehajtódik (a ciklusfeltétel tehát a Java hátultesztelõ ciklusában ugyanúgy bentmaradási feltétel, mint az elöltesztelõ
ciklusban); a ciklusmag végét a } záró kapcsos zárójel jelzi*/
}
}
rögzített lépésszámú ciklus (számok négyzetének kiíratása növekvõ, ill. csökkenõ sorrendben)
program rogzitett1;
uses crt;
var i,n:integer;
BEGIN
clrscr;
write('Kerek egy egesz szamot: ');readln(n);
writeln('SZAM':20,'SZAM NEGYZETE':20);
for i:=1 to n do {a rögzített lépésszámú ciklus un. ciklusfeje: a rögzített lépésszámú ciklus egy olyan
elöltesztelõ ciklus, amelyben
(1) a for kulcsszó után egy sorszámozott (pl. integer, char, stb.) típusú ciklusváltozót deklarálunk (ez
esetünkben i),
(2) a ciklusmag elsõ végrehajtása elõtt automatikusan egy kezdõértékadás hajtódik végre (ez
esetünkben i:=1; ),
(3) a bentmaradási feltétel ciklusváltozó<=végérték, amely mindig a ciklusmag végrehajtása elõtt
értékelõdik ki; a végérték (itt: n) tetszõleges kifejezés lehet, amelynek típusa kompatibilis a
ciklusváltozó típusával; a végértéket a ciklusfejben a to kulcsszó után adjuk meg (tehát a
bentmaradási feltétel esetünkben i<=n),
(4) a ciklusmag végrehajtása után automatikusan megtörténik a ciklusváltozó növelése eggyel (ez
esetünkben az i:=i+1; értékadásnak felel meg).
Megjegyzés: a Turbo Pascal a ciklusmag utolsó végrehajtása után már nem növeli meg a
ciklusváltozó értékét, így ha a ciklusmag legalább egyszer lefutott, a ciklusból való kilépés után a
ciklusváltozó értéke a végértékkel fog megegyezni}
  begin {ciklusmag kezdete}
  writeln(i:20,sqr(i):20);
  end; {ciklusmag vége}
END.
program rogzitett2;
uses crt;
var i,n:integer;
BEGIN
clrscr;
write('Kerek egy egesz szamot: ');readln(n);
writeln('SZAM':20,'SZAM NEGYZETE':20);
for i:=n downto 1 do {az elõzõ példához képest a különbségek:
(1) a ciklusfejben to helyett downto szerepel,
(2) a kezdõértékadás itt i:=n; ,
(3) a bentmaradási feltétel most ciklusváltozó>=végérték ; a végérték esetünkben 1, tehát a
bentmaradási feltétel i>=1,
(4) a ciklusmag végrehajtása után automatikusan megtörténik a ciklusváltozó csökkentése eggyel (ez
esetünkben az i:=i-1; értékadásnak felel meg).}
    begin {ciklusmag kezdete}
    writeln(i:20,sqr(i):20);
    end; {ciklusmag vége}
{a program végrehajtásának eredménye itt látható}
END.
public class Rogzitett {
public static void main(String[] args) {
int i,n;
n=Integer.parseInt(args[0]);
System.out.println(Eloltesztelo.hosszBeallit("SZAM",20)+Eloltesztelo.hosszBeallit("SZAM
NEGYZETE",20));
for(i=1;i<=n;i++) {
/*a rögzített lépésszámú ciklus Java nyelvû megfelelõjének un. ciklusfeje: ez egy olyan elöltesztelõ ciklus, amelyben
(1) a for kulcsszó után egy, a ciklusmag elsõ végrehajtása elõtt végrehajtandó utasítást adunk meg, amely általában egy
(tetszõleges típusú) ciklusváltozó kezdõértékét állítja be (esetünkben ez i=1; ),
(2) ezután egy bentmaradási feltételt adunk meg, amely mindig a ciklusmag végrehajtása elõtt értékelõdik ki, és a
ciklusmag csak akkor kerül végrehajtásra, ha a bentmaradási feltétel igaz; hamis érték esetén kilépünk a ciklusból
(esetünkben a bentmaradási feltétel i<=n),
(3) végül pedig egy, a ciklusmag minden végrehajtása után (automatikusan) végrehajtandó utasítást adunk meg, amely
lehet pl. a ciklusváltozó növelése egy adott értékkel (esetünkben ez az utasítás az i:=i+1; értékadásnak felel meg).
Megjegyzés: ezt az utasítást akár el is hagyhatjuk, de ebben az esetben nekünk kell a ciklusmagban "manuálisan"
megadnunk a szükséges utasításokat (pl. a ciklusváltozó növelését) */
    System.out.println(Eloltesztelo.hosszBeallit(i,20)+Eloltesztelo.hosszBeallit(i*i,20));
    }
for(i=n-1;i>=1;i--) {
    System.out.println(Eloltesztelo.hosszBeallit(i,20)+Eloltesztelo.hosszBeallit(i*i,20));
    }
/*a program végrehajtásának eredménye itt látható*/

}
}
ugrás a ciklusfeltételre (Turbo Pascal)
program Lotto1;
uses crt;
var x:array [1..5] of integer;
function general:integer;
   begin
   general:=trunc(random*90)+1; { egy véletlen egész szám generálása az [1,90] intervallumból}
   end;
procedure kihuz;
   var i,j:integer;
        b:array [1..90] of Boolean;
   begin
   for i:=1 to 90 do b[i]:=false;
   i:=1;
   while i<=5 do begin
        j:=general;
        if b[j] then continue; {már volt ilyen j szám korábban (mivel b[j]=true), ezért ugrás a közvetlenül a ciklusfeltételre, a
ciklusmag hátralevõ részének figyelmen kívül hagyásával}
        b[j]:=true; {azok a j számok lesznek kiválasztva, amelyekre b[j]=true teljesül}
        inc(i);
        end;
   j:=1;
   for i:=1 to 90 do begin
        if b[i]=true then begin
           x[j]:=i; {a kiválasztott szám eltárolása az x tömbben}
           inc(j);
           end;
        end;
   end;
procedure kiir;
   var i:integer;
   begin
   for i:=1 to 5 do writeln('A(z) ',i,'. lottoszam: ',x[i]:2);
   end;
BEGIN
clrscr;
randomize;
kihuz;
kiir;
END.
A Turbo Pascal programnak megfelelõ Java programot már tárgyaltuk: a LottoSzamok java program forráskódja itt
található.
kilépés egy ciklusból (jegyek átlagának kiszámítása)
program atlag;
uses crt;
const n:integer=20; {legfeljebb 20 jegy átlagát számítjuk majd ki}
var i,j,s:integer;
BEGIN
clrscr;
i:=0;
s:=0;
repeat
inc(i); {számoljuk, eddig hány jegyet írtunk be}
write('Kerem az',i,'. jegyet: ');readln(j);
if (j<1) or (j>5) then begin {ha jegy helyett pl. 0-t írunk be, azt a program a beírás befejezéseként értelmezi}
    n:=i-1; {eddig i-1 darab jegyet írtunk be, ezzel felülírjuk n értékét}
    break; {ezzel kilépünk a ciklusból, a program végrehajtása a ciklus után következõ utasításon fog folytatódni }
    end;
s:=s+j; {az eddig beírt jegyek összegéhez hozzáadjuk a most beírt jegyet}
until i>=n; {n(=20) jegy beírása után mindenképpen kilépünk a ciklusból}
writeln('A jegyek atlaga: ',s/n:3:2);
END.
public class Atlag {
public static final int N=20;
public int readln() {
    return (int)(Math.random()*7); /*egy "véletlen" egész szám generálása a [0,6] intervallumból*/
    }
public static void main(String[] args) {
int i=0,j,s=0,n=N;
Atlag a=new Atlag();
do {
    i++;
    j=a.readln();
    System.out.println("Az "+i+". jegy: "+j);
    if(j<1 || j>5) {   /*kilépés a ciklusból akkor, ha j értéke kisebb, mint 1, vagy nagyobb, mint 5*/

        n=i-1; /*a "beolvasott" jegyek száma*/
        break;
        }
    s+=j;
    } while(i<n);
System.out.println("A jegyek atlaga: "+Math.round(s*100.0/n)/100.0); /*itt nagyon vigyáznunk kell a zárójelen belüli sorrendre:
s/n*100.0 esetén s/n egészosztást jelentene!*/
/*a program futásának eredménye néhány jellemzõ esetben itt látható*/

}
}
kilépés egy alprogramból (az elsõ 20 primszám kiíratása)
program primszam;
uses crt;
var n:integer;
function prim(k:integer):Boolean;
  begin
  if k>sqrt(n) then begin
     prim:=True;
     exit; {1. kilépési pont: egy számelméleti tételbõl következik, hogy ha k értéke nagyobb, mint a
vizsgált szám (n) négyzetgyöke, már nem kell tovább vizsgálni, hogy a vizsgált számnak van-e 1-nél
nagyobb osztója; a szám ilyenkor biztosan primszám, és ezért kiléphetünk a függvénybõl, ami után a
program végrehajtása a függvény meghívása utáni utasításon fog folytatódni (amely esetünkben a
függvényt záró end; utasítás lesz)}
     end;
  if (n mod k)=0 then begin
     prim:=False;
     exit; {2. kilépési pont: ha k osztója a vizsgált számnak (n), az biztosan nem primszám; ekkor
szintén kiléphetünk a függvénybõl, és ezután a program végrehajtása a függvény meghívása utáni
utasításon fog folytatódni (amely esetünkben a függvényt záró end; utasítás lesz)}
     end;
  prim:=prim(k+1); {a program legizgalmasabb része: ha k-ra nem tudtuk eldönteni, hogy n
primszám-e vagy sem, meghívjuk a függvényt (k+1)-re, és a k+1-re visszaadott érték lesz a függvény
visszatérési értéke k-ra is; mivel a függvény önmagát hívja meg, ilyenkor rekurzív függvényhívásról
beszélünk, amely elõbb-utóbb biztosan véget ér, mivel azok az értékek, amelyekkel a függvényt
meghívjuk, folyamatosan egyre nagyobbak lesznek}
  end;
BEGIN
clrscr;
write('Kerek egy szamot: ');readln(n);
if prim(2) then writeln('a szam primszam')
            else writeln('a szam nem primszam');
END.
public class Primszam {
public int n;
public void setN(int i) {
    n=i;    /*az n mezõ értékének beállítása*/

    }
public boolean prim() {
    return _prim(2);      /*2-tõl négyzetgyök n-ig végigvizsgálja a természetes számokat, hogy valamelyik osztója-e az n
mezõ értékének*/
    }
private boolean _prim(int k) {
    if(k>Math.sqrt(n)) return true; /*n primszám*/
    if((n%k)==0) return false; /*n nem primszám*/
    return _prim(k+1);      /*k-ra nem dönthetõ el, hogy n primszám-e; vizsgáljuk meg k+1-re is*/

    }
public static void main(String[] args) {
int i,j=0,max=20;
Primszam p=new Primszam();
System.out.println("AZ ELSO 20 PRIMSZAM");
i=2;
do {
    p.setN(i);
    if(p.prim()) {
        System.out.println(i);
        j++; /*számláljuk, eddig hány primszámot írattunk ki*/
        }
    i++;
    } while(j<max);
/*a program futásának eredménye itt látható*/
}
}
kilépés a programból (kamatos kamat számítása)
program kamat;
uses crt;
var betet,kamat,ev:integer;
  i:integer;
  osszeg:real;
procedure hiba;
  begin
  writeln('Hibas adat!');
  halt; {hibás adat esetén felesleges tovább számolnunk, így kilépünk a programból}
  end;
BEGIN
clrscr;
write('Kerem a betetosszeget: ');readln(betet);
if betet<=0 then hiba;
write('Kerem a kamatlabat: ');readln(kamat);
if kamat<=0 then hiba;
write('Kerem az evek szamat: ');readln(ev);
if ev<=0 then hiba;
osszeg:=betet;
for i:=1 to ev do
  osszeg:=osszeg+osszeg*kamat/100;
writeln('A kamatos kamat osszege: ',trunc(osszeg));
END.
public class Kamat {
public int betet,kamatlab,ev;
public void setBetet(int b) { betet=b; }
public void setKamatlab(int k) { kamatlab=k; }
public void setEv(int e) { ev=e; }
public int osszeg() {
  int i;
  double x=betet;       /*valós értékekkel számolunk*/

  for(i=1;i<=ev;i++) {
      x+=x*kamatlab/100.0;
      }
  return (int)x;
  }
public static void main(String[] args) {
Kamat k=new Kamat();
try {
    k.setBetet(Integer.parseInt(args[0]));
    k.setKamatlab(Integer.parseInt(args[1]));
    k.setEv(Integer.parseInt(args[2]));
    }
catch(Exception e) {
    System.out.println("Hibas adat(ok)! " + e);
    System.exit(1);     /*hibás adat esetén felesleges tovább számolnunk, így kilépünk a programból; a zárójelek között
megadott érték az ún. kilépési kód, amely megállapodás szerint hiba esetén 0-tól különbözõ*/
    }
System.out.println("A kamatos kamat osszege: "+k.osszeg());
}
}


kivételek kiváltása (Java): kamatos kamat számítása
public class Kamat1 {
public int betet,kamatlab,ev;
public void setBetet(int b) throws Exception {            /*itt még csak azt deklaráljuk, hogy a setBetet(int) metódusban
egyes esetek kivételt fognak jelezni*/
    if (b<=0) throw new Exception("Nulla betet");           /*itt pedig kiváltjuk a kivételt és
megadjuk szövegesen a kivétel okát*/
    betet=b;
    }
public void setKamatlab(int k) throws Exception {
    if (k<=0) throw new Exception("Nulla kamat");
    kamatlab=k;
    }
public void setEv(int e) throws Exception {
    if (e<=0) throw new Exception("Nulla ev");
    ev=e;
    }
public int osszeg() {
    int i;
    double x=betet;      /*valós értékekkel számolunk*/

    for(i=1;i<=ev;i++) {
        x+=x*kamatlab/100.0;
        }
    return (int)x;
    }
public static void main(String[] args) {
Kamat1 k=new Kamat1();
try {
    k.setBetet(Integer.parseInt(args[0]));
    k.setKamatlab(Integer.parseInt(args[1]));
    k.setEv(Integer.parseInt(args[2]));
    }
catch(Exception e) {
    System.out.println("Hibas adat(ok)! " + e);
    System.exit(1);
    }
System.out.println("A kamatos kamat osszege: "+k.osszeg());
}
}


saját kivételek kiváltása (Java): kamatos kamat számítása
class NullaBetet extends Exception { } /*ha mi definiálunk kivételeket, ezeket a java.lang.Exception osztály
leszármazott osztályaként kell deklarálni*/
class NullaKamat extends Exception { }
class NullaEv extends Exception { }
public class Kamat2 {
public int betet,kamatlab,ev;
public void setBetet(int b) throws NullaBetet {
    if (b<=0) throw new NullaBetet();
    betet=b;
    }
public void setKamatlab(int k) throws NullaKamat {
    if (k<=0) throw new NullaKamat();
    kamatlab=k;
    }
public void setEv(int e) throws NullaEv {
    if (e<=0) throw new NullaEv();
    ev=e;
    }
public int osszeg() {
    int i;
    double x=betet;       /*valós értékekkel számolunk*/
    for(i=1;i<=ev;i++) {
        x+=x*kamatlab/100.0;
        }
    return (int)x;
    }
public static void main(String[] args) {
Kamat2 k=new Kamat2();
try {
    k.setBetet(Integer.parseInt(args[0]));
    k.setKamatlab(Integer.parseInt(args[1]));
    k.setEv(Integer.parseInt(args[2]));
    }
catch(NullaBetet e) {
    System.out.println("Hibas betet! " + e);
    System.exit(1);
    }
catch(NullaKamat e) {
    System.out.println("Hibas kamat! " + e);
    System.exit(2);
    }
catch(NullaEv e) {
    System.out.println("Hibas ev! " + e);
    System.exit(3);
    }
catch(Exception e) {
    System.out.println("Egyeb hiba! " + e);
    if(e instanceof NumberFormatException) {            /*az instanceof összehasonlító operátorral egy objektumpéldány osztálytípusát tudjuk
eldönteni*/
        System.out.println("Nem szamok!");
        System.exit(4);
        }
    else if(e instanceof ArrayIndexOutOfBoundsException) {
        System.out.println("Keves adat!");
        System.exit(5);
        }
    System.exit(6);       /*ismeretlen eredetû hiba*/

    }
System.out.println("A kamatos kamat osszege: "+k.osszeg());
}
}
másodfokú egyenlet megoldása (függvényhívással)
program masodfoku;
uses crt;
var a,b,c,d,x1,x2:real;
function diszkriminans:real;
  begin
  diszkriminans:=b*b-4*a*c;
  end;
BEGIN
clrscr;
writeln('Adja meg a masodfoku egyenlet egyutthatoit!');
write('a = ');readln(a);
write('b = ');readln(b);
write('c = ');readln(c);
d:=diszkriminans; {függvény hívása: a program a hívott függvény (diszkriminans) deklarációjának
elsõ utasításán (begin) folytatódik, majd a függvény értékének kiszámítása után végrehajtódik az
értékadás (a függvény értéke eltárolódik a d változóban), és a program folytatódik az értékadás után
következõ utasítással (if d<0 ...)}
if d<0 then begin
  writeln('Nincs valos gyok');
  halt;
  end;
if d=0 then begin
  x1:=-b/(2*a);
  writeln('Egy valos gyok van');
  writeln('x = ',x1:5:4);
  halt;
  end;
d:=sqrt(d);
x1:=(-b+d)/(2*a);
x2:=(-b-d)/(2*a);
writeln('Ket valos gyok van');
writeln('x1 = ',x1:5:4);
writeln('x2 = ',x2:5:4);
writeln('Ellenorzes:');
writeln('a*x1*x1 + b*x1 + c = ',a*x1*x1+b*x1+c:5:4);
writeln('a*x2*x2 + b*x2 + c = ',a*x2*x2+b*x2+c:5:4);
{a program végrehajtásának eredménye itt látható}
END.
public class MasodFv {
public double a,b,c;
public double diszkriminans() {
    return b*b-4*a*c;
    }
public double gyok() {        /*ha a diszkrimináns nulla, a két gyök egybeesik (azaz csak egy gyök van) */

    return -b/(2*a);
    }
public double gyok12(double sqrtd) {
    return (-b+sqrtd)/(2*a);      /*a függvény hívásakor a diszkrimináns (d) pozitív és negatív négyzetgyökét kell aktuális
paraméterként megadni*/
    }
public double masodfoku(double x) {
    return a*x*x+b*x+c;
    }
public static void main(String[] args) {
double a,b,c,d,x1,x2;
MasodFv m=new MasodFv();
m.a=Double.parseDouble(args[0]);
m.b=Double.parseDouble(args[1]);
m.c=Double.parseDouble(args[2]);
d=m.diszkriminans(); /*függvény hívása*/
if (d<0) {
    System.out.println("Nincs valos gyok");
    System.exit(0);
    }
if (d==0) {
    x1=x2=m.gyok();
    System.out.println("Egy valos gyok van");
    System.out.println("x = "+x1);
    System.out.println("Ellenorzes:");
    System.out.println("a*x*x + b*x + c = "+m.masodfoku(x1));
    System.exit(0);
}
d=Math.sqrt(d);        /*most már gyököt vonhatunk a diszkriminánsból*/
x1=m.gyok12(d);
x2=m.gyok12(-d);
System.out.println("Ket valos gyok van");
System.out.println("x1 = "+x1);
System.out.println("x2 = "+x2);
System.out.println("Ellenorzes:");
System.out.println("a*x1*x1 + b*x1 + c = "+m.masodfoku(x1));
System.out.println("a*x2*x2 + b*x2 + c = "+m.masodfoku(x2));
/*a program végrehajtásának eredménye itt látható*/
}
}


másodfokú egyenlet megoldása (eljáráshívással)
program masodfoku1;
uses crt;
var a,b,c,d,x1,x2:real;
procedure beolvas;
    begin
    writeln('Adja meg a masodfoku egyenlet egyutthatoit!');
    write('a = ');readln(a);
    write('b = ');readln(b);
    write('c = ');readln(c);
    end;
procedure nincs_gyok;
    begin
    writeln('Nincs valos gyok');
    end;
procedure egy_gyok;
    begin
    x1:=-b/(2*a);
    writeln('Egy valos gyok van');
    writeln('x = ',x1:5:4);
    end;
procedure ket_gyok;
    begin
    d:=sqrt(d);
    x1:=(-b+d)/(2*a);
  x2:=(-b-d)/(2*a);
  writeln('Ket valos gyok van');
  writeln('x1 = ',x1:5:4);
  writeln('x2 = ',x2:5:4);
  end;
procedure ellenorzes;
  begin
  writeln('Ellenorzes:');
  writeln('a*x1*x1 + b*x1 + c = ',a*x1*x1+b*x1+c:5:4);
  writeln('a*x2*x2 + b*x2 + c = ',a*x2*x2+b*x2+c:5:4);
  end;
BEGIN
clrscr;
beolvas; {eljárás hívása: a program a hívott eljárás (beolvas) deklarációjának elsõ utasításán (begin)
folytatódik, majd az eljárás utasításainak végrehajtása után a program az eljáráshívás után
következõ utasítás végrehajtásával (d:=...;) fog folytatódni}
d:=sqr(b)-4*a*c; {diszkriminans}
if d<0 then nincs_gyok
          else if d=0 then egy_gyok
                     else begin
                   ket_gyok;
                   ellenorzes;
                         end;
{figyeljük meg, hogy az egyes eseteknek megfelelõ utasítások eljárásokba szervezésével a
fõprogram mennyivel áttekinthetõbb lett!}
END.
public class MasodElj extends MasodFv {
public void nincs_gyok() {
  System.out.println("Nincs valos gyok");
  }
public void egy_gyok() {
  double x=gyok();
  System.out.println("Egy valos gyok van");
  System.out.println("x = "+x);
  System.out.println("Ellenorzes:");
  System.out.println("a*x*x + b*x + c = "+masodfoku(x));
  }
public void ket_gyok() {
    double x1,x2;
    double sqrtd=Math.sqrt(diszkriminans());
    x1=gyok12(sqrtd);
    x2=gyok12(-sqrtd);
    System.out.println("Ket valos gyok van");
    System.out.println("x1 = "+x1);
    System.out.println("x2 = "+x2);
    System.out.println("Ellenorzes:");
    System.out.println("a*x1*x1 + b*x1 + c = "+masodfoku(x1));
    System.out.println("a*x2*x2 + b*x2 + c = "+masodfoku(x2));
    }
public static void main(String[] args) {
double a,b,c,d;
MasodElj m=new MasodElj();
m.a=Double.parseDouble(args[0]);
m.b=Double.parseDouble(args[1]);
m.c=Double.parseDouble(args[2]);
d=m.diszkriminans();
/*a diszkrimináns értékétõl függõen hívjuk meg a megfelelõ eljárást */

if (d<0) { m.nincs_gyok(); }
else {
    if (d==0) { m.egy_gyok(); }
    else { m.ket_gyok(); }
    }
}
}
eljárások hívása esetszétválasztással (Turbo Pascal)
program masodfoku2;
uses crt;
var a,b,c,d,x1,x2:real;
    esetek:(nincs,egy,ketto); {a Turbo Pascal lehetõvé teszi, hogy egy speciális, un. felsorolásos
típusú változót használjunk egy logikai (Boolean) típusú változó helyett olyan esetekben, amikor
kettõnél több esetet kell szétválasztanunk a program végrehajtása során; ilyenkor a változó neve
után egyszerûen felsoroljuk az esetek szimbolikus elnevezését}
procedure nincs_gyok;
  begin
  writeln('Nincs valos gyok');
  end;
procedure egy_gyok;
  begin
  x1:=-b/(2*a);
  writeln('Egy valos gyok van');
  writeln('x = ',x1:5:4);
  end;
procedure ket_gyok;
  begin
  d:=sqrt(d);
  x1:=(-b+d)/(2*a);
  x2:=(-b-d)/(2*a);
  writeln('Ket valos gyok van');
  writeln('x1 = ',x1:5:4);
  writeln('x2 = ',x2:5:4);
  end;
procedure ellenorzes;
  begin
  writeln('Ellenorzes:');
  writeln('a*x1*x1 + b*x1 + c = ',a*x1*x1+b*x1+c:5:4);
  writeln('a*x2*x2 + b*x2 + c = ',a*x2*x2+b*x2+c:5:4);
  end;
BEGIN
clrscr;
writeln('Adja meg a masodfoku egyenlet egyutthatoit!');
write('a = ');readln(a);
write('b = ');readln(b);
write('c = ');readln(c);
d:=sqr(b)-4*a*c; {diszkriminans}
if d<0 then esetek:=nincs
       else if d=0 then esetek:=egy
                    else esetek:=ketto;
{figyeljük meg: itt állapítottuk meg a diszkrimináns kiszámított értéke (d) alapján, hogy a megadott
együtthatójú másodfokú egyenletnek nincs valós gyöke (esetek=nincs), egy valós gyöke van
(esetek=egy), vagy két valós gyöke van (esetek=ketto)}
case esetek of
  nincs:nincs_gyok; {(esetek=nincs) esetben meghívjuk a nincs_gyok eljárást}
  egy:egy_gyok; {(esetek=egy) esetben meghívjuk az egy_gyok eljárást}
  ketto:begin ket_gyok;ellenorzes; end; {(esetek=ketto) esetben meghívjuk a ket_gyok és az
ellenorzes eljárásokat}
  end;
{figyeljük meg, hogy az egyes eseteknek megfelelõ utasítások eljárásokba szervezésével és az
egyes esetek szétválasztásával a fõprogram mennyivel áttekinthetõbb lett!}
END.

                                                                                Boda István, 2003 december 3.
rendezés, interfészek, csomagoló osztályok

Az Java nyelvben a programfejlesztés során osztályokat készítünk. Összetettebb programok esetén ezt
jelentõsen megkönnyíti, ha az osztályokat egy õsosztályból kiindulva, annak leszármazottjaiként készítjük el, a
már meglevõ mezõket és metódusokat felhasználva (és bõvítve, illetve átdefiniálva, ha szükséges). Az
õsosztályt önállóan csak ritkán használjuk, többnyire csak arra szolgál, hogy a leszármazott osztályok
kialakítása számára egy jól felhasználható "keretet", sémát biztosítson. Ezért az õsosztályt akár úgy is
elkészíthetjük, hogy benne egyes metódusokat csak deklarálunk, a metódusok konkrét megvalósítását pedig a
leszármazott osztályokra hagyjuk. Ilyenkor absztrakt metódusokról, egy olyan osztály esetén pedig, amely
legalább egy ilyet tartalmaz, absztrakt osztályról beszélünk. Az ilyen osztályok nem példányosíthatóak (mivel
szerepelnek bennük nem definiált metódusok), viszont õsei lehetnek a metódusokat ténylegesen megvalósító
leszármazott osztályoknak. Például egy könyvtári nyilvántartás esetén egy absztrakt õsosztály a
következõképpen nézhet ki:
public abstract class Konyvtar {
public long raktjel;
public String[] szerzo;
public String cim;
public abstract void beolvas();
public void kiir() {
 int i;
 System.out.println(raktjel);
 System.out.print(cim+" / ");
 for(i=0;i<szerzo.length;i++) {
    System.out.println(szerzo[i]+(i==szerzo.length-1?".":" - "));
    }
 System.out.println();
 }
public abstract long[] raktjelKeres(long l);
public abstract long[] szerzoKeres(String s);
public abstract long[] cimKeres(String s);
}
A fentiekben vázolt programfejlesztési filozófiát azonban korlátozza az, hogy egy osztálynak csak
egy õsosztálya lehet (ez az ún. egyszeres öröklõdés). Egyes feladatok elvégzéséhez ugyanis nagyon
hasznos lenne, ha a feladat elvégzéséhez szükséges mûveleteket, azaz metódusokat egy önálló,
osztályjellegû egységben, úgynevezett interfészben konkrét megvalósításuktól függetlenül (azaz
absztrakt módon megadva õket) össze tudnánk gyûjteni, mivel ekkor

           az interfész felhasználásával meg tudnánk írni a feladatot végzõ metódust teljesen általánosan, azaz
            konkrét osztályoktól függetlenül, pusztán az interfészben megadott mûveleteket felhasználva
            (célszerûen a metódus fejrészében az adott interfésszel egyezõ típusú formális paramétert megadva),
           azoknak a konkrét osztályoknak az esetén, amelyeken az illetõ feladatot ténylegesen is el szeretnénk
            végezni, elég lenne az interfészben leírt mûveleteket megvalósítani, hogy a feladat elvégezhetõ legyen,
          a feladatot végzõ metódus számára pedig úgy jelezhetnénk, hogy egy adott osztály alkalmas az adott
           feladatra, hogy az osztály és az interfész között öröklõdés jellegû kapcsolatot alakítanánk ki (azaz az
           osztályt bizonyos értelemben az interfész, mint egy absztrakt osztály leszármazottjaként adnánk meg) -
           ekkor ugyanis az adott osztály egy példányát a metódus hívásakor megadhatnánk a metódus aktuális
           paramétereként.

Az interfész megvalósítása tehát egy osztály által tehát mindig egy adott feladatra való alkalmasságot, képességet jelent (valahogyan
úgy, ahogy pl. egy könyvtáros informatikus könyvtáros végzettsége adott munkák, munkakörök sikeres elvégzésének képességét
garantálja).
Egy példán keresztül nézzük meg, hogyan használhatóak ki a Java nyelvben az interfész által nyújtott lehetõségek.
Elõször adjuk meg a Rendezheto interfészt, amely a rendezéshez szükséges mûveleteket, metódusokat deklarálja:
public interface Rendezheto {
public boolean egyenlo(Object o);
public boolean nagyobbMint(Object o);
public boolean kisebbMint(Object o);
}
(Az interfészek mindig absztraktak, ezért az abstract módosítót sem az interfész-deklaráció fejrészében, sem pedig az
interfészek metódusainak deklarációjakor nem kell kiírnunk.) Ezután adjuk meg a Hallgato osztályt, amelynek egy
példánya egy hallgatót azonosít, és amely megvalósítja, implementálja a rendezheto interfészt, azaz megvalósítja az
interfészben megadott metódusokat a Hallgato osztály egyes példányai esetén:
public class Hallgato implements Rendezheto {
public String nev;
public int jegy;
public Hallgato(String s,int j) {
 nev=s;
 jegy=j;
 }
public boolean egyenlo(Object o) {
 Hallgato h=(Hallgato)o;
 return jegy==h.jegy;
 }
public boolean nagyobbMint(Object o) {
 Hallgato h=(Hallgato)o;
 return jegy>h.jegy;
 }
public boolean kisebbMint(Object o) {
 Hallgato h=(Hallgato)o;
 return jegy<h.jegy;
 }
public String toString() {
 return nev+"("+String.valueOf(jegy)+")";
 }
}
Ezek után már csak a Rendezo osztályra van szükségünk, amelyben egy rendez(...) nevû statikus metódus a
Rendezheto interfészben megadott metódusok alapján elrendezi egy tömb elemeit. A tömbelemek típusára
csak egy megszorítás van: azoknak olyan osztálytípusúaknak kell lenniük, amely a Rendezheto interfészt
implementálta. A Hallgato osztály ilyen, tehát a Hallgato osztály példányaiból álló tömb a rendez(...) eljárással
elrendezhetõ (esetünkben a hallgatók jegyei alapján). A rendez(...) eljárás a legnagyobb elem kiválasztásán
alapul; ha van n darab elemünk

              1. lépés: kiválasztjuk a rendezendõ elemek közül a legnagyobbat, és ezt kicseréljük az elsõ elemmel,
              2. lépés: kiválasztjuk a még rendezendõ elemek közül a legnagyobbat, és ezt kicseréljük a második
              elemmel,
              ... (ezt így folytatjuk, amíg csak két elem marad)
              (n-1)-dik lépés: a megmaradt két rendezetlen elem közül kiválasztjuk a nagyobbikat, és ezt kicseréljük az
              (n-1)-dik elemmel.

Megjegyzés: ha valamelyik lépésben éppen a lépésnek megfelelõ sorszámú elem a legnagyobb, a cserét nyilvánvalóan
nem kell végrehajtanunk.
public class Rendezo {
public static void rendez(Rendezheto[] kulcs) {
int i,j,k,max=kulcs.length;
Rendezheto r;
for(i=0;i<max-1;i++) {
    System.out.println((i+1)+". lepes:");
    System.out.print("         ");
    for(j=0;j<max;j++) {
        System.out.print(kulcs[j]+(j<max-1?" - ":""));
        }
    System.out.println();

    k=i; /*legnagyobb elem indexe*/
    for(j=i+1;j<max;j++) {
    if(kulcs[j].nagyobbMint(kulcs[k])) { //ha találunk kulcs[k]-nál nagyobbat
        k=j; //a nagyobb érték indexét tároljuk
        }
    }
    if(i!=k) {
        System.out.println("         "+kulcs[i]+" es "+kulcs[k]+" csereje");

    r=kulcs[i];
    kulcs[i]=kulcs[k];
    kulcs[k]=r;
    }
    else {
        System.out.println("         nem kell cserelni");
        }

    }
}
}
Ahhoz, hogy kipróbáljuk, mindez hogyan mûködik, készítsük el a Hallgatok osztályt:
public class Hallgatok {
public static void main(String[] args) {
int i,max=7;
Hallgato[] tomb=new Hallgato[max];
System.out.println("A tarolt tombertekek (rendezes elott):");
for(i=0;i<max;i++) {
    tomb[i]=new Hallgato(String.valueOf((char)(65+i)),(int)(Math.random()*5+1));
    System.out.print(tomb[i]+(i<max-1?" - ":""));
    }
System.out.println();
Rendezo.rendez(tomb);
System.out.println("A tarolt tombertekek (rendezes utan):");
for(i=0;i<max;i++) {
    System.out.print(tomb[i]+(i<max-1?" - ":""));
    }
System.out.println();
}
/*a futtatáskor kapott eredmény itt látható*/
}
Ahhoz, hogy a fenti program mûködését igazán megértsük, még egy dolog ismeretére van szükségünk.
Figyeljük meg, hogy a Hallgato típusú elemekbõl álló tomb nevû tömb rendezését a

               Rendezo.rendez(tomb);

eljáráshívással valósítottuk meg. Eddigi programjainkban a metódusok kétféleképpen adták vissza az általuk kiszámított
értékeket:

               a függvények hívása önmagában is egy érték visszaadását jelentette (azaz formálisan mindig a függvény nevéhez
                rendeltük hozzá a visszatérési értéket),
               az eljárások pedig az adott objektumpéldány mezõinek az értékét módosították

A Hallgatok osztályban egy harmadik lehetõséget használtunk ki: a rendez(...) eljárás az eljárás hívásakor aktuális
paraméterként megadott tomb nevû tömb elemeinek az értékét módosította. A Parameteratadas osztály azt szemlélteti,
hogyan és mikor használhatjuk ki ezt a lehetséget a Java programokban:
class ProbaOsztaly { /*ezzel az osztállyal próbáljuk ki, hogy a paraméterátadás hogyan mûködik osztálytípusok
(referenciatípusok) esetén*/
public int intMezo;
public String stringMezo;
public ProbaOsztaly(int i, String s) {          /*konstruktor*/

        intMezo=i;
        stringMezo=s;
        }
public ProbaOsztaly(ProbaOsztaly p) {             /*konstruktor*/

    this.intMezo=p.intMezo; /*Ebben az értékadó utasításban a this "pszeudováltozó" az aktuális objektumot jelenti,
szembeállítva a formális paraméterként megadott p objektummal. A this hivatkozást pszeudováltozóként úgy kell
elképzelnünk, mint egy olyan mezõt, amelyet a Java minden objektumban automatikusan létrehoz, és értékének beállítja
az illetõ objektum referenciáját. Ezáltal a this mezõn keresztül hivatkozhatunk az aktuális objektum bármely mezõjére és
metódusára. A fenti értékadás egyébként a this megadása nélkül is tökéletesen mûködne, de a this megadásával
"áttekinthetõbb" forráskódot kapunk. (Megjegyzés: emlékezzünk rá, hogy a this hivatkozás egy konstruktor elsõ sorában
az aktuális osztály konstruktorára való hivatkozást jelentette, ettõl azonban eltér a pszeudováltozóként való használata.) */
    this.stringMezo=p.stringMezo;
    }
public boolean equals(Object o) {           /*két ProbaOsztaly objektum összehasonlításához kell*/

    ProbaOsztaly p=(ProbaOsztaly)o;
    return this.intMezo==p.intMezo && this.stringMezo.equals(p.stringMezo);
    }
public String toString() {       /*az aktuális ProbaOsztaly objektum kiiratásához kell*/

    return "    this.intMezo = "+this.intMezo+"         this.stringMezo = "+this.stringMezo;
    }
}
public class Parameteratadas {
public void proba(int i) {
    System.out.println("   megprobaljuk megduplazni i erteket");

    i*=2;
    }
public void proba(String s) {
    System.out.println("   megprobaljuk 'megduplazni' s erteket");
    s+=s;
    }
public void proba(StringBuffer sb) {
    System.out.println("   megprobaljuk 'megduplazni' sb erteket");
    sb.append(sb);
    }
public void proba(ProbaOsztaly p) {
    System.out.println("   megprobaljuk megduplazni intMezo erteket");

    p.intMezo*=2;
    System.out.println("   megprobaljuk 'megduplazni' stringMezo erteket");

    p.stringMezo+=p.stringMezo;
    }
public static void main(String[] args) {
    int i=1,i0=i;
    String s="Hello",s0=s;
    StringBuffer sb=new StringBuffer("Hello"),sb0=new StringBuffer().append(sb);
    ProbaOsztaly p=new ProbaOsztaly(1,"Hello"),p0=new ProbaOsztaly(p);
    Parameteratadas par=new Parameteratadas();
    System.out.println("A formalis parameter: int i");
    System.out.println("     i = "+i0);
    par.proba(i);
    System.out.println("     i = "+i);
    System.out.println("     A modositas sikeres volt: "+(i0==i?"nem":"igen"));
    System.out.println("A formalis parameter: String s");
    System.out.println("     s = "+s0);

    par.proba(s);
    System.out.println("     s = "+s);
    System.out.println("     A modositas sikeres volt: "+(s0.equals(s)?"nem":"igen"));
    System.out.println("A formalis parameter: StringBuffer sb");
    System.out.println("     sb = "+sb);

    par.proba(sb);
    System.out.println("     sb = "+sb);
    System.out.println("     A modositas sikeres volt: "+(sb0.equals(sb)?"nem":"igen"));
    System.out.println("A formalis parameter: ProbaOsztaly p");
    System.out.println(p);
    par.proba(p);
    System.out.println(p);
    System.out.println("     A modositas sikeres volt: "+(p0.equals(p)?"nem":"igen"));

    }
    /*a program futásának az eredménye itt látható*/
}
A példaprogramból látszik, hogy


Ha egy eljárás formális paramétere elemi vagy String típusú, akkor a metódus törzsében a formális
paraméteren végrehajtott változtatások nem jelennek meg a híváskor megadott aktuális paraméter értékében.
Ha viszont a formális paraméter StringBuffer típusú vagy bármilyen más osztálytípusú (pl. ProbaOsztaly
típusú), a metódus törzsében a formális paraméteren végrehajtott változtatások a metódus hívásakor
megadott aktuális paraméter értékében is megjelennek. (Megjegyzés: ha olyan osztályt használunk formális
paraméterként, amelynek (1) nem tudunk a mezõihez hozzáférni és (2) nincs olyan metódusa, amellyel a
mezõk értékét meg tudnánk változtatni, a fent leírt paraméterátadási mechnizmus nyilván nem alkalmazható
- egyébként ez a helyzet áll fenn a String osztály, és bármely csomagoló osztály esetén is.)
A Java paraméterátadásának ezt a sajátosságát használtuk ki a Rendezo osztály rendez(...) eljárásának a megírásakor.
A Java nyelv a JDK 1.3 verziójától kezdve egy kész rendezési eljárást biztosít pl. String típusú értékek rendezésére: a
java.util csomagon belül a Collections.sort() eljárást. Vizsgáljuk meg egy példán keresztül, hogyan lehetséges a
parancssori paraméterekként beírt karakterláncok rendezése lexikografikusan (vagyis "ábécé sorrendben"):
import java.util.*; /*a java.util csomag elérhetõsége szükséges a rendezéshez*/
public class Rendez {
public static void main(String[] args) {
    int i;
    List alist=Arrays.asList(args); /*az argstömb értékeibõl létrehozzuk a List típusú alistlistát az Arrays osztály asList() statikus metódusának
segítségével; a lista módosítása visszahat az eredeti tömbre is, tehát ha a listaelemeket elrendezzük, az automatikusan a tömb rendezését is jelenti
majd*/
    System.out.println(alist); /*az alist lista elemeinek kiiratása*/
    for(i=0;i<args.length;i++) {
        System.out.println(args[i]); /*az args tömb elemeinek kiiratása*/
        }
    System.out.println("Rendezes...");
    Collections.sort(alist); /*az alist lista és az args tömb elemeinek (együttes) rendezése a JDK 1.3 verziójától hozzáférhetõ Collections osztály
sort() statikus metódusa segítségével; mivel a sort() metódust egy formális paraméterrel hívtuk meg, a rendezés a String típusú tömb- ill. listabelemek
compareTo() metódusa alapján fog megtörténni*/
    System.out.println(alist);
    for(i=0;i<args.length;i++) {
        System.out.println(args[i]);
        }
    /*a kiiratás eredménye itt látható*/
    }
}
A rendezés mûveletére azonban sok más esetben is szükség van, így érdemes megvizsgálnunk, hogyan lehetséges nem
csak String típusú értékekre, hanem bármilyen Java típusra alkalmaznunk a Java standard rendezési eljárását. Ehhez azt
kell észrevennünk, hogy a rendezés alapja minden esetben az adott típus értékeinek összehasonlíthatósága. Ehhez a
Java Collections.sort() standard rendezési eljárása két metódust használ (attól függõen, hogy egy vagy két formális
paraméterrel hívjuk meg). Ezek a következõk:

            compareTo(Object) metódus (egy formális paraméter esetén, pl. Collections.sort(alist); )
            compare(Object,Object) metódus (két formális paraméter esetén, pl. Collections.sort(pars,h); )

Ezeknek a metódusoknak a meglétét, azaz azt, hogy az illetõ metódusokat deklaráltuk egy osztályban, a Java nyelvben un.
interfészekkel adjuk meg. Másként megfogalmazva, ha egy osztályban meg van valósítva egy interfész, biztosak lehetünk abban, hogy
az osztály rendelkezik az interfész definíciójában megadott metódusokkal. A számunkra fontos két metódusnak megfelelõ interfészek
a következõk:

            a compareTo() metódus esetén a java.lang.Comparable interfész
            a compare() metódus esetén a java.util.Comparator interfész.

Példaként nézzük meg, hogy a Java 2 SDK, Standard Edition 1.4.0 Beta verzióban hogyan valósították meg ezeket az interfészeket:
package java.lang;
public interface Comparable {
    public int compareTo(Object o);
}
package java.util;
public interface Comparator {
    int compare(Object o1, Object o2);
    boolean equals(Object obj);
}
Azt, hogy egy osztályban megvalósítottunk, "implementáltunk" egy interfészt, az implements Java
kulcsszóval adjuk meg, közvetlenül az osztály nevének deklarálása után.
Hasonlítsuk most össze egy táblázatban a Hallgatok és Rendez osztályokban a rendezéshez
használt nyelvi eszközöket:


               public class Hallgatok                                public class Rendez
a rendezendõ elemek osztályában megvalósított    a rendezendõ elemek osztályában megvalósított
interfész:                                       interfész:

       Rendezheto                                      Comparable

a rendezés alapjául szolgáló metódus(ok):        a rendezés alapjául szolgáló metódus(ok):

       egyenlo()                                       compareTo()
       kisebbMint()
       nagyobbMint()

milyen típusú elemeket rendeztünk:               milyen típusú elemeket rendeztünk:

       Hallgato                                        String

milyen tömb elemeit rendeztük el:                milyen tömb elemeit rendeztük el:

       Hallgato[] tomb                                 String[] args

                                                 hogyan alakítottuk át a tömböt a rendezéshez:

                                                        List alist=Arrays.asList(args)

melyik eljárással rendeztünk:                    melyik eljárással rendeztünk:

       Rendezo.rendez(...)                             Collections.sort(...)

milyen típusú formális paramétert adtunk meg a   milyen típusú formális paramétert adtunk meg a
rendezõ eljárásban:                              rendezõ eljárásban:

       Rendezheto[] kulcs                              List list
Vizsgáljuk meg ezután példákon keresztül, hogyan használhatjuk a Comparable és Comparator
interfészeket:

         rendezés a compareTo() metódussal (Comparable)
         rendezés a compare() metódussal (Comparator)
         rendezés a compareTo() és a compare() metódusokkal (Comparable, Comparator)

A példák is mutatják, hogy a Java standard rendezési eljárását a Comparable vagy Comparator interfész
implementálása mellett bármilyen Object típusú értékekbõl álló listára alkalmazhatjuk. Mivel a Javában az
osztályok az Object osztály leszármazottai, ez azt jelenti, hogy bármilyen osztálytípus esetén, ha az illetõ
osztály implementálja a Comparable vagy a Comparator interfészek valamelyikét, alkalmazhatjuk a
rendezést. Azonban az elemi típusú adatok (pl. int, double típusú számok) nem leszármazottai az Object
osztálynak, így ha elemi típusú adatokra akarjuk a rendezést alkalmazni, az adott elemi típus helyett a neki
megfelelõ un. csomagoló osztályt kell használnunk. Ezek a következõk:

         byte típus esetén a Byte osztály
         short típus esetén a Short osztály
         int típus esetén az Integer osztály
         long típus esetén a Long osztály
         float típus esetén a Float osztály
         double típus esetén a Double osztály
         char típus esetén a Character osztály.

(Megjegyzés: boolean típus esetén is létezik egy csomagoló osztály, a Boolean osztály, azonban ilyen típusú
értékeket aligha akarunk rendezni, így ezzel nem foglalkozunk.) A csomagoló osztályok rendelkeznek egy
(privát, tehát csak az osztály metódusai által elérhetõ) value nevû mezõvel, amely az illetõ osztálynak
megfelelõ elemi típusú érték tárolását valósítja meg, és eköré épülnek az illetõ osztály metódusai. A csomagoló
osztályok és a nekik megfelelõ elemi értékek konverzióját a következõképpen valósíthatjuk meg:

         elemi típus (int, double, stb.) -> csomagoló osztálytípus (Integer, Double, stb.) esetén a csomagoló
          osztály konstruktorával; például
              o Integer i=new Integer(23); (az értékadás után i.value értéke 23 lesz)
              o Double d=new Double(3.14); (az értékadás után d.value értéke 3.14 lesz)
              o ...
         csomagoló osztálytípus (Integer, Double, stb.) -> elemi típus (int, double, stb.) esetén pedig a
          csomagoló osztály xxxValue() nevû függvényeivel, ahol xxx a megfelelõ elemi típus neve; például az
          elõzõ példákban szereplõ változók esetén
              o i.intValue() (mivel i.value értéke 23, a függvény értéke 23 lesz)
              o d.doubleValue() (mivel d.value értéke 3.14, a függvény értéke 3.14 lesz)
              o ...



A csomagoló osztályok mindegyike az Object osztály leszármazottja (illetõleg az Integer, Long, Float és
Double osztályok a Number osztály leszármazottjai, amely az Object leszármazottja) és implementálja a
Comparable interfészt (azaz rendelkezik alapértelmezett compareTo() metódussal), vagyis rájuk már
alkalmazható a Java standard rendezési eljárása. Példaként nézzük meg, hogy a Java 2 SDK, Standard Edition
1.4.0 Beta verzióban az Integer osztályban hogyan valósították meg a compareTo() metódust:
package java.lang;
public final class Integer extends Number implements Comparable {
...
private int value;
...
public int compareTo(Integer anotherInteger) {
      int thisVal = this.value;
      int anotherVal = anotherInteger.value;
      return (thisVal<anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1));
      }
public int compareTo(Object o) {
      return compareTo((Integer)o);
      }
...
}
Utolsó példaként nézzük meg, hogyan lehetséges pl. int típusú egész számok nagyság szerinti
rendezése:

             példa: egész számok rendezése nagyság szerint



rendezés a compareTo() metódussal (Comparable)
import java.util.*;
public class MyString implements Comparable {                 /*a Comparable interfész olyan "absztrakt" osztálynak
fogható fel, amelynek nincsenek adatmezõi és amelyben csak egy metódus létezik, a compareTo() függvény, amelyet
nekünk kell definiálnunk, ha "implementáljuk" az interfészt; az implements Comparable deklarációval azt adjuk meg, hogy
a MyString osztályban a compareTo() függvény definiálva van, vagyis minden olyan eljárás (pl. a Collections.sort() eljárás
a main() metódusban), amely ezt használja, alkalmazható MyString típusú objektumokra is*/
private String value; /*A MyString objektum egyetlen mezõvel rendelkezik, mely String típusú. Egy MyString
objektum tehát egy karakterláncot ad meg, amelyet a value elemváltozóban tárolunk (szemléletesen azt is mondhatnánk,
hogy a MyString objektum "becsomagol" egy karakterláncot). Egy MyString objektum lényegében csak abban különbözik
egy String objektumtól, hogy eltérõ compareTo() metódusa van, vagyis másként hasonlitjuk össze a MyString
objektumokat, mint a "hagyományos" String objektumokat. A private láthatósággal definiált value elemváltozót csak a
MyString osztály metódusain keresztül érhetjük el.*/
public MyString(String s) { /*konstruktorfüggvény, amellyel egy MyString típusú objektum létrehozásakor
kezdõértéket tudunk adni a private láthatóságú value mezõnek*/
      value=s;
      }
public int length() { /*formálisan ugyanaz, mint a String osztály length() függvénye; erre szükségünk lesz a
compareTo() metódus definiálásakor*/
      return value.length();
      }
public int compareTo(MyString s) { /*formálisan megfelel a String osztály compareTo() függvényének, de másként
definiáljuk: itt az összehasonlítás nem lexikografikusan, hanem a karakterláncok hossza alapján történik */
      return value.length()-s.length();
    }
public int compareTo(Object o) { /*itt a formális paraméter elvileg bármilyen objektum lehet; erre a metódusra azért van
szükség, mert a Collections osztály sort metódusát teljesen általánosan, ilyen szignatúrájú (azaz ilyen típusú formális paraméterrel
rendelkezõ) metódusra írták meg, hogy bármilyen osztálytípusra alkalmazható legyen; jegyezzük meg: a Java nyelvben minden osztály
az Object osztály leszármazottja*/
    MyString s=(MyString)o;          /*típuskényszerítést alkalmazva az Object típusú formális paramétert MyString típusúvá alakítjuk;
megjegyzés: ha az o objektum nem konvertálható MyString típusra (azaz nem MyString típusú), az ClassCastException kivételhez
vezet!*/
    return compareTo(s);        /*a MyString osztály korábban definiált compareTo() metódusát hívjuk meg*/

    }
public String toString() { /*formálisan ugyanaz, mint a String osztály toString() függvénye, amelyet akkor hív meg a Java, ha
String típusúvá kell konvertálni egy MyString objektumot, pl. a System.out.println() metódusban; megjegyzés: a toString() függvény már
az Object osztályban is definiálva van, tehát minden Java osztály rendelkezik ilyen függvénnyel, de az egyes osztályok
jellegzetességeit figyelembe véve ez a függvény az egyes osztályokban felüldefiniálható, mint ahogy esetünkben is */
    return value;
    }
public static void main(String[] args) {
    int i;
    MyString[] ms=new MyString[args.length]; /*a tömb rendezéshez kell; annyi elembõl fog állni, ahány parancssori
paramétert adtunk meg*/
    for(i=0;i<args.length;i++) {
        ms[i]=new MyString(args[i]);        /*feltöltjük a tömböt a MyString() konstruktor meghívásával*/

        }
    List mlist=Arrays.asList(ms); /*ezt már az elõzõ példában is megcsináltuk; az mlist lista az ms tömbbõl jön létre, és innentõl
az ms tömb és mlist lista innentõl "párhuzamosan" használható, tehát pl. a listát elrendezve a tömb elemei is rendezettek lesznek */
    System.out.println(mlist);
    for(i=0;i<args.length;i++) {
        System.out.println(ms[i]);
        }
    System.out.println("**** Rendezes a karakterlancok hossza alapjan ****");
    Collections.sort(mlist);
    System.out.println(mlist);
    for(i=0;i<args.length;i++) {
        System.out.println(ms[i]);
        }
    /*a kiiratás eredménye itt látható*/
    }
}
rendezés a compare() metódussal (Comparator)
import java.util.*;
public class Hasonlit implements Comparator {               /*a Comparator interfész a compare() metódust tartalmazza,
amelyet a rendezéskor használhatunk*/
public int compare(Object o1, Object o2) {
    String s1=(String)o1;
    String s2=(String)o2;
    return s1.length()-s2.length();
    }
public static void main(String[] args) {
    List pars=Arrays.asList(args);
    Hasonlit h=new Hasonlit();
    System.out.println("RENDEZETLENUL");
    System.out.println(pars);
    Collections.sort(pars);      /*rendezés a String osztályban deklarált standard compareTo() metódus alapján, ábécé
rendben*/
    System.out.println("ABC SORRENDBEN RENDEZVE");
    System.out.println(pars);
    Collections.sort(pars,h); /*a sort() metódus második paramétereként megadva a Comparator interfészt
implementáló Hasonlit() osztály egy h példányát, a rendezés az osztályban deklarált compare() metódus alapján fog
megtörténni; így lehetõségünk van a String típusú tömbelemeket egy általunk választott rendezési elv szerint is
elrendezni anélkül, hogy egy új osztályba kellene csomagolni a tömbelemek értékeit */
    System.out.println("HOSSZ ALAPJAN RENDEZVE");
    System.out.println(pars);
    /*a kiiratás eredménye itt látható*/
    }
}


rendezés a compareTo() és a compare() metódusokkal (Comparable, Comparator)
import java.util.*;
public class YourString implements Comparable, Comparator {                    /*egy osztály egyszerre több interfészt is
implementálhat: esetünkben az interfészek azt jelzik, hogy a YourString osztályban egyaránt deklaráltuk a compareTo()
és a compare() metódust is*/
private String value;
public YourString() {
    value=new String();        /*ha a konstruktort paraméter nélkül hívjuk meg, akkor a kezdõérték egy üres String lesz*/

    }
public YourString(String s) {
    value=s;    /*ha a konstruktort egy String típusú paraméterrel hívjuk meg, akkor a kezdõérték a megadott paraméter
értéke lesz*/
    }
public int length() {
    return value.length();
    }
public int compare(Object o1,Object o2) {              /*"alternatív" rendezés: a karakterláncok hossza alapján*/

    YourString s1=(YourString)o1;
    YourString s2=(YourString)o2;
    return s1.length()-s2.length();
    }
public int compareTo(Object o) { /*"hagyományos" rendezés: megfelel a String osztály "hagyományos" compareTo() metódusának (ti. ezt is
hívja meg)*/
    YourString s=(YourString)o;
    return value.compareTo(s.toString());
    }
public String toString() {
    return value;
    }
public static void main(String[] args) {
    int i;
    YourString y=new YourString(); /*megjegyzés: ezért kellett a YourString() konstruktort formális paraméterek nélkül is deklarálnunk*/
    YourString[] ys=new YourString[args.length];
    for(i=0;i<args.length;i++) {
        ys[i]=new YourString(args[i]);        /*megjegyzés: és ezért kellett a YourString(String s) konstruktort String típusú formális paraméterrel
deklarálnunk*/
        }
    List ylist=Arrays.asList(ys);
    System.out.println("**** Eredeti sorrendben ****");
    System.out.println(ylist);
    System.out.println("**** Rendezes alfabetikusan ****");
    Collections.sort(ylist);
    System.out.println(ylist);
    System.out.println("**** Rendezes a karakterlancok hossza alapjan ****");
    Collections.sort(ylist,y); /*a YourString osztály y példányát megadva a sort() metódus második formális paramétereként, a rendezés a példány
compare() metódusa alapján fog megtörténni (megjegyzés: ha legalább egy parancssori paramétert megadunk, elegánsabb megoldást adna a
Collections.sort(ylist,ys[0]); utasítás, mivel ys[0] szintén a YourString osztály egy példánya; ebben az esetben nem lenne szükség az y példányra, és a
formális paraméterek nélküli YourString() konstruktorra sem)*/
    System.out.println(ylist);
    /*a kiiratás eredménye itt látható*/
    }
}
példa: egész számok rendezése nagyság szerint
import java.util.*;
public class Egeszek {
public static void main(String[] args) {
    int i;
    Integer[] a=new Integer[args.length]; /*az Integer csomagoló osztálynak megfelelõ típusú elemekbõl álló tömb,
amely annyi elemet tartalmaz, ahány parancssori paramétert adtunk meg*/
    for(i=0;i<args.length;i++) {
        a[i]=new Integer(args[i]); /*a parancssori paraméterek String típusúak, ezeket kell Integer típusú értékekké
konvertálnunk õket. Ehhez rendelkezésünkre áll az Integer osztály megfelelõ konstruktora. Ha a parancssori paraméterek
nem konvertálhatóak egész számokká, az NumberFormatException kivételhez vezet!*/
        }
    List alist=Arrays.asList(a); /*az asList() metódus elemi (pl. int) típusú értékekre közvetlenül nem, csak Object
(pl. Integer, Double, String, stb.) típusú értékekre alkalmazható*/
    System.out.println(alist);
    System.out.println("Rendezes...");
    Collections.sort(alist);
    System.out.println(alist);
    /*a kiiratás eredménye itt látható*/
    }
}

                                                                                            Boda István, 2003 december 17.
Példaprogramok gyûjteménye (Java)
A szükséges Java fejlesztõi környezet letöltése:

      Download Java 2 Platform, Standard Edition (J2SE) v 1.4.2_01 [System Development Kit (SDK),
       Windows Offline Installation, DOWNLOAD (kb. 47 MB)]

A programok futtatásához szükséges parancsfájlok

      javac.bat - szöveges felületen futó java forrásfájl lefordítása
      java.bat - szöveges felületen futó java program lefuttatása
      proba.bat - szöveges felületen futó java forrásfájl lefordítása és futtatása (az elõzõ két parancsfájl
       egyben)
      test.bat - grafikus felületen futó java applet forrásfájljának lefordítása és futtatása
      test11.bat - grafikus felületen futó java applet forrásfájljának lefordítása a régebbi böngészõk által is
       megjeleníthetõ formában, és futtatása

Szöveges felületen futó alapprogramok (kezdõknek)

      Hello.java - "Hello!" kiíratása (class, main, System.out.println() )
          o Hello1.java - üdvözlés kiíratása (lokális változók a main metódusban, értékadás, szövegek és
               változók együttes használata a System.out.println() metódus formális paramétereként)
                    Hello1a.java - üdvözlés kiíratása (lokális változók a main metódusban, kezdõértékadás
                       elemi és osztálytípusú változók esetén)
          o Hello2.java - üdvözlés kiíratása (mezõk, példányosítás, alapértelmezett konstruktor, hozzáférés
               az objektum elemváltozóihoz)
          o Hello3.java - üdvözlés kiíratása (metódus visszatérési érték nélkül, hozzáférés az objektum
               metódusaihoz)
          o Hello4.java - üdvözlés kiíratása (metódus visszatérési értékkel, lokális változó egy metódusban,
               zártság)
                    Hello4a.java - üdvözlés kiíratása (alapértelmezett String típusú érték rendelése az
                       objektumhoz a toString() metódussal)
                    Hello4b.java - üdvözlés kiíratása (metódusok visszatérési értékkel, elemváltozók
                       értékének lekérdezése és eltárolása lokális változókban)
                    Hello4c.java - üdvözlés kiíratása (metódusok formális paraméterrel és visszatérési
                       értékkel, elemváltozók értékének beállítása, lekérdezése és eltárolása lokális
                       változókban)
          o Hello5.java - üdvözlés kiíratása (egymást hívó metódusok)
                    Hello51.java - üdvözlés kiíratása (kezdõértékadás a main() metódusból)
                    Hello5a.java - üdvözlés kiíratása (saját konstruktor definiálása, kezdõérték beállítása
                       konstruktorral)
                    Hello5b.java - üdvözlés kiíratása (saját konstruktor definiálása formális paraméterekkel,
                       kezdõérték beállítása konstruktorral)
                    Hello5c.java - üdvözlés kiíratása (saját konstruktorok definiálása formális
                       paraméterekkel és anélkül, hivatkozás az osztály egy másik konstruktorára)
          o Hello6.java - üdvözlés kiíratása más adatokkal (öröklõdés, metódus átdefiniálása
               (polimorfizmus) )
                    Hello6a.java - más szövegû üdvözlés kiíratása (öröklõdés, alapértelmezett konstruktor a
                       leszármazott osztályban)
                    Hello6b.java - más szövegû üdvözlés kiíratása (öröklõdés, saját konstruktor definiálása
                       formális paraméterekkel a leszármazott osztályban, hivatkozás a szülõ osztály
                       konstruktorára a leszármazott osztályban)
                   Hello6c.java - más szövegû üdvözlés kiíratása (öröklõdés, saját konstruktor definiálása
                    formális paraméterekkel és anélkül a leszármazott osztályban, hivatkozás a szülõ osztály
                    konstruktorára a leszármazott osztályban)
       o Hello65.java - üdvözlés kiíratása más adatokkal (öröklõdés, metódus átdefiniálása - mindez egy
            forrásfájlban)
       o Hello7.java - üdvözlés kiíratása (öröklõdés, új mezõ hozzáadása, hivatkozás a szülõ osztályra
            (super) az átdefiniált metódusokban, soremelés (\n karakter) )
       o Hello8.java - üdvözlés kiíratása csillagokkal határolva (statikus változó és metódus,
            System.out.print() )
                 Hello8a.java - üdvözlés kiíratása csillagokkal határolva (statikus metódus meghívása egy
                    másik osztályból)
                 Hello8b.java - üdvözlés kiíratása csillagokkal határolva (statikus metódus meghívása egy
                    másik statikus metódusból)
                 Hello8c.java - üdvözlés kiíratása csillagokkal határolva (statikus metódusok meghívása
                    egy dinamikus metódusból)
                         Hello8cc.java - üdvözlés kiíratása csillagokkal határolva (statikus és dinamikus
                             metódusok hívása egy dinamikus metódusból)
       o Hello9.java - üdvözlés kiíratása csillagokkal határolva (statikus változó és metódus öröklése,
            statikus metódus túlterhelése, String hosszának lekérdezése)
                 Hello9a.java - üdvözlés kiíratása csillagokkal határolva (statikus metódusok meghívása
                    egy másik osztályból)
                 Hello9b.java - üdvözlés kiíratása plusz karakterekkel és csillagokkal határolva (statikus
                    változó és metódus öröklése, statikus metódus átdefiniálása és hatása a statikus hívási
                    környezetre, statikus metódus túlterhelése)
                 Hello9c.java - üdvözlés kiíratása plusz karakterekkel és csillagokkal határolva (statikus
                    változó és metódus öröklése, statikus metódus átdefiniálása és hatása a dinamikus hívási
                    környezetre, dinamikus metódus túlterhelése)
                         Hello9cc.java - üdvözlés kiíratása plusz karakterekkel és csillagokkal határolva
                             (statikus változó és metódus öröklése, dinamikus metódus átdefiniálása és hatása
                             a dinamikus hívási környezetre, dinamikus metódus túlterhelése)
   Dij1.java - késedelmi díj kiszámítása (static final; kétirányú elágazás)
       o Dij11.java - késedelmi díj kiszámítása (egyirányú elágazás)
       o Dij2.java - késedelmi díj kiszámítása a Dij1 osztály használatával
       o Dij3.java - késedelmi díj kiszámítása egy parancssori paraméterrel megadott értékkel (args,
            Integer.parseInt(), try, catch, NumberFormatException)
       o Dij4.java - késedelmi díj kiszámítása a Dij3 osztály használatával
       o Dij5.java - késedelmi díj kiszámítása parancssori paraméterrel megadott értékekkel
       o Dij6.java - késedelmi díj kiszámítása a Dij5 osztály használatával
   Lotto.java - lottószámok kiírása (tömb megadása az elemek felsorolásával; tömbelemek kiírása
    egyenként)
       o Lotto1.java - lottószámok kiírása (tömbelemek kiírása ciklussal)
       o Lotto2.java - lottószámok kiírása (tömb megadása a méret megadásával; tömbelemek beállítása
            és kiírása eljárásokkal)
       o Lotto3.java - véletlen számok megadása lottószámként és kiírásuk
       o Lotto4.java - véletlen számok megadása lottószámként és kiírásuk (különbözõ számok megadása
            egy logikai tömbben való tárolással)
       o Lotto5.java - véletlen számok megadása lottószámként és kiírásuk (különbözõ számok megadása
            egy logikai tömbben való tárolással és kiírásuk rendezetten)
       o Lotto6.java - véletlen lottószámok kiírása (lottószámok kiolvasása egy függvénnyel)
   Katced.java - egyszerû bibliografikus rekord kiíratása (String típusú tömbök)
       o Katced1.java - egyszerû bibliografikus rekord kiíratása (a kezdõérték-beállító metódus
            átdefiniálása)
   Muveletek.java - különbözõ mûveletek eredményének kiíratása
   Szamok.java - az elsõ 10 egész szám kiíratása (for, ++)
       o Szamok1.java - az elsõ 5 egész szám kiíratása növekvõ és csökkenõ sorrendben (--)
                 Szamok1a.java - az elsõ 5 egész szám kiíratása növekvõ és csökkenõ sorrendben (while)
                   Szamok1b.java - az elsõ 5 egész szám kiíratása növekvõ és csökkenõ sorrendben
                    (do...while)
        o Szamok2.java - az elsõ 10 páratlan szám kiíratása (+=)
                 Szamok2a.java - az elsõ 10 páros szám kiíratása
                 Szamok2b.java - az elsõ 10 páros szám kiíratása visszafelé (-=)
                 Szamok2c.java - az elsõ 10 páros szám kiíratása sorszámmal (+(összefûzés))
        o Szamok3.java - az 1,2,4,7,11,... sorozat elsõ 10 elemének kiíratása sorszámmal
        o Szamok4.java - az 1,-2,3,-4,... sorozat elsõ 10 elemének kiíratása (boolean, !, ?:)
   Osszeg.java - az elsõ 10 szám összegének kiszámítása
        o Osszeg1.java - az elsõ 10 számra a számok összegének kiíratása
        o Osszeg2.java - az elsõ 10 páratlan szám összegének kiszámítása
   Fakt.java - 10 faktoriálisának kiszámítása (long)
        o Fakt1.java - az elsõ 10 számra a szám faktoriálisának kiíratása (metódus formális
            paraméterekkel)
        o Fakt2.java - az elsõ 10 számra a szám faktoriálisának kiíratása (statikus metódus formális
            paraméterekkel)
        o Fakt3.java - az elsõ 10 páratlan szám szorzatának kiszámítása
        o Fakt4.java - az elsõ 5 páratlan szám összegének és szorzatának kiszámítása
   Negyzet.java - az elsõ 10 négyzetszám kiíratása
   Hatvany.java - 2 elsõ 10 pozitív hatványának kiíratása (double, *=)
        o Hatvany1.java - 2 elsõ 10 negatív hatványának kiíratása (/=)
        o Hatvany2.java - PI (3.14...) elsõ 10 hatványának kiíratása (Math.PI, Math.pow())
                                          1.0   1.5  2.0   2.5      10.0
                 Hatvany2a.java - a PI , PI , PI , PI , ..., PI         hatványok kiíratása
   Kerekit.java - egy valós szám kerekítése n tizedesjegyre (if, Math.round())
   Fuggvenyek.java - a szinusz- és koszinuszfüggvény értékeinek kiíratása négy tizedesjegy pontossággal
    (Math.sin(), Math.cos())
   Veletlen.java - 10 db véletlen valós szám kiíratása a [0,1) intervallumból (Math.random())
        o Veletlen0.java - 5 db véletlen valós szám kiíratása négy tizedesjegy pontossággal
        o Veletlen1.java - 10 db véletlen valós szám tárolása egy tömbben és kiíratása (tömb létrehozása)
        o Veletlen2.java - 10 db véletlen valós szám tárolása egy tömbben; átlag, legkisebb és legnagyobb
            elem kiíratása
        o Veletlen3.java - 5 db véletlen egész szám kiíratása az [1,90] intervallumból ((int))
   OtParam.java - a parancssori paraméterek számának és max. öt parancssori paraméternek a kiíratása
    (args, args.length)
        o OtParam1.java - a parancssori paraméterek kiíratása hibakezeléssel
            (ArrayIndexOutOfBoundsException)
        o OtParam2.java - a parancssori paraméterek konvertálása egész számmá és kiíratásuk
            hibakezeléssel (Integer.parseInt(), Exception)
        o OtParam3.java - a parancssori paraméterek konvertálása egész számmá és kiíratásuk
            hibakezeléssel (utasítások összevonása a ++ operátor használatával)
        o OtParam4.java - a parancssori paraméterek konvertálása egész számmá és kiíratásuk
            hibakezeléssel (az elõzõ program tömör leírása for ciklus használatával)
   Keres.java - egy megadott érték lineáris keresése (értékek megadása felsorolással)
        o Keres1.java - egy megadott érték lineáris keresése (értékek megadása egyenként, értékadással)
        o Keres2.java - egy megadott érték lineáris keresése (értékek megadása ciklussal)
        o Keres3.java - egy megadott érték lineáris keresése (véletlen egész értékek megadása ciklussal)
        o Keres4.java - egy megadott érték lineáris keresése (véletlen egész értékek megadása ciklussal a
            konstruktorban, a keresés megvalósítása függvénnyel)
        o Keres5.java - egy megadott érték lineáris keresése (rendezett egész értékek megadása ciklussal a
            konstruktorban)
        o Keres6.java - egy megadott érték szekvenciális keresése (a keresés megvalósítása függvénnyel)
        o Keres7.java - egy megadott érték bináris keresése (a keresés megvalósítása rekurzív
            függvénnyel)
   Param.java - parancssori paraméterek kiírása ciklussal
        o Param1.java - a megadott parancssori paraméter kiírása szóközökkel ritkítva (String, length(),
            charAt())
          o    Param2.java - a megadott parancssori paraméter kiírása függõlegesen, karakterenként külön
               sorba
           o Param3.java - a megadott parancssori paraméterek kiírása ábécé sorrendben (compareTo())
                    Param3a.java - parancssori paraméterekként megadott egész számok kiírása növekvõ
                      sorrendben
                    Param3b.java - parancssori paraméterekként megadott valós számok kiírása növekvõ
                      sorrendben (Double.parseDouble())
      Jegyek.java - egy jegy megadása parancssori paraméterként és szöveges formájának kiírása
       (Integer.parseInt(), switch...case...break...default)
           o Jegyek1.java - egy jegy megadása parancssori paraméterként és szöveges formájának kiírása
               hibakezeléssel (try...catch)

Grafikus felületen futó alapprogramok (középhaladóknak)

      HelloApplet.java, HelloApplet.html - "Hello!" kiíratása egy appletben
      SzinApplet.java, SzinApplet.html - "Hello!" kiíratása különbözõ színekben
      RajzApplet.java, RajzApplet.html - síkidomok kirajzolása és feliratok kiíratása
      ColorApplet.java, ColorApplet.html - különbözõ színárnyalatok megjelenítése egy appletben
          o ColorApplet1.java, ColorApplet1.html - a vörös szín megjelenítése különbözõ telítettség-értékek
              mellett egy appletben
          o ColorApplet2.java, ColorApplet2.html - a vörös szín megjelenítése különbözõ fényerõ-értékek
              mellett egy appletben
      FontApplet.java, FontApplet.html - szöveg kiírása különbözõ karakterformátumokban
      HatterApplet.java, HatterApplet.html - szövegek kiíratása síkidomok között
      RGBApplet.java, RGBApplet.html - a színösszetevõk kiíratása az alapszínek esetén
          o RGBApplet1.java, RGBApplet1.html - a színösszetevõk kiíratása különbözõ színárnyalat-
              értékek (color hue) esetén
          o RGBApplet2.java, RGBApplet2.html - a kék alapszín színösszetevõinek kiíratása különbözõ
              telítettség-értékek (saturation) esetén
          o RGBApplet3.java, RGBApplet3.html - a vörös alapszín színösszetevõinek kiíratása különbözõ
              fényerõ-értékek (brightness) esetén
          o RGBApplet4.java, RGBApplet4.html - különbözõ szürkeárnyalatok színösszetevõinek kiíratása
              fokozatosan változtatott fényerõ-értékek esetén
      UrlapApplet.java, UrlapApplet.html - két szám összeadása egy ûrlapon

Összetett alkalmazások (haladóknak)

      Szamol.java - absztrakt osztály, amely az Osszead és Szoroz osztályok õsosztálya
           o Osszead.java - két parancssori paramétert összead
           o Szoroz.java - két parancssori paramétert összeszoroz
      Kiiratas.java - szövegek és számok kiiratása adott hosszon (StringBuffer; metódusnév túlterhelése)
           o Kiiratas1.java - valós számok kiiratása adott hosszon
      LottoSzamok.java - lottószámok rendezett kiíratása (szöveges felületen)
      LottoFrame.java - lottószámok rendezett kiíratása (grafikus felületen)
           o LottoFrame1.java - lottószámok rendezett kiíratása menüvezérelten
      EgerApplet.java, EgerApplet.html- egérkattintás figyelése, pötty kirajzolása (grafikus felületen)
      GraphFrame.java - egy absztrakt függvény grafikonjának kirajzolása (grafikus felületen)
           o LinFrame.java - lineáris függvény grafikonjának kirajzolása
           o SinFrame.java - szinuszfüggvény grafikonjának kirajzolása
      SzamolApplet.java, SzamolApplet.html - számológép (grafikus felületen)


                                                                                   Boda István, 2003. november 12.

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:30
posted:2/21/2012
language:Hungarian
pages:177