Tartalom

• Összehasonlító táblázat
• Az öröklés meghatározása:
• A polimorfizmus meghatározása
• Következtetés:

Az öröklődés lehetővé teszi, a kód újrafelhasználhatóságát és a polimorfizmust az, hogy egy funkció eltérő formájú. Az öröklés és a polimorfizmus közötti alapvető különbség az, hogy az öröklés lehetővé teszi a már létező kód újbóli felhasználását egy programban, és a polimorfizmus mechanizmust biztosít a dinamikusan eldöntendő függvény formájának meghatározására.

1. Összehasonlító táblázat
2. Meghatározás
3. Főbb különbségek
4. Következtetés

Összehasonlító táblázat

Az összehasonlítás alapja	Öröklés	polimorfizmus
Alapvető	Az öröklés új osztályt hoz létre a már létező osztály tulajdonságainak felhasználásával.	A polimorfizmus alapvetően többféle forma közös felülete.
Végrehajtás	Az öröklést alapvetően az osztályokon hajtják végre.	A polimorfizmust alapvetően a függvényen / módszereken valósítják meg.
Használat	Az újrafelhasználhatóság fogalmának támogatása az OOP-ban és a kód hosszának csökkentése.	Lehetővé teszi az objektum számára, hogy eldöntse, hogy a függvény mely formáját hívja meg, mikor, fordítási időben (túlterhelés), valamint futási időben (felülbírálás).
Forms	Az öröklés lehet egyetlen öröklés, több öröklés, többszintű öröklés, hierarchikus öröklés és hibrid öröklés.	A polimorfizmus lehet egy fordított idõbeli polimorfizmus (túlterhelés) vagy futásidejû polimorfizmus (felülbíráló).
Példa	Az osztályasztal örökölheti az osztálybútor tulajdonságait, mivel az asztal bútor.	Az osztálytanulmánynak rendelkeznie lehet a set_color () függvénnyel, az étkezőasztalhoz pedig a set_color () függvénnyel is, tehát a set_color () függvény meghívására melyik formája egyaránt eldönthető, összeállítási és futási időben.

Az öröklés meghatározása:

Az öröklés az OOP egyik legfontosabb jellemzője, amely erőteljesen támogatja a „újrafelhasználhatóságot”. Az újrafelhasználhatóság úgy jellemezhető, mint egy új osztály létrehozása a meglévő osztály tulajdonságainak újbóli felhasználásával. Az öröklés során létezik egy alap osztály, amelyet a származtatott osztály örökít. Amikor egy osztály örökli bármely más osztályt, akkor az alaposztály tagja (i) egy származtatott osztály tagja (i )kká válik.

Az osztály öröklésének általános formája a következő:

osztály származtatott osztálynév: hozzáférés-meghatározó alap-osztálynév {// az osztály törzse};

Itt a hozzáférés-meghatározó biztosítja a hozzáférési módot (magán, nyilvános, védett) az alaposztály tagjainak / tagjainak a származtatott osztályhoz. Ha nincs hozzáférési meghatározó, akkor alapértelmezés szerint „privátnak” tekintik. A C ++ esetén, ha a származtatott osztály „struct”, akkor a hozzáférés-meghatározó alapértelmezés szerint „nyilvános”.

A C ++ esetében az öröklés öt formában érhető el. Ezek a következők szerint osztályozhatók: -

• Egyetlen öröklés (csak egy szuper osztály)
• Több öröklés (több szuper osztály)
• Hierarchikus öröklés (egy szuper osztály, sok alosztály)
• Több öröklés (származtatott osztályból származik)

A Java-ban az osztály az „extens” kulcsszóval örököli a másik osztályt. A Java-ban az alaposztályt szuper osztálynak, a származtatott osztályt pedig alosztálynak nevezik. Az alosztály nem fér hozzá az alaposztály azon tagjaihoz, amelyeket „privátnak” nyilvánítanak. A Java formájában az osztály öröklésének általános formája a következő.

az osztály származtatott osztálynév kibővíti az alap osztály osztály nevét {// az osztály törzse};

A Java nem támogatja a többszörös öröklés öröklését, míg a többszintű hierarchiát támogatja. A Java-ban egy szuper osztály néha el akarja rejteni a megvalósítás részleteit, és az adatok egy részét „privátnak” teszi. Mint a Java-ban, az alosztály nem fér hozzá a szuperosztály magántagjaihoz, és ha egy alosztály meg akarja férni vagy inicializálni azokat, akkor a Java megoldást kínál. Az alosztály a „szuper” kulcsszóval hivatkozhat azonnali szuperosztály tagjaira. Ne feledje, hogy csak a közvetlen szuperosztály tagjaihoz férhet hozzá.

A „szuper” két általános formája van. Az első az, hogy szuper osztály kivitelezőjét hívják. A második a szuperosztály tagjának elérése, amelyet az alosztály tagja elrejtött.

// a konstruktor meghívásának első formája. osztály supper_class {supper_class (argumentumlista) {..} // a super class építője}; az al_osztály osztály a supper_osztályt bővíti {al_osztály (argumentumlista) {..} // a szuper_osztály konstruktora (argumentumlista); // az sub_class meghívja a szuper osztály kivitelezőjét}};

// második a szuper osztály supper_classához {int i; } osztály al_osztály kiterjeszti a supper_osztályt {int i; alosztály (int a, int b) {super.i = a; // i szuperosztály i = b; // i alosztály i}};

A polimorfizmus meghatározása

A polimorfizmus kifejezés egyszerűen „egy funkciót, több formát” jelent. A polimorfizmust mind fordítási, mind futási időben érjük el. Az összeállított időpolimorfizmus „túlterheléssel” érhető el, míg a futási idő polimorfizmus „felülírással” érhető el.

A polimorfizmus lehetővé teszi az objektum számára, hogy eldöntse „a függvény mely formáját kell meghívni, amikor” mindkettőn, összeállítja az időt és a futási időt.
Beszéljünk meg a túlterhelés első koncepciójáról. Túlterheléskor egy osztályban többször definiálunk egy függvényt, eltérő, adattípussal és paraméterek számával, míg a túlterhelendő függvénynek ugyanannak a visszatérési típusnak kell lennie. A túlterhelt funkciók legtöbbször az osztály konstruktorai.

osztály túlterhelés {int a, b; public: int túlterhelés (int x) {// első túlterhelés () konstruktor a = x; vissza a; } int túlterhelés (int x, int y) {// második túlterhelés () konstruktor a = x; b = y; visszatér a * b; }}; int main () {túlterhelés O1; O1.overload (20); // első túlterhelés () kivitelező hívása O1. overload (20,40); // második túlterhelés () kivitelező hívása}

Most tárgyaljuk meg a polimorfizmus második formáját, azaz az elsőbbséget. A felülbírálás fogalma csak azokra az osztályokra alkalmazható, amelyek az öröklés fogalmát is végrehajtják. A C ++ esetében a felülbírálandó funkciót az alaposztályban a „virtuális” kulcsszó előzi meg, és a származtatott osztályban újradefiniálják ugyanazzal a prototípussal, kivéve a „virtuális” kulcsszót.

osztálybázis {public: virtual void funct () {// az base class cout virtuális függvénye << "Ez egy funct () base classs osztály;" }}; class deri1: public base {public: void funct () {// az base class virtuális függvénye újradefiniálva a deri1 class cout << "Ez egy deri1 osztály funct ()"; }}; int main () {alap * p, b; származtatott1 d1; * P = & B; p-> funct (); // hívás az alaposztály funkciójára (). * P = & D1; visszatérés 0; }

1. Az öröklés olyan osztályt hoz létre, amely sajátossága egy már létező osztályból származik. Másrészt a polimorfizmus egy olyan felület, amely többféle formában meghatározható.
2. Az öröklést az osztályokon hajtjuk végre, míg a polimorfizmust módszereken / függvényeken.
3. Mivel az öröklés lehetővé teszi egy származtatott osztály számára az alaposztályban meghatározott elemek és módszerek használatát, a származtatott osztálynak nem kell meghatároznia ezeket az elemeket, vagy újra meg kell határoznia, tehát mondhatjuk, hogy ez növeli a kód újrafelhasználhatóságát, és ennélfogva csökkenti a kód hosszát . Másrészt a polimorfizmus lehetővé teszi az objektum számára, hogy eldöntse, hogy a metódus melyik formáját akarja alkalmazni mind a fordítási, mind a futási idõben.
4. Az öröklés egységes öröklés, többszörös öröklés, többszintű öröklés, hierarchikus öröklés és hibrid öröklés kategóriába sorolható. Másrészt a polimorfizmus túlterhelésnek és felülbírálónak minősül.

Következtetés:

Az öröklés és a polimorfizmus egymással összefüggő fogalmak, mivel a dinamikus polimorfizmus azokra az osztályokra vonatkozik, amelyek az öröklés fogalmát is végrehajtják.