is-Logo Taschenlampe V. 1.1
 

S. Spolwig
 

[Home | Unterrichtssequenzen]
Startseite

 

unit uFenster;
// ***********************************************************************
// K L A S S E : TLampenGUI
// -----------------------------------------------------------------------
// Version  : 1.1
// Autor    : S. Spolwig, 2005
//            nach einer Vorlage von Christian Steinbrucker, OSZ TIEM, Berlin
// Aufgabe  : GUI fuer die Taschenlampe
// Compiler : DELPHI 6
// Aenderung: V. 1.0 - 26-AUG-05   GUI fuer Prototyp
//               1.1 - 27-AUG-05   TLampe ausgelagert 
//                                 mit zufällig begrenzter Lebensdauer
// ***********************************************************************

/// Der Code ist unverändert


UNIT uTaschenlampe;
(* ******************************************************************** *)
(* K L A S S E : TTaschenlampe                                          *)
(* -------------------------------------------------------------------- *)
(* Version     : 1.1                                                    *)
(* Autor       :                                                        *)
(* Beschreibung: Die Klasse abstrahiert und modelliert eine Taschenlampe*)
(*               mit einer diskreten Lampe                              *)
(* Compiler    : Delphi 6.0                                             *)
(* Aenderungen : -                                                      *)
(* ******************************************************************** *)


INTERFACE
// =======================================================================

uses uLampe;

type
  TTaschenlampe = class(TObject)
   private
    Lampe    : TLampe;      // Elektriker-Deutsch, vulgo Glühbirne o.ä.
    Batterie : Boolean;
    Schalter : boolean;

   public
    constructor Create;
    procedure   Einschalten;
    procedure   Ausschalten;
    function    Leuchtet : boolean;
  end;

(* -------------------- B e s c h r e i b u n g -------------------------

Oberklasse    :
Bezugsklassen : ...........      import:


Methoden
--------

Create
  Auftrag: Erzeugen und Anfangswerte initialisieren
  vorher : -
  nachher: Batterie ist true; Schalter false

Einschalten
  Auftrag: Schalter auf true
  vorher : -
  nachher: done

Ausschalten
  Auftrag: Schalter auf false
  vorher : -
  nachher: done

Leuchtet
  Anfrage: ob die Taschenlampe 'brennt'
  vorher :
  nachher: leuchtet, wenn Lampe Licht gibt, Batterie OK und Schalter auf EIN

--------------------------------------------------------------------- *)


IMPLEMENTATION
// ====================================================================

constructor TTaschenlampe.Create;
// --------------------------------------------------------------------
begin
  inherited Create;
  Lampe := TLampe.Create;
  Batterie  := true; // drin und ok
  Schalter  := false // aus
end;


procedure TTaschenlampe.Einschalten;
// --------------------------------------------------------------------
begin
  Schalter := true;
  Lampe.Leuchten;
end;

procedure TTaschenlampe.Ausschalten;
// --------------------------------------------------------------------
begin
  Schalter := false;
end;

function TTaschenlampe.Leuchtet : boolean;
// --------------------------------------------------------------------
begin
  Result := (Lampe.GetLicht = true) AND (Batterie = true) AND (Schalter = true)       
end;

END. // -------- UNIT -------------

UNIT uLampe;
(* ******************************************************************** *)
(* K L A S S E : TLampe                                                 *)
(* -------------------------------------------------------------------- *)
(* Version     : 1.1                                                    *)
(* Autor       :                                                        *)
(* Beschreibung: Die Klasse abstrahiert und modelliert eine             *)
(*               Lampe mit zufälliger Lebensdauer, die durch die        *)
(*               angefallenen Leuchtzyklen erreicht wird                *)
(* Compiler    : Delphi 6.0                                             *)
(* Aenderungen : -                                                      *)
(* ******************************************************************** *)

INTERFACE
// =======================================================================

type
  TLampe = class(TObject)
   private
    Licht       : boolean; // leuchtet oder nicht
    Lebensdauer : integer;
    Leuchtzyklen: integer; // wie oft gebrannt hat
   
   public
    constructor Create;
    procedure   Init;
    procedure   Leuchten;
    function    IsDefekt : boolean;
    function    GetLicht : boolean;
  end;

(* -------------------- B e s c h r e i b u n g -------------------------

Oberklasse    : -
Bezugsklassen : -     import:


Methoden
--------
Create
  Auftrag: erzeugen und initialisieren
  vorher : -
  nachher: done

Init
  Auftrag: zufällige Lebensdauer bestimmen
  vorher : -
  nachher: kein Licht; Lebensdauer zwischen 0 und 5, Leuchtzyklen sind 0

Leuchten;
  Auftrag: Lampe gibt Licht, Leuchtzyklen hochzaehlen
  vorher : ist nicht defekt
  nachher: L. leuchtet

IsDefekt
  Anfrage: ob Lampe defekt ist
  vorher : L. ist init.
  nachher: true, wenn Leuchtzyklen > Lebensdauer

GetLicht
  Anfrage: ob Licht da ist (true)
  vorher : Lampe ist init.
  nachher: -

--------------------------------------------------------------------- *)

IMPLEMENTATION
// ====================================================================
constructor TLampe.Create;
// --------------------------------------------------------------------
begin
  inherited Create;
  Init;
end;

procedure TLampe.Init;
// --------------------------------------------------------------------
begin
  Randomize;
  Licht        := false;
  Lebensdauer  := Random (5);  // man weiss nicht, wie lange sie hält
  Leuchtzyklen := 0;
//  showmessage('init' +' ' +inttostr(lebensdauer) + '  ' + inttostr(Leuchtzyklen));
end;


procedure TLampe.Leuchten;
// --------------------------------------------------------------------
begin
  if NOT  IsDefekt
  then
    begin
      Licht := true;
      inc(Leuchtzyklen);
    end
  else Licht := false;
end;


function TLampe.IsDefekt;
// --------------------------------------------------------------------
begin
  Result := false;
  if Leuchtzyklen >= Lebensdauer
  then result := true;
end;

function TLampe.GetLicht : boolean;
// --------------------------------------------------------------------
begin
  Result := Licht;
end;

END. // -------- UNIT -------------



©  05. Oktober 2008    Siegfried Spolwig

page_top