Programowanie obiektowe. Wstęp.

Literatura:
Neil J. Rubenking, Understending and Programming in Object-Oriented-Pascal, PC Magazine, February 27, 1990, p. 263.

Turbo Pascal w wersji 5.5 i wyższych dopuszcza struktury typu obiekt (ang. object), które podobnie jak rekordy składają się z pól danych oraz z dodatkowych pól zawierających zgłoszenia tzw. metod, a więc funkcji i procedur operujących na tych danych. Taki sposób mieszania danych nosi nazwę enkapsulacji. Pola metod w deklaracjach object są podobne do deklaracji forward funkcji czy procedur. Część implementacyjna, a więc opis metod, pojawia się w następnej kolejności, już po ich zgłoszeniu i poza deklaracją obiektu. Nazwa obiektu kwalifikuje nazwę metody (podobnie jak nazwa pola rekordu jest na zewnątrz kwalifikowana nazwą zmiennej określonego typu rekordowego wraz z kropką i nazwą wewnętrznej pola. Np. a.x→ rekord a; pole x). Jako przykład podam krótki program (Neil J. Rubenking), który wyświetla standardowe powitanie Hello na ekranie terminala. 
TYPE
  message = OBJECT
    words : string;
    CONSTRUCTOR Init(is : String);
    PROCEDURE Say;
  END;
  CONSTRUCTOR Message.Init(is : String);
  BEGIN self.words := iS; END;
  PROCEDURE Message.Say;
  BEGIN Write(self.words); END;
VAR H: message;
BEGIN
  H.Init('OO Hello');
  H.Say
END.
Program ten deklaruje obiekt message, który składa się z pola danych o nazwie words oraz dwóch metod: Init i Say. Metoda Init zwana constructor jest specjalną metodą, która inicjuje dane typu message. Musi ona być wywołana przed użyciem obiektu. W programie Hello wywołanie to odbywa się przez 
       H.Init('OO Hello');
Dopiero po tym, łańcuch 'OO Hello' jest dostępny dla metody Say, która drukuje go. Dzieje się to w linii 
       H.Say;
Rozszerzymy teraz program Hello tak, by pokazać bardzo podstawowe mechanizmy programowania obiektowego. Załóżmy, że chcemy teraz wypisąć łńcuch 'OOP Hello' w dowolnym, ale określonym przez współrzędne, miejscu ekranu. W przypadku starego stylu programowania musieli byśmy napisać nowy program. W OOP można w prosty sposób rozszerzać istniejące programy w dowolnym kierunku.

Dziedziczenie

Następny fragment programu (Hello2.pas) jest biblioteką Turbo Pascala. Rozpoczyna go identyczna jak poprzednio deklaracja obiektu message. W następnej części zdefiniowany jest obiekt o nazwie placeMessage, którego zmiennymi są wielkości zawierające współrzędne położenia napisu na ekranie. W następnej kolejności zdefiniowano obiekt colorMessage, w którym dodatkowo zadeklarowany został kolor tekstu napisu. Wszystkie wprowadzone obiekty dotyczą napisu, lecz każdy z nich różni się od poprzedniego jakąś dodatkową cechą czy możliwością, które opisują własności napisu, a to jego położenie, a to kolor, itd. 
UNIT Hello2;
(* Turbo Pascal 5.5 version *)
INTERFACE 
USES Crt;
TYPE
  message = OBJECT
    words : String;
    CONSTRUCTOR Init(is : String);
    PROCEDURE Say; virtual;
  END;
  placeMessage = OBJECT(message)
    X, Y : Byte;
    CONSTRUCTOR InitPM(is : String; iX, iY : Byte);
    PROCEDURE Say; virtual;
  END;
  colorMessage = OBJECT(placemessage)
    color, SaveColor : Byte;
    CONSTRUCTOR InitCM(iS : String; iX, iY, iColor : Byte);
    PROCEDURE Say; virtual;
  END;
  MsPt = ^Message;
  PMpt = ^PlaceMessage;
  CMpt = ^ColorMessage;
  MsgList = ^MsgNode;
  MsgNode = RECORD
    data : MsPt;
    next : MsgList;
  END;
  List = OBJECT
    Nodes : MsgList;
    CONSTRUCTOR Init;
    PROCEDURE Add(MP : MsPt);
    PROCEDURE Show;
  END;
IMPLEMENTATION 
  CONSTRUCTOR Message.Init(iS : String);
  BEGIN self.words := iS; END;
  PROCEDURE Message.Say;
  BEGIN Write(self.words); END;
  CONSTRUCTOR
  PlaceMessage.InitPM(iS : String; iX, iY : Byte);
  BEGIN
    Message.Init(iS);
    self.X := iX;
    self.Y := iY;
  END;
  PROCEDURE PlaceMessage.Say;
  BEGIN
    GotoXY(self.X, self.Y);
    Message.Say;
  END;
  CONSTRUCTOR
     ColorMessage.InitCM(iS : String; iX, iY, iColor : Byte);
  BEGIN
    PlaceMessage.InitPM(iS, iX, iY);
    self.Color := iColor;
  END;
  PROCEDURE ColorMessage.Say;
  BEGIN
    self.SaveColor := TextAttr;
    TextAttr := self.Color;
    PlaceMessage.Say;
    TextAttr := self.SaveColor;
  END;
  CONSTRUCTOR List.Init;
  BEGIN self.Nodes := NIL; END;
  PROCEDURE List.Add(MP : MsPt);
  VAR P : MsgList;
  BEGIN
    New(P);
    P^.data := MP;
    P^.next := self.nodes;
    self.nodes := P;
  END;
  PROCEDURE List.Show;
  VAR P : MsgList;
  BEGIN
    P := self.nodes;
    WHILE P <> NIL DO
      BEGIN
        P^.data^.say;
        P := P^.next;
      END;
  END;
END.
Po słowie OBJECT, w przypadku obiektu placeMessage, umieszczone zostało w nawiasie słowo message i podobnie, po zgłoszeniu obiektu colorMessage umieszczono słowo placeMessage. Oznacza to, że zmienne typu placeMessage są wciąż zmiennymi message, tzn. dziedziczą wszystkie ich własności, a więc pola danych i metody. Podobnie pochodne zmienne typu colorMessage przejmą po swoich przodkach, w tym wypadku po obiektach message i placeMessage. Dodatkowo, zmienne te mają jeszcze inne, swoje, własności. Mamy tu taką sytuację, że typy pochodne, a więc spadkobiercy, dziedziczą po swoich przodkach pewne cechy. Nazywa się je również typami potomnymi. Typy potomne mają na ogół dodatkowe własności, inne niż ich przodkowie. Przedyskutujmy to dokładnie na przykładzie placeMessage. W porównaniu z messsage, placeMessage jest typem, który rezerwuje dwa pola (dodatkowo do pola words), w których przechowywane będą współrzędne x, y położenia napisu na ekranie. Zmieniona również została metoda constructor, która teraz nosi nazwę InitPM i może inicjować zmienne typu placeMessage. Inna jest też metoda Say. Wypisuje ona łańcuch na ekran w miejscu określonym przez x, y. Metody, które można zmieniać w typach potomnych opatruje się słowem virtual (wirtualna). Tak jest z metodą Say w obiekcie message.
Nie można zmieniać nagłówka metody wirtualnej w typie potomnym.
Metoda placeMessage.InitPm ustawia własne pola x, y. Na początku woła ona dziedziczoną metodę message.Init w celu inicjacji pola words, a następnie ustawia x, y. Metoda placeMessage.Say po przemieszczeniu kursora do miejsca ekranu (x, y) (zostały one dodatkowo opatrzone słowem Self; patrz dalej) wywołuje metodę swojego przodka message.Say aby wypisać tam dany łańcuch. Obiekt placeMessage jest przodkiem obiektu colorMessage i potomkiem pierwotnego obiektu message. Następne deklaracje w jednostce Hello2 ustalają wskazy do różnych obiektów w zadanej hierarchii oraz definiują listę połączoną wskazów do oryginalnego typu message. Ta lista staje się polem danych w obiekcie List, którego metody, dodają (Add) oraz pokazują (Show) komunikaty (messages). W OO Pascalu typy potomne są w bardzo szczególny sposób zgodne z ich przodkami. Polega to na tym, że
wskaz do zmiennej typu przodka może wskazywać zmienne wszystkich typów potomnych.
Procedura, której parametr formalny opatrzony słowem VAR jest procedurą (funkcją) przyjmie jako argument aktualny zmienną dowolnego typu potomnego (też procedurę). Obiekt zachowuje przy tym swoją indywidualność, a wywoływane metody wirtualne będą właściwymi dla niego metodami. W przykładzie Hello2 parametrami aktualnymi procedury List.Add mogą być zmienne dowolnego z trzech zadeklarowanych typów: message, placeMessage, colorMessage.

Polimorfizm

Metoda List.Show bierze kolejne elementy listy i wywołuje ich metody Say. Nie zwraca przy tym uwagi na szczegóły dotyczące obiektu. P^.data^ jest obiektem, którego typ nie nie jest znany aż do chwili wywołania. Mamy tu do czynienia z tzw. obiektem polimorficznym, o potencjalnie różnych własnościach. Jeśli kompilator napotyka na zwykłą procedurę statyczną wówczas może od razu odwołać się do konkretnego adresu. Jest to metoda tzw. wczesnego kojarzenia, lub związania (early binding). W przypadku metod wirtualnych obiektu polimorficznego, kompilator nie może z góry określić adresu. W czasie wykonywania się programu wybierana jest właściwa metoda, zależna od szczególnego typu zmiennej obiektowej. Takie kojarzenie wywołań nosi nazwę późnego.

Przykład

Program UseHello, pokazany na następnym diagramie, ilustruje zadziwiające własności obiektów polimorficznych. 
PROGRAM UseHello;
(* 5.5 *)
USES Crt, hello2;
TYPE
  MMpt = ^MovingMessage;
  MovingMessage = OBJECT(ColorMessage)
    width : Byte;
    CONSTRUCTOR InitMM(iS : String; iX, iY, iColor, iWid : Byte);
    PROCEDURE Say; virtual;
  END;
  CONSTRUCTOR
  MovingMessage.InitMM(iS : String; iX, iY, iColor, iWid : Byte);
  BEGIN
    ColorMessage.InitCM(iS, iX, iY, iColor);
    self.width := iWid;
  END;
  PROCEDURE MovingMessage.Say;
  VAR marquee : String;
    P : Byte;
  BEGIN
    FillChar(marquee, SizeOf(marquee), ' ');
    marquee[0] := chr(self.width);
    P := 1;
    self.SaveColor := TextAttr;
    TextAttr := self.color;
    REPEAT
      GotoXY(self.X, self.Y);
      Write(marquee);
      MOVE(marquee[2], marquee[1], pred(self.width));
      marquee[self.width] := self.words[P];
      P := succ(P MOD length(self.words));
      sound(20); Delay(60); NoSound;
      delay(75);
    UNTIL KeyPressed;
    TextAttr := self.SaveColor;
  END;
VAR
  TheList : List;
BEGIN
  ClrScr;
  TheList.Init;
  TheList.Add(new(MMpt, InitMM('  O O P !  ', 9,16,1C,60)));
  TheList.Add(new(CMpt, InitCM(′Hello in living color! ′, 20,10,4E)));
  TheList.Add(new(PMpt, InitPM('Hello from down under ',1,25)));
  TheList.Add(new(MsPt, Init('Hello, World! ')));
  TheList.Show;
END.
Program UseHello korzysta wprost z biblioteki Hello2,. Deklaruje on dodatkowy typ, obiekt movingMessage, który jest rozszerzeniem obiektu colorMessage. Obiekt ten nie istniał w bibliotece Hello2 w momencie jej kompilacji, a więc w chwili tworzenia modułu Hello2.tpu. Mimo to, metody List.Add oraz List.Show radzą sobie ze zmiennymi nowego typu! Ma tu miejsce zgodność typów potomnych z ich przodkami. Zwróćmy uwagę na użycie procedury New. Jeśli chcemy umieściś w pamięci komputera zmienną dynamiczną z jej metodami wirtualnymi to procedurę New wywołujemy z parametrami, którymi są nazwa obiektu i konstruktor tego obiektu. Np. 
      New(MojObiekt, Init(1, 2, 3);)
Po drugie, można używać New z argumentem typu pointer tak jakby była to funkcja, zwracająca wskaz do zmiennej danego typu. Można więc tworzyć wskazy i przekazywać je jako parametry bez potrzeby tworzenia i inicjowania zmiennych tymczasowych.

Podsumowanie

Program Hello ilustruje cztery podstawowe własności programowania obiektowego, którymi są:

Zadanie 1: Napisz program Pomocnik, który na podstawie zadanego numeru wyświetla linię tekstu dowolnej długości. Taki program może zarządzać bazą, która zawiera te linie tekstu (może je więc dodawać, usuwać, wypisać). Wykorzystaj OOP.

Parametr Self

Załóżmy, że w programie występuje definicja typu rekordowego (Marciniak) 
type nowe_xy=record
        x, y: integer;
        kolor: byte;
     end;
oraz definicja typu obiektowego 
type xy=object
        x, y: integer;
        procedure wspolrzedne(punkt: nowe_xy)
     end;
Zadaniem metody współrzędna jest przypisanie wartości pól x, y rekordu nowe_xy polom x, y obiektu xy. W celu uniknięcia konfliktu identyfikatorów definicja metody powinna być następująca: 
procedura xy.wspolrzedne(punkt: nowe_xy);
begin
   with punkt do begin
        Self.x:=x;
        Self.y:=y
   end
end;
Wystąpił tu parametr Self, wskazujący na to, że x i y z lewej strony instrukcji przypisania; są to własne pola x i y obiektu (nie pola rekordu xy), w którym znajduje się metoda. Zaznaczyć należy, że jeśli nie używa się instrukcji wiążącej with to parametr Self nie jest konieczny. 
procedure xy.wspolrzedne(punkt: nowe_xy);
begin
   x:=punkt.x;
   y:=punkt.y;
end;

File translated from TEX by TTH, version 4.03.
On 16 Oct 2013, 21:50.