Halb-virtuelle Methoden

[Der schöne Günther]

Ich bin zu ungeschickt, in den Weiten des Internets richtig danach zu suchen. Folgender Code:

Delphi-Quellcode:

program Project15; {$APPTYPE CONSOLE} {$R *.res}

uses System.SysUtils;

type
   IMyInterface = interface
      procedure interfaceProc();
   end;

   TMyBase = class(TInterfacedObject, IMyInterface)
      procedure interfaceProc();// virtual;
   end;

   TMyChild = class(TMyBase, IMyInterface)
      procedure interfaceProc();// override;
   end;

procedure TMyBase.interfaceProc();
begin
   WriteLn('TMyBase');
end;

procedure TMyChild.interfaceProc();
begin
   inherited;
   Writeln('TMyChild');
end;

var
   interfaceVariable: IMyInterface;
   classVariable: TMyBase;
begin
   WriteLn('interface variable');
   interfaceVariable := TMyChild.Create();
   interfaceVariable.interfaceProc();

   Write(sLineBreak);

   WriteLn('class type variable');
   classVariable := TMyChild.Create();
   classVariable.interfaceProc();

   readln;
end.

erzeugt die Ausgabe

Code:

interface variable
TMyBase
TMyChild

class type variable
TMyBase

Sprich: Spreche ich die Instanz mit einer Interface-Variable an wird die Methode behandelt, als hätte ich virtual angegeben. Nehme ich die Klassenreferenz wird sie nicht virtual behandelt.

Warum ist das so? Könnte folgendes etwas damit zu tun haben?
http://docwiki.embarcadero.com/RADSt...mplementations


Lange Rede kurzer Sinn: Sollte ich bei implementierten Interface-Methoden nun eine virtual-Direktive dahintersetzen? Eigentlich kann ich mir das ja dann sparen...