Propertys bei Vererbung

[Jumpy]

Hallo,
und gleich nochmal eine Frage,

ich will in einer abstrakten Basisklasse auch einige Propertys implementieren.

In allen abgeleiteten Klassen soll das auslesen der Property möglich sein, die getProperty-Funktion würde natürlich in jeder Klasse indivivuell implementiert.

In nur manchen Klassen aber soll auch das setzten dieser Property möglich sein!

Wie und wo (private/Protected/Public wann read wann write) muss ich denn das deklarieren? Geht das überhaupt?
Oder muss ich auch allen Klassen eine setProperty spendieren, die dann aber ggf. bei manchen Klassen nichts macht?

[Bummi]

Vielleicht meinst Du etwas in der Art?

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type

  TBaseClass=Class
    protected
    function GetValue: Integer; virtual;
    Procedure SetValue(aValue:Integer);virtual ;
    published
    Property Value:Integer read GetValue;
  End;

  TFirstClass=Class(TBaseClass)
    private
    FValue:Integer;
    protected
    function GetValue: Integer;override;
    Constructor Create;
  End;

  TSecondClass=Class(TBaseClass)
    private
    FValue:Integer;
    protected
    function GetValue: Integer;override;
    Procedure SetValue(aValue:Integer);override;
    published
    Property Value:Integer read GetValue write SetValue;
  End;

  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TBaseClass }


{ TFirstClass }

constructor TFirstClass.Create;
begin
  inherited;
  FValue := 17;
end;

function TFirstClass.GetValue: Integer;
begin
   Result := FValue;
end;

{ TSecondClass }

function TSecondClass.GetValue: Integer;
begin
  Result := FValue;
end;

procedure TSecondClass.SetValue(aValue: Integer);
begin
  inherited;
  FValue := aValue;
end;

{ TBaseClass }

function TBaseClass.GetValue: Integer;
begin
//
end;

procedure TBaseClass.SetValue(aValue: Integer);
begin
  Showmessage('Set Value from base')
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
   With TFirstClass.Create do
    try
      // Value := 13; geht nicht
      Showmessage(IntToStr(value));
    finally
      free;
    end;
   With TSecondClass.Create do
    try
      Value := 13;
      Showmessage(IntToStr(value));
    finally
      free;
    end;

end;

end.

[Sir Rufo]

In der Basis-Klasse würde ich die property komplett verstecken und Getter/Setter als abstract definieren:

Delphi-Quellcode:

type

  TBaseClass=Class
    protected
      function GetValue: Integer; virtual; abstract;
      Procedure SetValue(aValue:Integer); virtual; abstract; 
      Property Value : Integer read GetValue;
  End;

  TFirstClass=Class(TBaseClass)
    private
      FValue:Integer;
    protected
      function GetValue: Integer;override;
      Constructor Create;
    published
      property Value; // so gibt es nur lesenden Zugriff
  End;

  TSecondClass=Class(TBaseClass)
    private
      FValue:Integer;
    protected
      function GetValue: Integer;override;
      Procedure SetValue(aValue:Integer);override;
    published
      Property Value:Integer read GetValue write SetValue;
  End;

[DeddyH]

Dann musst Du den Setter aber in TFirstClass trotzdem überschreiben.

[Der schöne Günther]

Exakt das gleiche Problem hatte ich gestern auch, kam allerdings nie auf die Idee, die Property selbst in der Unterklasse zu ... was eigentlich? Methoden lassen sich überschreiben, Felder (zumindest in den Sprachen die ich kenne) nicht.

[Jumpy]

Zitat von Bummi:

Vielleicht meinst Du etwas in der Art?

Ja genau darauf wollte ich hinaus. Danke euch beiden. Ich pflege meistens nut ALtlasten und komme zu selten in die Verlegenheit was neues machen zu dürfen und dann bin ich immer mal wieder verwirrt von den Sichtbarkeitsstufen, vor allem im Zusammenhang: Stehen die Klassen in einer Unit, oder in getrennten Units.

Wobei bei mir beim Durchlesen eurer Varianten doch die Frage aufgekommen ist, ob ich nicht doch statt Vererbung von einer Basisklasse die Klassen lieber ein Interface implementieren lassen soll. Die Klassen sind nämlich nicht wirklich ähnlich. Sie sollen nur bestimmte Eigenschaften gemeinsam haben bzw. nach aussen tragen, die die GUI später braucht um das darzustellen, z.B. einen Status oder Informationen zum Fortschritt, sowas in der Art.

[Sir Rufo]

Zitat von DeddyH:

Dann musst Du den Setter aber in TFirstClass trotzdem überschreiben.

Wieso, gibt ja nur eine Warnung

So reicht das auch (wenn man die Eigenschaft um einen Setter erweitern möchte)

Delphi-Quellcode:

type
  TBase = class
  protected
    function GetValue : string; virtual; abstract;
    procedure SetValue( const Value : string ); virtual; // ok, dann eben nur virtual :o)
    property Value : string read GetValue;
  end;

  TFirst = class( TBase )
  protected
    function GetValue : string; override;
  published
    property Value;
  end;

  TSecond = class( TBase )
  private
    FValue : string;
  protected
    function GetValue : string; override;
    procedure SetValue( const Value : string ); override;
  published
    property Value write SetValue; // der Getter wird geerbt :o)
  end;