algorytm.org

Implementacja w Delphi/Pascal

Baza Wiedzy
wersja offline serwisu przeznaczona na urządzenia z systemem Android
Darowizny
darowiznaWspomóż rozwój serwisu
Nagłówki RSS
Artykuły
Implementacje
Komentarze
Forum
Bookmarki






Sonda
Implementacji w jakim języku programowania poszukujesz?

Polecenie (command) - Implementacja w Delphi/Pascal
Ocena użytkownikóww: *****  / 1
SłabyŚwietny
Nadesłany przez Andrzej Borucki, 25 listopada 2012 11:01
Kod przedstawiony poniżej przedstawia główną część rozwiązania problemu.
Pobierz pełne rozwiązanie.

Jeżeli nie odpowiada Ci sposób formatowania kodu przez autora skorzystaj z pretty printer'a i dostosuj go automatycznie do siebie.

CommandDworak.dpr:
(****************************************
*   Wzorzec Projektowy Command          *
*   (polecenie)                         *
*   www.algorytm.org                    *
*   Kontakt                             *
*   borucki_andrzej (małpka) wp.pl      *
*   Przetłumaczył Andrzej Borucki na    *
*   podstawie przykładu Kamila Dworaka  *
*****************************************)
{$apptype console}
program CommandDworak;

uses
  SysUtils;

type
  IPolecenie = interface
    procedure wykonaj;
   	procedure cofnij;
  end;

 { obiekt wywolujacy }
 TTrener = class
 private
   mode: IPolecenie;
 public
   procedure setMode(polecenie: IPolecenie);
   procedure rozkaz;
   procedure cofnij;
 end;

{ odbiorca }
  TZawodnik = class
  private
    id: string;
  public
    constructor Create(id: string);
    procedure zacznijBiegac;
    procedure przestanBiegac;
    procedure zacznijPlywac;
    procedure przestanPlywac;
    procedure zacznijCwiczyc;
    procedure przestanCwiczyc;
  end;

  { Polecenie }
  TBieganie = class(TInterfacedObject, IPolecenie)
  private
    zawodnik: TZawodnik; //obiekt wykonujacy
  public
    constructor Create(zawodnik: TZawodnik);
    procedure wykonaj;
    procedure cofnij;
  end;

  { Polecenie }
  TPlywanie = class(TInterfacedObject, IPolecenie)
  private
    zawodnik: TZawodnik; //obiekt wykonujacy
  public
    constructor Create(zawodnik: TZawodnik);
    procedure wykonaj;
    procedure cofnij;
  end;

  TPolecenieTab = array of IPolecenie;
  { Polecenie }
  TCwiczenie = class(TInterfacedObject, IPolecenie)
  private
    zawodnik: TZawodnik; //obiekt wykonujacy
  public
    constructor Create(zawodnik: TZawodnik);
    procedure wykonaj;
    procedure cofnij;
  end;

  TPelnyTrening = class(TInterfacedObject, IPolecenie)
    tab: TPolecenieTab;
    constructor Create(tab: TPolecenieTab);
    procedure wykonaj;
    procedure cofnij;
  end;

{ TTrener }

procedure TTrener.cofnij;
begin
  mode.cofnij();
end;

procedure TTrener.rozkaz;
begin
  mode.wykonaj();
end;

procedure TTrener.setMode(polecenie: IPolecenie);
begin
  mode := polecenie;
end;

{ TZawodnik }

constructor TZawodnik.Create(id: string);
begin
  self.id:=id;
end;

procedure TZawodnik.przestanBiegac;
begin
  writeln('zawodnik ',id,' przestal biegac');
end;

procedure TZawodnik.przestanCwiczyc;
begin
  writeln('zawodnik ',id,' przestal cwiczyc');
end;

procedure TZawodnik.przestanPlywac;
begin
  writeln('zawodnik ',id,' przestal plywac');
end;

procedure TZawodnik.zacznijBiegac;
begin
  writeln('zawodnik ',id,' biega');
end;

procedure TZawodnik.zacznijCwiczyc;
begin
  writeln('zawodnik ',id,' cwiczy');
end;

procedure TZawodnik.zacznijPlywac;
begin
  writeln('zawodnik ',id,' plywa');
end;

{ TBieganie }

procedure TBieganie.cofnij;
begin
  zawodnik.przestanBiegac();
end;

constructor TBieganie.Create(zawodnik: TZawodnik);
begin
  self.zawodnik := zawodnik;
end;

procedure TBieganie.wykonaj;
begin
  zawodnik.zacznijBiegac();
end;

{ TPlywanie }

procedure TPlywanie.cofnij;
begin
  zawodnik.przestanPlywac();
end;

constructor TPlywanie.Create(zawodnik: TZawodnik);
begin
  self.zawodnik := zawodnik;
end;

procedure TPlywanie.wykonaj;
begin
  zawodnik.zacznijPlywac();
end;

{ TCwiczenie }

procedure TCwiczenie.cofnij;
begin
  zawodnik.przestanCwiczyc();
end;

constructor TCwiczenie.Create(zawodnik: TZawodnik);
begin
  self.zawodnik := zawodnik;
end;

procedure TCwiczenie.wykonaj;
begin
  zawodnik.zacznijCwiczyc();
end;

{ TPelnyTrening }

procedure TPelnyTrening.cofnij;
var
  i: integer;
  temp: IPolecenie;
begin
  for i:=High(tab) downto 0 do
  begin
     temp := tab[i];
     temp.cofnij;
  end;
end;

constructor TPelnyTrening.Create(tab: TPolecenieTab);
begin
  self.tab := tab;
end;

procedure TPelnyTrening.wykonaj;
var
  i: integer;
  temp: IPolecenie;
begin
  for i:=0 to High(tab) do
  begin
     temp := tab[i];
     temp.wykonaj;
  end;
end;

var
  trener :TTrener;
  z1,z2,z3: TZawodnik;
  bieganie: TBieganie;
  plywanie: TPlywanie;
  tab: TPolecenieTab;
  pelnyTrening: TPelnyTrening;
begin
  trener:=TTrener.Create;
  z1 := TZawodnik.Create('Kowalski');
  z2 := TZawodnik.Create('Nowak');
	z3 := TZawodnik.Create('Brzeczyszczykiewicz');

  bieganie := TBieganie.Create(z1);
	plywanie := TPlywanie.Create(z2);

  trener.setMode(bieganie);
  trener.rozkaz();
  trener.setMode(plywanie);
  trener.rozkaz();
  trener.cofnij();

  writeln;

  SetLength(tab,3);
  tab[0]:=TCwiczenie.Create(z3);
  tab[1]:=TBieganie.Create(z3);
  tab[2]:=TPlywanie.Create(z3);
  pelnyTrening := TPelnyTrening.Create(tab);
  trener.setMode(pelnyTrening);
	trener.rozkaz();
  trener.cofnij();

  z1.Free;
  z2.Free;
  z3.Free;
  trener.Free;
end.
Dodaj komentarz