Tachchen,

wieso müssen bei Class-Property die Getter/Setter eigentlich Static-Class-Methods sein?

markieren

Delphi-Quellcode:

class function MyGetter: TObject; {static}
class property MyClass: TObject read MyGetter; //verlangt static

Aber durch Static gibt es dann kein Self mehr und man kann nicht mehr den Klassentyp einer abgeleiteten Klasse auslesen.

Zitat:

A class field is shared between two classes that are related by inheritance. So that cannot be used for polymorphism. And a class static method also cannot supply polymorphic behaviour.

Use a virtual class function rather than a class property.

Quelle: http://stackoverflow.com/a/11013542/2298252

Kann man wohl nichts machen

Zitat von himitsu:

Tachchen,
Aber durch Static gibt es dann kein Self mehr und man kann nicht mehr den Klassentyp einer abgeleiteten Klasse auslesen.

Und wozu sollte das gut sein? Klassenvariablen, Klassenmethoden und Klassenproperties sind schließlich Instanzunabhängig. Und da man sich auch nur auf eigene Klassenvariablen beziehen kann, ist es völlig Wumpe, ob eine Klassenmethode weiß, dass sie in einer Kindklasse aufgerufen wird.

Was hast Du denn eigentlich vor, dass Du so ein Kronstrukt benötigst?

Gruß aus dem hohen Norden
Thomas

Zitat von TBx:

Aber durch Static gibt es dann kein Self mehr

Worauf würde 'Self' denn dann eigentlich zeigen?

Zitat von Dejan Vu:

Zitat von TBx:

Aber durch Static gibt es dann kein Self mehr

Worauf würde 'Self' denn dann eigentlich zeigen?

Es gibt kein "Self". Eine statische Klassenmethode ist wie eine ganz normale Routine.

Wie der Compiler es konkret handhabt, weiß ich gerade nicht, aber ich würde vermuten, dass er entweder sagt "undefinierter Bezeichner" oder es einfach stur durch den Klassennamen ersetzt.

Ein vernünftiger Grund, weshalb Property-Getter statisch sein müssen, fällt mir spontan nicht ein. Faulheit der Compilerentwickler?

Nicht Static-Methoden kennen ihren Nachfahren.

Ein Property ist doch eigentlich nur ein "Alias" für den Getter, also sollte das doch mit dem Static eigentlich nichts zu tun haben

Self ist ein unsichtbarer Parameter, der als erstes in der Parameterliste drinsteht.
Nur bei Static gibt es diesen Parameter nicht. Das sieht intern wie eine "normale" Funktion, so als wäre sie nicht in einer Klasse drin.

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMyClass = class
    function Method: string;
    class function ClassMethod: string;
    class function StaticMethod: string; static;
  end;

  TOtherClass = class(TMyClass);
  end;


function TMyClass.Method: string;
begin
  // Self = die Instanz (TObject)
  // ClassType = TMyClass oder TOtherClass
  Result := ClassName; // MyClassType={Self.}ClassType / MyClassType=Self.ClassType
end;

class function TMyClass.ClassMethod: string;
begin
  // Self = der Klassentyp (TClass)
  // ClassType = TMyClass oder TOtherClass
  Result := ClassName; // MyClassType=Self
end;

class function TMyClass.StaticMethod: string;
begin
  // Self gibt es nicht
  // kennt nur sich und nicht den Nachfahren
  Result := 'k.A.';
end;

markieren

Code:

MyObj.Method              TMyClass
OtherObj.Method           TOtherClass
TMyClass.Method           geht natürlich nicht
TOtherClass.Method        geht natürlich nicht

MyObj.ClassMethod         TMyClass
OtherObj.ClassMethod      TOtherClass
TMyClass.ClassMethod      TMyClass
TOtherClass.ClassMethod   TOtherClass

MyObj.StaticMethod        k.A.
OtherObj.StaticMethod     k.A.
TMyClass.StaticMethod     k.A.
TOtherClass.StaticMethod  k.A.

Zitat von Namenloser:

Es gibt kein "Self". Eine statische Klassenmethode ist wie eine ganz normale Routine.

Sagte schon himitsu und der gesunde Menschenverstand sowieso. Ich habe nur nachgefragt, denn wenn jemand die Nichtexistenz von Etwas bedauert, müsste er auch sagen können, wie dieses Etwas denn aussehen sollte, wenn es denn existieren würde, ne wahr?

zusammenfalten · markieren

Delphi-Quellcode:

Type
  TMyClass = class
    class function StaticMethod; virtual; static;
  end;
  TOtherClass = class(TMyClass)
    class fnction StaticMethod; override; static;
  end;

class function TMyClass.StaticMethod: string;
begin
   Result := 'TMyClass';
end;
class function TOtherClass .StaticMethod: string;
begin
   Result := TOtherClass ;
end;

Geht das?

Zitat von Dejan Vu:

Zitat von TBx:

Aber durch Static gibt es dann kein Self mehr

Worauf würde 'Self' denn dann eigentlich zeigen?

Bei einer Klassenmethode zeigt Self auf den aktuellen Klassentyp. So könnt eine nicht-statische Klassenmethode in etwa sowas machen:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMyBaseClass = class
  public
    class procedure Execute;
  end;

  TMyClass1 = class(TMyBaseClass);
  TMyClass2 = class(TMyBaseClass);
  

class procedure TMyBaseClass.Execute;
var
  instance: TMyBaseClass;
begin
  instance := Self.Create;
  try
    ...
  finally
    instance.Free;
  end;
end;

begin
  TMyClass1.Execute; // erzeugt ein TMyClass1
  TMyClass2.Execute; // erzeugt ein TMyClass2
end;

Einen nicht static Getter bräuchte man, wenn class variables virtual wären.