Delphi 在子类中创建具有自类型参数的泛型类或接口

我想创建一个类或接口，我可以子类化，总是使用当前类实例作为方法参数

下面是一个例子来解释我的问题：

 type IArithmeticObject = interface(IInterface)
   procedure assign(ao : IArithmeticObject);
   procedure add(ao : IArithmeticObject);
   procedure remove(ao : IArithmeticObject);
   procedure multiply(ao : IArithmeticObject);
   procedure divide(ao : IArithmeticObject);
 end;

接口

IArithmeticObject

将作为起点，引用基本算术运算和子类，可以声明为

 type TInteger = class(TInterfacedObject, IArithmeticObject)
   procedure assign(ao : TInteger);
   procedure add(ao : TInteger);
   procedure remove(ao : TInteger);
   procedure multiply(ao : TInteger);
   procedure divide(ao : TInteger);
 end;

ao

的参数类型为

TInteger

，而不是

IArithmeticObject

另一个想法是使用自引用泛型类型，如：

  AMathObject = class;

  AMathObject<T : AMathObject, constructor> = class
    procedure assign(ao : T);virtual;abstract;
    procedure add(ao : T);virtual;abstract;
    procedure remove(ao : T);virtual;abstract;
    procedure multiply(ao : T);overload;virtual;abstract;
    procedure divide(ao : T);virtual;abstract;
  end;

AMathObject=class；
AMathObject=class
程序分配（ao:T）；事实上的摘要
程序添加（ao:T）；事实上的摘要
程序删除（ao:T）；事实上的摘要
程序乘法（ao:T）；超载；事实上的摘要
程序划分（ao:T）；事实上的摘要
结束；

但是我想不出正确的语法

---

有人对这种可能性（或不可能）有什么想法吗？

如果我不能正确理解，您可能希望从泛型接口派生类

type
  IArithmeticObject<T> = interface
    procedure assign(ao: IArithmeticObject<T>);
    procedure add(ao: IArithmeticObject<T>);
    procedure remove(ao: IArithmeticObject<T>);
    procedure multiply(ao: IArithmeticObject<T>);
    procedure divide(ao: IArithmeticObject<T>);
  end;

  TInteger = class (TInterfacedObject, IArithmeticObject<TInteger>)
    procedure assign(ao: IArithmeticObject<TInteger>);
    procedure add(ao: IArithmeticObject<TInteger>);
    procedure remove(ao: IArithmeticObject<TInteger>);
    procedure multiply(ao: IArithmeticObject<TInteger>);
    procedure divide(ao: IArithmeticObject<TInteger>);
  end;

类型
IArithObject=接口
程序分配（ao：对象）；
程序添加（ao:IArithObject）；
程序删除（ao:IArithObject）；
过程乘法（ao：对象）；
程序划分（ao：对象）；
结束；
TInteger=类（TInterfacedObject、iArthMeticObject）
程序分配（ao：对象）；
程序添加（ao:IArithObject）；
程序删除（ao:IArithObject）；
过程乘法（ao：对象）；
程序划分（ao：对象）；
结束；

答案根据编辑：现在类的方法接受声明为对象或接口的参数

var
  ao: IArithmeticObject<TInteger>;
begin
  ao := TInteger.Create;
  ao.multiply(ao);
end.

var
ao：一个对象；
开始
ao:=TInteger.Create；
乘法（ao）；
结束。

虽然这样做很有效，但没有多大意义，因为这样会在API中混合接口和对象引用。您希望使用

IArithmeticObject

，但只能将

TInteger

传递给其方法。因此，在我看来，如果将

IArithmeticObject

方法的参数从

T

更改为

IArithmeticObject

，则更有意义。