Deklarace statické a virtuální pedefinované metody – Pascal – Fórum – Programujte.com

Zdravím

Připravuji se na písemku z OOP, které se učíme na programovacím jazyku Pascal. Narazil jsem na několik věcí, na které jednoduše neumím odpovědět a v podpoře jsem nenašel odpověď. Zeptám se tedy, zda mi umí někdo pomoci. Otázky které řeším jsou:

1. Definujte Polymorfismus metod, uveďte deklaraci statické předefinované metody
2. Definujte Polymorfismus metod, uveďte deklaraci virtuální předefinované metody

Mohu poprosit, napíše zdě někdo ony dvě deklarace, případně ještě nějaké shrnutí definice polymorfismu z první části otázky? V podpoře máme k Polymorfismu toto:

Víme, že

•je možno využít dědičnosti k dědění atributů i metod z předka na potomka;
•je možno přidávat nové atributy i metody k potomkovi,
•je možno předefinovat implementaci metody předka tak, aby vyhovovala potomkovi a přitom zachovat stejný název metody (metoda potomka může mít atributy navíc nebo i jiné chování – to nazýváme předefinováním metody);
•která verze stejnojmenné metody se volá, to určují pravidla: volá se metoda volajícího objektu, pokud tam neexistuje, pak se hledá postupně u svých předků od vlastní třídy směrem ke kořeni hierarchie.

Vlastnost OOP použít  stejný název metody pro různé implementace nazýváme polymorfismem.

•u polymorfních metod můžeme použít ještě další způsob, jak změnit nebo upravit chování metody, a to přetěžování;
•konečně u polymorfních metod může nastat nový problém, pokud uvnitř volají jiné metody – uvedeme příště;
•polymorfní mohou být metody nebo celé objekty, ty uvedeme později.

Nějak si z toho neumím udělat myšlenku, kterou bych na písemce vyjádřil jednou až dvěma větami a dávalo to obsahově smysl.

Statické předefinování znamená, že si v potomkovi nadefinuješ metodu se stejným názvem, jako měla nějaká metoda některého předka. Normálně pomocí klíčového slova procedure, bez dalších upřesnění. Tím tu původní zděděnou metodu předefinuješ novou verzí (může mít i úplně jiné parametry).

Polymorfismus znamená, že si v potomkovi nadefinuješ metodu se stejným názvem, jako měla nějaká metoda některého předka, a s přesně stejnými parametry. Za hlavičku jí navíc přidáš klíčové slovo virtual a objekt před prvním použitím inicializuješ metodou, která místo klíčového slova procedure používá slovo constructor.

Rozdíl je v tom, že polymorfní metodu potomka můžeš volat pomocí ukazatele na předka, zatímco ke staticky předefinovaným metodám se nedostaneš.

Příklad na statické předefinování metody:

type bod = object
           x,y:integer;
           procedure init(nx,ny:integer);
           procedure kresli;
           end;

procedure bod.init(nx,ny:integer)
Begin
x:=nx; y:=ny;
End;

procedure bod.kresli;
Begin
putpixel(x,y,15); {15 je bila barva}
End;

type BarevnyBod = object(bod)
                  barva:byte;
                  procedure init(nx,ny:integer; nbarva:byte);
                  procedure kresli;
                  end;

procedure barevnybod.init(nx,ny:integer; nbarva:byte);
Begin
bod.init(nx,ny);
barva:=nbarva;
End;

procedure barevnybod.kresli;
Begin
putpixel(x,y,barva);
End;

var b:bod;
    bb:barevnybod;
    ukazatel:^bod;

BEGIN
...
b.init(10,20);
bb.init(30,40,3);
ukazatel:=addr(b);
ukazatel^.kresli; {vykresli bod b}
ukazatel:=addr(bb);
ukazatel^.kresli; {chyba - nelze}...

Příklad na polymorfní metodu (rozdíly jsou jenom v několika slovech, zvýraznit to tu bohužel nijak nejde):

type bod = object
           x,y:integer;
           constructor init(nx,ny:integer);
           procedure kresli; virtual;
           end;

constructor bod.init(nx,ny:integer)
Begin
x:=nx; y:=ny;
End;

procedure bod.kresli;
Begin
putpixel(x,y,15);
End;

type BarevnyBod = object(bod)
                  barva:byte;
                  constructor init(nx,ny:integer; nbarva:byte);
                  procedure kresli; virtual;
                  end;

constructor barevnybod.init(nx,ny:integer; nbarva:byte);
Begin
bod.init(nx,ny);
barva:=nbarva;
End;

procedure barevnybod.kresli;
Begin
putpixel(x,y,barva);
End;

var b:bod;
    bb:barevnybod;
    ukazatel:^bod;

BEGIN
...
b.init(10,20);
bb.init(30,40,3);
ukazatel:=addr(b);
ukazatel^.kresli; {vykresli bod b}
ukazatel:=addr(bb);
ukazatel^.kresli; {v poradku, vykresli bod bb}
...

Praktické využití? Můžeš mít třeba pole dynamicky alokovaných objektů. I když je každý jiného typu, můžeš celé pole zpracovávat jednoduchým cyklem a voláním jedné metody. U každého se automaticky použije ta správná.

Kdyby byly metody staticky předefinované, volala by se vždycky jenom ta původní od společného předka, bez ohledu na skutečný typ jednotlivých objektů.

Neručím za 100% správnost výše uvedeného, už jsem to dlouho nepoužíval. Bezpečnější bude mrknout na http://mircosoft.mzf.cz/texty/OOP.TXT ; to jsem psal, když jsem měl OOP ještě v čerstvé paměti.