unit uFenster;
// ***********************************************************************
// K L A S S E : TLampenGUI
// -----------------------------------------------------------------------
// Version : 1.2
// 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 Die Fachklasse TTaschenlampe ausgelagert
// gemäß MVC-Pattern
// 1.1 - 27-AUG-05 TLampe ausgelagert
// 1.2 - 06-SEP-05 TBatterie ausgelagert, liefert konst. Spannung
// TGluehlampe - Unterklasse
// ***********************************************************************
//// Der Rest ist unverändert ///
|
|
UNIT uTaschenlampe;
(*
********************************************************************
*)
(* K L A S S E : TTaschenlampe
*)
(*
--------------------------------------------------------------------
*)
(* Version : 1.2
*)
(* Autor :
*)
(* Beschreibung: Die Klasse abstrahiert und modelliert eine
Taschenlampe*)
(*
mit einer diskreten Gluehlampe und einer Batterie.
*)
(* Compiler : Delphi 6.0
*)
(* Aenderungen : V. 1.2 -
TGluehlampe, TBatterie
*)
(*
********************************************************************
*)
INTERFACE
//
=======================================================================
uses uGluehLampe, uBatterie;
type
TTaschenlampe = class(TObject)
private
Lampe : TGluehLampe;
Batterie : TBatterie;
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 initialisieren
vorher :
nachher:
Einschalten
Auftrag: Schalter auf ein und Lampe mit Batteriespannung versorgen
vorher :
nachher: done
Ausschalten
Auftrag: Schalter auf aus und Spannung an der Lampe auf 0
vorher :
nachher: done
Leuchtet
Anfrage: ob die Taschenlampe 'brennt'
vorher :
nachher: leuchtet, wenn Lampe Licht gibt und Lampenspannnung > 0 und
Schalter auf EIN
---------------------------------------------------------------------
*)
IMPLEMENTATION
//
====================================================================
constructor TTaschenlampe.Create;
//
--------------------------------------------------------------------
begin
inherited Create;
Lampe := TGluehLampe.Create;
Batterie := TBatterie.Create;
Schalter := false // aus
end;
procedure TTaschenlampe.Einschalten;
//
--------------------------------------------------------------------
begin
Schalter := true;
Lampe.SetSpannung(Batterie.GetSpannung);
end;
procedure TTaschenlampe.Ausschalten;
//
--------------------------------------------------------------------
begin
Schalter := false;
Lampe.SetSpannung(0);
end;
function TTaschenlampe.Leuchtet : boolean;
//
--------------------------------------------------------------------
begin
Result := (Lampe.GetLicht = true) AND (Lampe.GetSpannung
> 0) AND (Schalter = true);
end;
END. // -------- UNIT ------------- |
|
|
UNIT uLampe;
(* ******************************************************************** *)
(* K L A S S E : TLampe *)
(* -------------------------------------------------------------------- *)
(* Version : 1.2 *)
(* 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)
protected // damit alles an Unterklassen vererbt werden kann
Licht : boolean; // leuchtet oder nicht
Lebensdauer : integer;
Leuchtzyklen: integer; // wie oft gebrannt hat
.... |
//// Der Rest ist unverändert ///
|
|
UNIT uGluehlampe;
(* ******************************************************************** *)
(* K L A S S E : TGluehlampe *)
(* -------------------------------------------------------------------- *)
(* Version : 1.2 *)
(* Autor : *)
(* Beschreibung: Die Klasse abstrahiert und modelliert eine Lampe, die *)
(* zum Leuchten eine Spannung > 0 braucht *)
(* *)
(* Compiler : Delphi 6.0 *)
(* Aenderungen : - *)
(* ******************************************************************** *)
INTERFACE
// =======================================================================
uses uLampe;
type
TGluehlampe = class (TLampe) // erbt alles von TLampe
private
Spannung : double;
public
constructor Create;
procedure SetSpannung (u : double);
function GetSpannung : double;
end;
(* -------------------- B e s c h r e i b u n g -------------------------
Oberklasse : TLampe
Bezugsklassen : - import:
Methoden
--------
Create
Auftrag: Lampe erzeugen und init.
vorher : -
nachher: Spannung ist 0 V
SetSpannung
Auftrag: Lampe mit Strom versorgen und leuchten lassen
vorher : -
nachher: Leuchtet wenn Spannung > 0
Get...
Auftrag: Attribut aus dem Objekt lesen
vorher : Objekt ist init.
nachher: -
--------------------------------------------------------------------- *)
IMPLEMENTATION
// ====================================================================
constructor TGluehlampe.Create;
// --------------------------------------------------------------------
begin
inherited Create;
Spannung := 0;
end;
procedure TGluehlampe.SetSpannung (u : double);
// --------------------------------------------------------------------
begin
Spannung := u;
if Spannung > 0
then Leuchten;
end;
function TGluehlampe.GetSpannung : double;
// --------------------------------------------------------------------
begin
Result := Spannung;
end;
END. // -------- UNIT ------------- |
|
|
UNIT uBatterie;
(* ******************************************************************** *)
(* K L A S S E : TBatterie *)
(* -------------------------------------------------------------------- *)
(* Version : 1.2 *)
(* Autor : *)
(* Beschreibung: Die Klasse abstrahiert und modelliert eine Batterie *)
(* mit 1.5 V *)
(* Compiler : Delphi 6.0 *)
(* Aenderungen : - *)
(* ******************************************************************** *)
INTERFACE
// =======================================================================
type
TBatterie = class(TObject)
private
Spannung : double;
public
constructor Create;
function GetSpannung : double;
end;
(* -------------------- B e s c h r e i b u n g -------------------------
Oberklasse :
Bezugsklassen : ........... import:
Methoden
--------
Create
Auftrag: Erzeugen und Anfangsspannung festlegen
vorher :
nachher: Spannung ist 1.5 V.
Get...
Auftrag: Attribut aus dem Objekt lesen
vorher : Spannung ist init.
nachher: -
--------------------------------------------------------------------- *)
IMPLEMENTATION
// ====================================================================
constructor TBatterie.Create;
// --------------------------------------------------------------------
begin
inherited Create;
Spannung := 1.5;
end;
function TBatterie.GetSpannung : double;
// --------------------------------------------------------------------
begin
Result := Spannung;
end;
END. // -------- UNIT ------------- |
|
