Konstanten im Interface

[Der schöne Günther]

In Delphi können Interfaces keine Konstanten haben, oder?

Ja, es sind in der Regel Implementations-Details die dort nicht hineingehören. Ich ziehe Standard-Belegungen für Parameter immer gerne in Konstanten raus:

Delphi-Quellcode:

TSomeClass = class
   private const
      Param_someProc_someParam = 12;
   public
      procedure someProc(const someParam: Integer = Param_someProc_someParam);
end;

In einem Interface bleibt mir nur

Delphi-Quellcode:

ISomeInterface = interface
   procedure someProc(const someParam: Integer = 12);
end;

Oder?

[himitsu]

Zitat von Der schöne Günther:

In Delphi können Interfaces keine Konstanten haben, oder?

Wie wäre es mit Ausprobieren?

(ich glaub zwar nicht, wobei aber z.B. Property möglich sind, obwohl Interfaces sowas eigentlich auch nicht haben)

public, protected und private gibt es allerdings leider auch nicht, wobei man das private via Interface-Vererbung indirekt nutzen kann, um z.B. das "private" vor der Codevervollständigung zu verstecken.

[Thom]

Eine Möglichkeit:

Delphi-Quellcode:

  TSomeBaseClass = class(...)
  private const
    Param_someProc_someParam = 12;
  end;

  ISomeInterface = interface
    procedure someProc(const someParam: Integer = TSomeBaseClass.Param_someProc_someParam);
  end;

  TSomeClass = class(TSomeBaseClass,ISomeInterface)
  public
    procedure someProc(const someParam: Integer = TSomeBaseClass.Param_someProc_someParam);
  end;

[Der schöne Günther]

Natürlich habe ich selbst probiert und gesucht.

Properties helfen einem für Default-Parameter nicht weiter.

Das mit "private" und Interface-Vererbung verstehe ich nicht. Hast du ein Beispiel?


Thom, das Interface von der Klasse abhängig zu machen ist keine gute Idee. Aber: Deine TSomeBaseClass macht doch noch einmal deutlich, dass die Parameterbelegung eine Implementierungseigenschaft ist: Die implementierende Klasse kann einen Standardwert vorgeben, selbst wenn das Interface kein vorgibt!

Da hatte ich irgendwie ein Brett vorm Kopf

[Thom]

Du hattest doch selbst die Idee, die Konstante in der (implementierenden) Klasse unterzubringen. Willst Du das nicht, dann definier doch einfach eine globale Konstante:

Delphi-Quellcode:

const
  Param_someProc_someParam = 12;

type
  ISomeInterface = interface
    procedure someProc(const someParam: Integer = Param_someProc_someParam);
  end;

  TSomeClass = class(...,ISomeInterface)
  public
    procedure someProc(const someParam: Integer = Param_someProc_someParam);
  end;

Zitat von Der schöne Günther:

Die implementierende Klasse kann einen Standardwert vorgeben, selbst wenn das Interface kein vorgibt!

Falls das eine Frage war: Ja.

Delphi-Quellcode:

type
  ISomeInterface = interface
    procedure someProc(const someParam: Integer);
  end;

  TSomeClass = class(...,ISomeInterface)
  private type
    Param_someProc_someParam = 12;
  public
    procedure someProc(const someParam: Integer = Param_someProc_someParam);
  end;

[himitsu]

Delphi-Quellcode:

  ISomeInterface = interface
  {private} const
    Param_someProc_someParam = 12;
  private  // geht nicht
    function MyGetter: Integer;
    procedure MySetter(Value: Integer);
    function MyGetter2(Index: Integer): Integer;
    procedure MySetter2(Value, Index: Integer);
  public
    procedure someProc(const someParam: Integer = Param_someProc_someParam);
    property MyProperty: Integer read MyGetter write MySetter;  // geht
    property MyProperty2: Integer index 1 read MyGetter write MySetter;  // Index geht nicht
    property MyProperty3: Integer index 2 read MyGetter write MySetter;
  end;

Delphi-Quellcode:

  TSomeClass = class(TSomeBaseClass,ISomeInterface)
  public
    procedure someProc(const someParam: Integer = TSomeBaseClass.Param_someProc_someParam);
  end;

Wenn du die Klasse nur als Interface brauchst, dann kannst du in der Klasse auch den Default-Wert weglassen.

Ansonsten ist die Idee von Thom eh besser, also die Konstante in einer Klasse zu definieren und in beiden Definitionen (Interface und Klasse) die selbe Konstante zu nutzen,
wobei TSomeClass nicht unbedingt von TSomeBaseClass abgeleitet sein muß.


PS: Die Benamung von Param_someProc_someParam finde ich etwas unglücklich.
Was ist, wenn diese Konstante auch an anderen Stellen verwendet wird?
Da wäre es ja eigentlich besser die "Funktion" als Namen zu nehmen und nicht den Ort.

[jaenicke]

Zitat von Der schöne Günther:

In Delphi können Interfaces keine Konstanten haben, oder?

Es wäre mir neu, dass das in anderen Sprachen bei Interfaces geht.

[himitsu]

Aber prinzipiell gibt es keinen Grund, warum es in Gelphi nicht gehen sollte.

Die Konstanten werden ja zur CompileTime aufgelöst und sind dann, zur Laufzeit, letztendlich nicht mehr im Interface vorhanden.

[Der schöne Günther]

Zitat von jaenicke:

Zitat von Der schöne Günther:

In Delphi können Interfaces keine Konstanten haben, oder?

Es wäre mir neu, dass das in anderen Sprachen bei Interfaces geht.

Also in Java sehe ich das relativ häufig. Immer wieder spaßig wenn zwei implementierte Interfaces auch noch jeweils eine Konstante mit dem selben Namen haben


Konstanten habe ich Delphi sowieso noch nicht so ganz verstanden. Ich vermisse bsp. immer noch ein bisschen, die Konstanten eines Objekts erst im Konstruktor setzen zu können. In C++ geht das ja über den Element-Initialisierer...

[mjustin]

Zitat von jaenicke:

Zitat von Der schöne Günther:

In Delphi können Interfaces keine Konstanten haben, oder?

Es wäre mir neu, dass das in anderen Sprachen bei Interfaces geht.

In Java hat die Möglichkeit, innerhalb einer Interface-Deklaration auch Konstanten zu definieren, immer schon bestanden. Es macht auch Sinn, da es ermöglicht, Zusammengehörendes gemeinsam zu definieren.

Code:

public interface GroupedInterface extends Interface1, Interface2, Interface3 {

    // constant declarations
    
    // base of natural logarithms
    double E = 2.718282;
 
    // method signatures
    void doSomething (int i, double x);
    int doSomethingElse(String s);
}

http://docs.oracle.com/javase/tutori...erfaceDef.html