Objektum orientáltság és öröklés (Félkész)

Az objektumorientáltság definíciója

…

Öröklés

Az öröklés egy olyan OOP (objektum-orientált programozás) koncepció, amely lehetővé teszi egy osztály számára, hogy örökölje egy másik osztály tulajdonságait és viselkedését.

Az öröklés lehetővé teszi, hogy új osztályokat hozzunk létre, amelyek öröklik az összes tulajdonságot és metódust a szülőosztályból, és kiegészíthetjük vagy felülírhatjuk azokat a saját igényeink szerint.

Ősosztály mint gyűjtőfogalom

Érdemes úgy gondolni az öröklésre mint kategorizálás.

Képzeljünk el, hogy egy olyan programot írunk amiben létezik egy Car auto és egy Ship hajó osztályunk.

Könnyen lehet, hogy ezen osztályoknak nagyon hasonló tulajdonságaik és metódusaik vannak. Pl. mind a kettőnek van sebesség, jelenlegi helyzet és végállomás field-je és mindkettőnek egy void void ToDestination() metódusa ami elmegy a célba a lehető legoptimálisabb útvonalon.

Előbb utóbb nagyon sok teljesen megegyező kód van mindkét osztályban. Ez kód-duplikáció és erősen kerülendő.

Átstrukturálhatjuk viszont a kódot. Létrehozhatunk egy Vehicle jármű ősosztályt és az autó és a hajó úgymond leszármazhat tőle, ami azt jelenti, hogy az autó és hajó a jármű kategóriába tartozik.

A gyakorlatban ekkor a két eredeti osztály kódjának azon része, ami megegyezett áttesszük a szülőbe. Azon kódrészleteket, amik egyediek meghagyunk a gyerek osztályokban.

Ezért érdemes inkább a kategorizálásként tekinteni az öröklésre:

Minden autó jármű, de nem minden jármű autó. Ez a kódban így fest.

Car myCar= new Car();
Ship myShip = new Ship();

myCar.speed = 90f;
myCar.Drive();

// Ha a Car és a Ship is leszármazik a Vehicle osztályból
// akkor, egy Vehicle változó tárolhat Car és Ship objektumot is.

Vehicle vehicle = myCar;
vehicle = myShip;

// Járművek egy tömbej:
Vehicle[] vehicles = {myCar, myShip};

foreach(Vehicle v in vehicles )
	v.GoToDestinationast();        // Minden vehicle-nek van ilyen metódusa.
																 // függetlenül, hogy az autó, hajó, vagy bármi egyéb

Az öröklés több szintű is lehet. Például az autóból leszármazhat a személyautó, teherautó és a busz függően attól, hogy mit kíván meg az adott szoftver.

Örökölni az osztály definiálásánál a : (kettőspont) operátorral tudunk.

class Car : Vehicle { ... }

Örökölni csak osztályok tudnak más osztályokból, egyéb adattípusok (enum-ok, struktúrák) nem örökölnek.

Jelenleg csak ennyit tanulunk az öröklésről, ami igazából csak épp a felszíne a témának, de a kurzusra elég lesz.

Példák Unity komponensek örökélésre

TODO:

Minden Unity komponens leszármazik a Component osztályból beleértve a saját általunk írt MonoBehaviour szkripteket is.

Absztrakció fogalma

Az absztrakció a szoftvertervezésben egy összetett rendszer egyik szintjére utal. Általa el lehet rejteni egy adott rendszer belső részleteit.

Például mikor egy RigidBody-nak AddForce metódussal egy erőt közlünk akkor a testet mozgásba hozzuk és a fizikai rendszer vezényli. Hogy ezt hogyan teszi meg a Unity fizika, azzal nem kell foglalkozni azon az absztrakciós szinten, ahol az erőt adjuk, ami a játéklogikával kapcsolatos.

Ha mi magunk írnánk meg ezt a fizikai rendszert, akkor meg kéne adnunk, hogy minden FixedUpdate-ben lépjünk előre a sebességvektor függvényében és azt, hogy a sebességvektor hogyan változzon az AddForce függvény hatására.

Ha még egy szinttel lejjebb lépünk, akkor elképzelhetjük, hogy a Vektor osztályt kell megírnunk és definiálnunk rá a már jól ismert műveleteket. Ekkor meg nem kéne azzal foglalkozni, hogy a Fizikai rendszer vagy bármi egyéb hogyan fogja azt felhasználni.

És így tovább mehetnénk lejjebb és lejjebb, hogy működi a progamozási nyelv, vagy akár a hardware maga.

Az absztrakció segít egyszerűsíteni és strukturálni a komplex rendszereket, és lehetővé teszi, hogy a felhasználók vagy más fejlesztők könnyedén használhassák azt, anélkül hogy meg kellene érteniük az adott implementációs részleteket.

A szoftverfejlesztő legnagyobb ellensége a komplexitás. Az absztrakció előnye, hogy megkönnyíti a szoftver átláthatóságát. Egyszerre mindig csak egy absztrakciós szintjét kell átlátni egy összetett problémának, csak erre az egy szintre koncentrálunk. Nem érdekel minket ekkor, hogy alacsonyabb szinteken hogyan működnek az eszközök, amiket éppen használunk és az sem, hogy a most készülő absztrakciós szintet feljebb hogyan fogják majd felhasználni.

Hogyan működik?

…