Polymorphism and properties - delphi

Question

I'm trying to use polymorphism and create a property that should return different types depending on what type of object it is.
Why is there this compiler warning for the code below:
[Warning: Constructing a class "TTimeField" with abstract method "SetValue"]
More important, how can I make this work so Value can be assigned a TDateTime when a TTimeField is created? As it is, there is a message about "type mismatch".
TBaseField = class
private
function GetValue: string; virtual; abstract;
procedure SetValue(AValue: string); virtual; abstract;
public
property Value: string read GetValue write SetValue;
end;
{ TTimeField }
TTimeField = class(TBaseField)
private
FValue : TDateTime;
function GetValue: TDateTime; override;
procedure SetValue(AValue: TDateTime); override;
public
property Value: TDateTime read GetValue write SetValue;
end;
implementation
function TTimeField.GetValue: TDateTime;
begin
Result:= FValue;
end;
procedure TTimeField.SetValue(AValue: TDateTime);
begin
FValue:= AValue;
end;
EDIT: Below, with the use of strings I achieved the functionality needed, but if the code above had worked it had meant a gain in performance.
TBaseField = class
private
procedure SetStrValue(AValue: string); virtual; abstract;
function GetStrValue: string; virtual; abstract;
public
property AsString: string read GetStrValue write SetStrValue;
end;
TTimeField = class(TBaseField)
private
FValue : TDateTime;
function GetStrValue: string; override;
procedure SetStrValue(AValue: string); override;
public
property AsString: string read GetStrValue write SetStrValue;
end;
function TTimeField.GetStrValue: string;
begin
Result:= DateTimeToStr(FValue);
end;
procedure TTimeField.SetStrValue(AValue: string);
begin
FValue:=StrToDateTime(AValue);
end;

Answer 1

I think your problem is that you're not actually overriding any method; your new method has a different signature. Therefore it is actually an overload. In your example, having TBaseField doesn't really help you in any way. The subclass doesn't use any of its methods, nor does it provide any extra functionality.
Polymorphism is about varying implementations for a given interface (as in method signatures) without the caller needing to knowing about that.
Looking at your example, it might just be that you're not necessarily looking for polymorphism, but rather for a way to implement similar methods/properties for various data types with as little code as possible. That's where generics usually prove more useful.
Say that all field classes need to store a value of their own type, which should be possible to set and retrieve. Then you can define a generic TField<T> where T is a "placeholder" for the type of data that the field should work with. You will be able to give it a getter and setter, as well as a property, which will be generic too. As such, you'll only need to define them once for all kinds of fields you'll end up using. These methods may contain whatever logic is shared by all fields. You may, however, still subclass a generic type to add specific functionality to a certain type, or to hide the fact that you rely on generics.
A simple example:
type
TField<T> = class
private
FValue: T;
protected
function GetValue: T; virtual;
procedure SetValue(const AValue: T); virtual;
public
property Value: T read GetValue write SetValue;
end;
TDateTimeField = TField<TDateTime>;
TTrimmingStringField = class(TField<string>);
protected
function SetValue(const AValue: string); override;
end;
// Now use these fields as you'd expect
implementation
{ TField<T> }
function TField<T>.GetValue: T;
begin
Result := FValue;
end;
procedure TField<T>.SetValue(const AValue: T);
begin
FValue := AValue;
end;
{ TTrimmingStringField }
procedure TTrimmingStringField.SetValue(const AValue: string);
begin
inherited SetValue(Trim(AValue));
end;

Answer 2

Polymorphism is used with methods rather than properties. You can define a property that has virtual getter and setter methods, and then use polymorphism on those getter and setter methods.
However, polymorphic methods are not allowed to change the type of the arguments or the return value. Why not?
Well, suppose we write this code:
type
TMyBaseClass = class
public
procedure Foo(Arg: string); virtual;
end;
....
var
obj: TMyBaseClass;
....
obj.Foo('bar');
One of the tenets of polymorphism is that obj can be an instance of TMyBaseClass or indeed any class derived from TMyBaseClass. The compiler does not need to know the actual type of obj, only that it is derived from TMyBaseClass. The type is only known at runtime, and polymorphic virtual method despatch ensures that the derived method is called.
This means that it would make no sense for Foo to accept arguments of any type other than that declared when the virtual method was first introduced.
What you need is something called a variant type. A variant type is one that can represent many different types. For instance, any decent variant type will be able to represent integers, floating point values, strings, dates and times and so on. In Delphi you would use something like the COM Variant type, or the more recently added TValue. In Free Pascal, I'm not so sure what the prevailing variant type is.