Objekty
-------

Datový typ object = "record"

type Neco = object
       D: TypData;
       P: word;
       procedure A;  { Metody }
       function B: longint;
       constructor X(Y:byte);
       destructor Z;
     end;

procedure Neco.A;
 begin ...
 end;
...

var N: Neco;


begin

      N.A;
      with N do begin
         A;
         writeln(B)
      end;
end.


Vlastnosti:

1. Zapouzdřenost (datové složky + metody, každá datová složka je
ovladatelná POUZE vhodnou metodou!!!!!)

2. Dědičnost (schopnost převzít datové složky a metody z jiného objektu)

type Jiny = object(Neco)
       E: boolean;
       procedure A;
     end;
procedure Jiny.A;
 begin ... end;       

3. Mnohotvarost (schopnost sady objektů být ovládána stejným způsobem)

ADT a objekty:
--------------
Implementace ADT = objekt (složky= data + metody = operace).

Příklad:

type 
     TypData = string;
     UkClen = ^Clen;
     Clen = record
       D: TypData;
       dalsi: UkClen;
     end;

     seznam = object
       UkPrvni: UkClen;
       Pocet: word;
       constructor Start;
       procedure init;
       procedure add(Prvek: TypData); virtual;
       procedure remove(var Prvek: TypData);
       function Empty:boolean;
     end;

constructor Seznam.Start;
 begin
 end;

procedure Seznam.init;
 begin UkPrvni:=nil;
       Pocet:=0;
 end;

{... ostatní metody }

type UspSeznam = object(Seznam)
       constructor Start;
       procedure add(Prvek: Typdata); virtual;
     end;

constructor UspSeznam.Start;
 begin
 end;

procedure UspSeznam.add(Prvek: Typdata);
 begin {.... zařadí řetězec na správné místo }
 end;

var S:Seznam;
    R:string;
    T:UspSeznam;

procedure Zpracuj(Obecny: Seznam);

 begin  Obecny.Init;
       while not eof do begin
         readln(R);
         Obecny.add(R);
       end;
       while not Obecny.empty do begin
         Obecny.remove(r);
         writeln(r)
       end;
 end;

begin
      {S.Start; 
       Zpracuj(S);}
      T.Start;
      Zpracuj(T);
end.


Kompatibilita objektů
---------------------
Přiřazení: předchůdce:=následník

Brzká vazba
-----------
Volání metod objektů je zařízeno pevnou adresou vzniklou při překladu.

Pozdní vazba
------------
V místě volání metody se nesmí použít pevná adresa objektu, musí tam
být pouze symbolický odkaz. Ten se naplní v okamžiku přiřazení
konkrétního objektu, tedy až V DOBĚ BĚHU.

Metoda, u které je potřeba použít pozdní vazbu, musí být speciálně
označena: virtual
Pro naplnění VMT slouží spec. metoda deklarovaná klíčovým slovem
constructor;

Polymorfismus = mnohotvarost: Sada objektů musí být řetězcem dědiců,
musí mít stejné metody, musí mít tyto metody jako virtuální, 
objekty musí mít konstruktory a ty musí být volány na začátku
před prvním použitím objektu.

Dynamické objekty
-----------------
ukazatel na objekt, kompatibilita ukazatelů.

type ukobjekt = ^Neco;

var U:UkObjekt;
----
new(U);
Rozšíření new:   new(U,start); U^.add...

new použito jako funkce:
                 U:=new(Neco,Start);

Dispose(U,done)


type neco = object
       constructor Start;
       procedure Init; virtual;
       procedure Vloz(A:string); virtual;
       function Empty:boolean; virtual;
       function Vyjmi:string; virtual;
     end;
 
     dalsi = object(neco)
       constructor Start;
       procedure Init; virtual;
       procedure Vloz(A:string); virtual;
       function Empty:boolean; virtual;
       function Vyjmi:string; virtual;
     end;

procedure neco.Vloz(A:string);
 begin ... vložení do zásobníku
 end;

procedure dalsi.Vloz(A:string);
 begin ... vložení do fronty
 end;

var A:neco; B:dalsi;

procedure Delej(var X:neco);
 var R:string;
begin X.Init;
      while not eof do begin
        readln(R);
        X.Vloz(R);
      end;
      while not X.Empty do begin
        R:=X.Vyjmi;
        writeln('--',R)
      end
end;

begin A.Start; Delej(A); B.Start; Delej(B);