Öröklés. Az öröklés előnyei

"Szia, Amigo! Itt van egy téma, amit szerintem sokat fogsz használni. Az öröklésről beszélek . "

Az avatatlanok számára a programozás olyan, mint a varázslat. Tehát hadd kezdjem egy analógiával…

Tegyük fel, hogy bűvész vagy, aki repülő lovat akar alkotni. Megpróbálhatsz Pegazust varázsolni. De mivel a repülő lovak nem a természetben fordulnak elő, nagyon nehéz dolgod lesz. Nagyon sok dolgod lenne. Sokkal egyszerűbb lenne lóval kezdeni és néhány szárnyat megidézni.

A programozásban ezt a folyamatot "öröklődésnek" nevezzük . Tegyük fel, hogy egy nagyon összetett osztályt kell írnod. Hosszú ideig eltölthet kódot a semmiből, majd hosszas tesztelést végezhet a hibák feltárása érdekében. De miért kell ezt a nehezebben csinálni? Jobb, ha körülnéz, és megnézi, létezik-e már a keresett osztály?

Tegyük fel, hogy talál egy osztályt, amely megvalósítja a szükséges funkciók 80%-át. Csak bemásolhatja a kódját az osztályába. De ennek több hátránya is lenne:

1) Lehet, hogy a megtalált osztály már bájtkódba van fordítva. Lehet, hogy nem fér hozzá a forráskódjához.

2) Lehet, hogy nálad van az osztály forráskódja, de dolgozz egy olyan cégnél is, akit pár milliárdra perelhetnek, ha akár 6 sornyi kódot is használsz valaki másnak. És akkor beperelnek.

3) Ez sok kód szükségtelen megkettőzéséhez vezet. És ha a másik osztály szerzője hibát talál és kijavítja, akkor is megvan a hiba.

Létezik egy elegánsabb megoldás is, amelyhez nem szükséges jogi engedélyt szerezni az eredeti osztály kódjához. Java-ban egyszerűen deklarálhatja a másik osztályt az osztály szülőjeként. Ez egyenértékű azzal, mintha az adott osztály kódját hozzáadná a saját osztályához. A szülőosztály összes adata és metódusa megjelenik az osztályában. Például örökölhet egy „lótól”, hozzáadhat „szárnyakat”, és kaphat egy „Pegazust”.

"Nagyon érdekes. Kérem, folytassa."

"Az öröklődésnek más haszna is van. Tegyük fel, hogy tíz nagyon hasonló osztálya van. Egyező adatokkal és metódusokkal rendelkeznek. Létrehozhat egy speciális alaposztályt, áthelyezheti az adatokat ( és a kapcsolódó metódusokat) az alaposztályba , és megvan ez a tíz osztály. Más szóval, minden osztálynál jelzi, hogy van egy szülőosztálya, más néven alaposztály."

"Ahogy az absztrakció előnyei csak a tokozással kapcsolatban derülnek ki igazán, az öröklődés előnyeit felnagyítja a polimorfizmus. De erről holnap mesélek. Ma nézzünk meg néhány példát az öröklődésre."

"Tegyük fel, hogy sakkprogramot írunk. Szükségünk lesz órákra a sakkfigurákhoz. Melyik osztályokat javasolnád, Amigo?"

– Király, királyné, püspök, lovag, bástya és gyalog.

"Nagyon jó. Nem maradtál le semmiről."

– És milyen adatok tárolását javasolná ezekben az osztályokban?

"Minden darab tábla pozíciója (x és y) és értéke. Végül is egyes darabok értékesebbek, mint mások."

– És mi a különbség ezek között az osztályok között?

"Különböznek abban, hogyan mozgatják a darabokat. A viselkedésükben."

"Igen. Meghatározhatod őket ilyen osztályokként:"

class King
{
int x;
int y;
int worth;
void kingMove()
{
//code that defines,
//how the king moves
}
}

class Queen
{
int x;
int y;
int worth;
void queenMove()
{
//code that defines,
//how the queen moves
}
}

class Rook
{
int x;
int y;
int worth;
void rookMove()
{
//code that defines,
//how the rook moves
}
}

class Knight
{
int x;
int y;
int worth;
void knightMove()
{
//code that defines,
//how the knight moves
}
}

class Bishop
{
int x;
int y;
int worth;
void bishopMove()
{
//code that defines,
//how the bishop moves
}
}

class Pawn
{
int x;
int y;
int worth;
void pawnMove()
{
//code that defines,
//how the pawn moves
}
}

– Igen, pontosan így írnám.

"De nézd meg, hogyan használhatsz öröklést kevesebb kód írásához. Azonos metódusokat és adatokat áthelyezhetünk egy közös osztályba. Nevezzük ChessItemnek. Nincs értelme ChessItem objektumokat létrehozni, mivel ezek nem felelnek meg egyiknek sem. sakkfigura. De az óra rendkívül hasznos lenne:"

class King extends ChessItem
{
void kingMove()
{
//code that defines,
//how the king moves
}
}

class Queen extends ChessItem
{
void queenMove()
{
//code that defines,
//how the queen moves
}
}

class Rook extends ChessItem
{
void rookMove()
{
//code that defines,
//how the rook moves
}
}

 class ChessItem
{
int x;
int y;
int worth;
}
 

class Knight extends ChessItem
{
void knightMove()
{
//code that defines,
//how the knight moves
}
}

class Bishop extends ChessItem
{
void bishopMove()
{
//code that defines,
//how the bishop moves
}
}

class Pawn extends ChessItem
{
void pawnMove()
{
//code that defines,
//how the pawn moves
}
}

"Milyen érdekes!"

"Abszolút! Az előny különösen nagy a több ezer különböző objektumot és több száz osztályt tartalmazó projekteknél. Ebben az esetben a megfelelően kiválasztott osztályok nemcsak a logikát jelentősen leegyszerűsíthetik, hanem a szükséges kódot is tízszeresére csökkenthetik."

– Szóval mit kell tenned, hogy örökölj egy osztályt?

"Az osztály deklarálása után az ' extends ' kulcsszót használjuk , majd a szülő osztály nevét. Csak egy osztályból örökölhetsz. "

A képen egy „tehén” látható, amely egy „disznótól” örökölt. A „disznó” a „csirkéből”, a „csirke” pedig a „tojásból” örököl. Minden osztálynak csak egy szülője van! Az ilyen öröklődés nem mindig logikus. Ha csak disznója van, de nagyon szüksége van egy tehénre, a programozók gyakran nem tudnak ellenállni annak a vágynak, hogy a «disznóból» tehenet csináljanak.

"De mi van, ha két osztályból akarok örökölni? Tehetek valamit?!"

"Nem igazán. A Java osztályok nem támogatják a megvalósítás többszörös öröklését: egy osztálynak csak egyetlen szülőosztálya lehet. De létezik többszörös típusú öröklődés, ami azt jelenti, hogy egy osztály több felületet is megvalósíthat. Ez némileg enyhíti a problémát. "

"Értem. És mi az a felület?"

"Holnap mesélek az interfészekről. Egyelőre elmélyüljünk az öröklődésben."