szit

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

====== Objektum Orientált Programozás ======

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

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

Itt csak egy rövid összefoglalót találunk az objektum orientált programozásról.
A objektum orientált programok konkrét megvalósítását lásd az adott programozási
nyelvnél.

Az angol **Object-Oriented Programming** szavakból alkotott betűszó, röviden **OOP**.
A valós világot úgy próbálja meg modellezni, hogy az sokkal közelebb álljon a valósághoz. A műveletek megalkotása helyett objektum hierarchiákat hozunk létre. A valós világból a számítógépen olyan olyan objektumokat hozunk létre, aminek tulajdonságai és viselkedéseik vannak.






===== Osztály =====

Az osztály, angolul class. Egy egyed leírása, amiről információkat tárolunk.
Ez az információ a programozási nyelvben változókat, és a változókon
elvégzett műveletekből (eljárás, metódus) áll.

Felépíthetjük például a Dolgozók osztályát. A dolgozónak tárolhatjuk tulajdonságait.
A tulajdonságok az osztály egy-egy változójában kapnak helyet. Például a dolgozó neve, kora, születésének ideje, fizetése, stb. 

A metódusok, beállíthatják, lekérdezhetik a tulajdonságokat. Például a nevet, a születést, vagy meghatározhatják az osztály egyéb viselkedését.

Az osztályra úgy szokás tekinteni, mint az **objektum terve**. Még nem egy konkrét valamit
ír le, csak egy terv.




===== Mező =====

A osztályok és objektumok tulajdonságait néha mező néven említjük. Ezek az osztály változói. 
A mezők, a tulajdonságok, az attribútumok így ugyanazt jelölik. 

A C# nyelv tartalmaz úgynevezett tulajdonság létrehozási lehetőséget, így ott a "tulajdonság" 
szónak más jelentése is van.





===== Metódus =====

A mezőkön végrehajtható eljárások és függvények összefoglaló neve.
A osztály viselkedésének is mondjuk.


===== Osztály létrehozása =====

Osztályt általában a class kulcsszóval vezetjük be, utána pedig a nevét adjuk meg.

<code java>
class Szemely {
	String nev;
	int kor;
}
</code>

{{:oktatas:programozas:class_pelda.png?400|}}

A mezők és a metódusok alkotják az osztály tagjait.

{{:oktatas:programozas:metodus_pelda.png?400|}}

{{:oktatas:programozas:mezok_pelda.png?400|}}


==== Python megközelítésben ====

{{:oktatas:programozas:osztaly_letrehozasa_3.png|}}



===== Konstruktor =====

A konstruktor egy speciális metódus. Speciális mivel lefut egy objektum létrehozása során.

Néhány nyelven a konstruktor neve megegyezik az osztály nevével. Ilyen a Java, C#. De a
Python nyelvben a konstruktor neve __init__()

A konstruktornak nem jelölhetünk meg visszatérési értéket, mivel alapértelmezett feladat
hogy visszaadja az osztály egy példányát. 

Konstruktor Java és C# nyelven:
<code java>
class Szemely {
	public String nev;
	public int kor;
	public Szemely() {
		this.nev = "névtelen";
		this.kor = -1;
	}
}
</code>

{{:oktatas:programozas:konstruktor_pelda.png?400|}}

A konstruktor mindig akkor fut le, amikor egy objektumot létrehozunk.


==== Konstruktor Python módra ====


{{:oktatas:programozas:osztaly_letrehozasa_konstruktor.png|}}



===== Destruktor =====

Némely nyelvben van destruktor is. A destruktor akkor hajtódik végre, ha valamilyen
objektumot megszüntetünk. 

A Java nyelvben nem használunk destruktort. 

A programozási nyelvekben általában a destruktor neve is megegyezik az osztály 
nevével, de egy ~ karaktert szokás elé tenni.



===== Objektum =====

Az osztály egy példányosított változata.

A fenti Dolgozó osztályból ha egy példányt hozunk létre, az már
egy konkrét dolgozó lesz. Lehet például egy "Nagy József"
nevű dolgozó, aki 28 éves, 480000 - Ft a fizetése. 
Az objektumnak is adnunk kell egy nevet. Például 
Joska.

Példa Java és C# nyelven:
<code java>
Dolgozo janos = new Dolgozo();
</code>

{{:oktatas:programozas:peldanyositas.png?400|}}

Az objektumot az osztályból hozzuk létre. Olyan ez mint egy változó létrehozása.
Az egyenlőség jel jobboldalán a new kulcsszó való az objektum példány létrehozására. 
A new után mindig a konstruktort hívjuk. 
===== Elérés =====

Az osztály egyes tagjai (változók és metódusok) elérése változtatható.

  * A **public** elérés, azt jelenti, hogy az adott tag más osztályokból is elérhető.
  * A **private** elérés, azt jelenti, hogy más osztályokból nem érhető el a tag, még az örökölés lévén létrejött osztályokban sem. 
  * A **protected** elérés, az jelenti, hogy csak az örökölés során létrehozott osztályokban érhető el.




===== Öröklés =====

Egy osztályból újabb osztályt hozhatunk létre, ennek folyamatát nevezzük öröklésnek.
Az öröklés során az új osztály örökli az előző minden tagját, beleértve a mezőket 
és a metódusokat.

Öröklés Java nyelven:
<code java>
class Szemely {
	String nev;
	int kor;
}

class Dolgozo extends Szemely {
	String munkakor;
}
</code>

Öröklés C# nyelven:
<code csharp>
class Szemely {
		public String nev;
		public int kor;
}

class Dolgozo : Szemely {
		String munkakor;
}

</code>

===== Többalakúság =====

A metódusok és a konstruktorok több alakban is meghívhatók. Az osztályok öröklés révén több formában is példányosíthatók. Ezeket a lehetőségeket nevezzük többalakúságnak.


==== Többalakúság örökléssel ====

<code java Program01.java>
class Allat {
    public void eszik() {
        System.out.println("evés...");
    }
}

class Macska extends Allat {
    public void nyavog() {
        System.out.println("miau");
    }
}

public class Tobbalakusag_01 {
    public static void main(String[] args) {
        Macska macska = new Macska();        
        Allat allat;
        
        allat = macska;
        
        macska.eszik();
        macska.nyavog();
        
        allat.eszik();
        /* Az allat objektum a macska objektumra mutat,
           mégsem lehet futtatni az allat objektumon
           a nyavog() metódust. Mintha több alakja lenne.
        */
    }    
}

</code>

==== Többalakúság interfésszel ====

<code java Program01.java>
interface Allat {
    public void beszel();
}

class Macska implements Allat {
    public void beszel() {
        System.out.println("miau");
    }
}

class Kutya implements Allat {
    public void beszel() {
        System.out.println("vau");
    }
}

public class Program01 {
    public static void main(String[] args) {
        Allat a = new Macska();
        Allat b = new Kutya();
        
        a.beszel();
        b.beszel();
    }    
}

</code>

==== Függvény paraméter és öröklés ====

<code java Program01.java>
public class Program01 {
    public static void main(String[] args) {
        Macska macska = new Macska();
        Kutya kutya = new Kutya();
        Allat allat = new Allat();
        beszeltet(allat);
        beszeltet(macska);
        beszeltet(kutya);
    }
    public static void beszeltet(Allat allat) {
        allat.beszel();
        /* Az allat objektum másként viselkedik
        ha macska objektumot kap, és másként
        ha kutya objektumot kap */
    }
}

class Allat {
    public void beszel() {
        System.out.println("aaaaa");
    }
}

class Macska extends Allat {
    public void beszel() {
        System.out.println("miau");
    }
}

class Kutya extends Allat {
    public void beszel() {
        System.out.println("vau");
    }
}


</code>


==== Függvény paramétere és interfész ====

<code java Program01.java>
public class Program01 {
    public static void main(String[] args) {
        Macska macska = new Macska();
        Kutya kutya = new Kutya();
        beszeltet(macska);
        beszeltet(kutya);
    }
    public static void beszeltet(Allat allat) {
        allat.beszel();
        /* Az allat objektum másként viselkedik
        ha macska objektumot kap, és másként
        ha kutya objektumot kap */
    }
}

interface Allat {
    public void beszel();
}

class Macska implements Allat {
    public void beszel() {
        System.out.println("miau");
    }
}

class Kutya implements Allat {
    public void beszel() {
        System.out.println("vau");
    }
}

</code>

===== Virtuális metódus =====

Egy metódus akkor virtuális, ha az örökölt osztályokban felülírható. 
A programozási nyelvekben ezt az ősosztályban kell beállítani, általában
a virtual kulcsszóval. A Java nyelvben nem szükséges ezt megtenni, mivel 
minden metódus alapértelmezettként felülírható, vagyis virtuális.

De pascal nyelven például:
<code pascal>
point = Object(location)
  visible: boolean;
  Constructor Init(InitX, InitY: integer);
  Procedure Show; Virtual;
  Procedure Hide; Virtual;
  Function  IsVisible: boolean;
  Procedure MoveTo(NextX, NextY: integer);
End;
</code>

Vegyük észre a Virtual kulcsszót a Show és a Hide eljárásnál.


===== Kérdések =====

  - Mivel dolgozunk objektum orientált programozásban?
  - Mik az osztályok?
  - Egy objektumorientált programozási nyelvben a viselkedés hogyan van leképezve?
  - Mi a különbség az osztály és az objektum között?
  - Mi a mező?
  - Mi a metódus?
  - Mi a konstruktor?
  - Mi a destruktor?
  - Mi az elérés? Milyen elérési szinteket ismer?
  - Mondjon példát, az egyes programozási nyelvekben hogyan valósítják meg az öröklést?
  - Mi a többalakúság?
  - Mi a virtuális metódus?
  - Hogyan teszünk Java nyelvben egy metódust virtuálissá?
  - Milyen metódust hívunk meg példányosításnál?
  - Milyen kulcsszót használunk példányosításnál?
  - A példányosított objektum rendelkezik az osztályok valamelyik tulajdonságával?

===== Feladatok Java megoldásokkal =====
==== Feladat 001 ====

Készítsen egy osztályt, amely járművek rendszámát és 
kivitelét tárolja. A járművek a következő kivitelűek 
lehetnek: buggi, cabrio, coupe, egyteru, ferdehatu, hot rod,
kisbusz, kombi, lépcsős hátú, moped, pickup, sedan, sport, terepjáró.
Írja meg azokat a metódusokat, amelyek lekérdezik, illetve beállítják
a két mező értékét. 
A programban vegyen fel egy példajárművet, majd határozza meg a rendszámát, 
és a kivitelét, majd írassa a képernyőre a kivitelt. 

<code java Program01.java>
class Jarmu {
	//Mezők
	private String rendszam;
	private JarmuKivitel kivitel;
	//Metódusok
	public String lekerRendszam() {
		return this.rendszam;
	}
	public void beallitRendszam(String atvettRendszam) {
		this.rendszam = atvettRendszam;
	}
	public JarmuKivitel lekerKivitel() {
		return this.kivitel;
	}
	public void beallitKivitel(JarmuKivitel atvettKivitel) {
		this.kivitel = atvettKivitel;
	}
}

enum JarmuKivitel {
	BUGGI,
	CABRIO,
	COUPE,
	EGYTERU,
	FERDEHATU,
	HOT_ROD,
	KISBUSZ,
	KOMBI,
	LEPCSOSHATU,
	MOPED,
	PICKUP,
	SEDAN,
	SPORT,
	TEREPJARO
}

public class Program01 {
	public static void main (String[] args) {
		Jarmu jarmu = new Jarmu();
		jarmu.beallitRendszam("ABC-123");
		jarmu.beallitKivitel(JarmuKivitel.MOPED);
		
		System.out.println("Példa jarmu: " + 
			jarmu.lekerKivitel() );
	}
}
</code>




==== Feladat 002 ====

Ingatlanok adatait szeretnénk nyilvántartani.
Ehhez kell egy osztályt elkészítenie.

Mit kell tárolni? Eladó vagy kiadó az ingatlan? Ár, alapterület,
szobák száma, típus: tégla, panel, csúsztatott zsalus.
Emeletek: mi felett? Szuterén, földszint, félemelet, 1,2 ..10, 10 felett
Lift: van vagy nincs. Erkély: van vagy nincs. Állapot: beköltözhető, 
építés alatt, új építésű, újszerű, felújított, közepes állapotú, 
felújítandó, jó állapotú Fűtés: gáz (cirko), gáz (konvektor), gáz (héra), 
távfűtés, távfűtés egyedi méréssel, elektromos, házközponti, 
házközponti egyedi méréssel, fan-coil, geotermikus, cserépkályha, egyéb.
Komfort: luxos, duplakomfortos, összkomfortos, komfortos, félkomfortos, komfort nélküli.

Lehetséges Java megoldás:

<code java Program01.java>
enum Status { ELADO, KIADO }
enum Tipus { TEGLA, PANEL, ZSALUS}
enum EmeletFelett { SZUTEREN, FOLDSZINT,
	FELEMELET, EGY, KETTO, HAROM, NEGY,
	OT, HAT, HET, NYOLC, KILENC, TIZ,
	TIZ_FELETT }
enum Allapot {
	BEKOLTOZHETO, EPITES_ALATT, UJ_EPITESU,
	UJSZERU, FELUJITOTT, KOZEPES, FELUJITANDO,
	JO }
enum Futes {
	GAZ_CIRKO, GAZ_KONVEKTOR, GAZ_HERA,
	TAVFUTES, TAVFUTES_EGYEDI, HAZKOZPONTI,
	HAZKOZPONTI_EGYEDI, FAN-COIL, GEOTERMIKUS,
	CSEREPKALYHA, EGYEB
}
enum Komfort {
	LUXUS, DUPLA, OSSZ, NORMAL, FEL, NINCS
}
class Ingatlan {
	Status status;
	double ar;
	int alapterulet;
	int szobakSzama;
	Tipus tipus;
	EmeletFelett emeletFelett;
	Allapot allapot;
	Futes futes;
	Komfort komfort;
}

public class Program01 {
	
	public static void main (String[] args) {
		System.out.println("Hi");
	}
}
</code>

===== Feleletválasztós feladatok =====

==== Feladat 101 ====

Adott a következő osztály:

<code java>
class Jarmu {
    String rendszam;
}
</code>

Mi a rendszam? Válasszon:
  * jellemző
  * statikus metódus
  * dinamikus metódus
  * konstruktor

==== Feladat 102 ====

Adott a következő osztály:

<code java>
class Jarmu {
    String rendszam;
    public Jarmu() {
        this.rendszam = 'ismeretlen';
    }
}
</code>

Mi a Jarmu()? Válasszon:
  * jellemző
  * statikus metódus
  * dinamikus metódus
  * konstruktor

==== Feladat 103 ====

Adott a következő osztály:

<code java>
class Jarmu {
    String rendszam;
    public Jarmu() {
        this.rendszam = 'ismeretlen';
    }
    public String lekerRendszam() {
        return this.rendszam;
    }
}
</code>

Mi a lekerRendszam()? Válasszon:
  * jellemző
  * statikus metódus
  * dinamikus metódus
  * konstruktor


===== Függelék =====

==== Hasonlat ====

| Nagy József | egy objektum |
| József születési adat | tulajdonság |
| Jóska ehet, ihat, alhat, beszélhet stb. | metódus |
| Jóska a **programozók** egy példánya | osztály |
| Jóska egy másik objektumon alapszik, \\ amit programozóknak hívnak | prototípus |
| Jóska megtartja magának a jogot, hogy \\ kiszámítsa életkorát a születési adatok alapján. | egységbezárás |
| Nem szükséges ismerni, hogy számítjuk \\ ki Jóska életkorát. | információs rejtés |
| Jóska a fejlesztői csapat része, amelybe \\ beletartozik Mari grafikus és Kati nyelvész | Absztrakció |
| Jóska, Mari és Kati a személy objektumon \\ alapszik. | Öröklés |
| Mindenki beszél, de mindenki mást mond: \\ Jóska:beszél, Mari:beszél, Kati:beszél | többalakúság |


===== Irodalom =====
==== Könyvek ====

  * Bert Bates, Kathy Sierra: Agyhullám: Java
  * Angster Erzsébet: Az objektumorientált tervezés és programozás alapjai
  * Angster Erzsébet: Objektumorientált Tervezés és Programozás - JAVA I. kötet
  * Angster Erzsébet: Objektumorientált Tervezés és Programozás JAVA II. Kötet
==== Linkek ====

  * http://spillerlaszlo.wordpress.com/programozasi-tesztek/oop/
  * http://wiki.prog.hu/wiki/Objektumorient%C3%A1lt_programoz%C3%A1s
  * http://hu.wikipedia.org/wiki/Objektumorient%C3%A1lt_programoz%C3%A1s