delphi中如何实现多重继承？

Question

我正在对一个旧库进行完全重写，我不确定如何处理这种情况（为了便于理解，大家都欢呼自行车类比）：

我有以下类：

• TBike - 自行车本身
• TBikeWheel - 自行车车轮之一
• TBikeWheelFront 和 TBikeWheelBack，两者都继承自 TBikeWheel 和然后在其之上实现他们需要的特定内容

这非常简单，但现在我决定创建多种自行车，每辆自行车都有自己的车轮 - 它们与常规前轮/后轮执行相同的操作，加上那辆自行车的具体情况。

• TBikeXYZ - 继承自 TBike
• TBikeWheelXYZ - 继承于 TBikeWheel

这是我的问题：TBikeWheelFrontXYZ code> 应该继承自 TBikeWheelXYZ （获取 XYZ 轮的具体方法），但它也应该继承自 TBikeWheelFront （获取前轮的具体方法） 。

我的问题是，我怎样才能以一种不这样的方式实现它：

1. 感觉就像黑客
2. 迫使我多次重写相同的代码

Answer 1

我想建议以下步骤：

1. 从 TBikeWheelXYZ 或 TBikeWheelFront 继承 TBikeWheelFrontXYZ 类（因为在 Delphi 中多重继承是不可能的）正如上面的答案中提到的）。

2. 将父类 TBikeWheelXYZ 或 TBikeWheelFront 之一转换为 TBikeWheel 类的类帮助器。

3. 将类帮助器单元添加到声明 TBikeWheelFrontXYZ 类的单元中。

Answer 2

Delphi 不支持多重继承。 但是类可以支持/实现多个接口，并且您可以委托接口实现，因此您可以模拟多重继承。

Answer 3

使用接口。 像这样的东西（根据你的描述，在我的脑海中......）

type

  IBikeWheel = interface
    ...
  end;

  IXYZ = interface
    ...
  end;

  IFrontWheel = interface(IBikeWheel)
    ...
  end;


  TBike = class
    ...
  end;

  TBikeWheel = class(TObject, IBikeWheel);

  TBikeWheelXYZ = class(TBikeWheel, IXYZ);

  TBikeFrontWheelXYZ = class(TBikeWheelXYZ, IFrontWheel);

然后为接口实现类，这些类执行旧（大概是 C/C++）库中相应类的操作，并在相应的库中实例化它们类的构造函数。

Answer 4

使用多态性将每个“事物”实现为一个对象层次结构，然后依次向该对象添加对象属性。 因此，创建车轮层次结构和自行车层次结构。 然后将车轮添加到自行车作为祖先自行车对象中的字段。 见下文。

  TBikeWheel = class
  TBikeWheelXYZ = class( TBikeWheel ) 

  TBike = class
    FFrontWheel : TBikeWheel;
    property FrontWheel : TBikeWheel
      read FrontWhell  

  TBikeABC = class( TBike)
    constructor Create;
  end;

  constructor TBikeABC.Create;
  begin
    inherited;
    FFrontWheel := TBikeWheel.Create;
  end;

  TBikeXYZ = class( TBike)
    constructor Create;
  end;

  constructor TBikeXYZ.Create;
  begin
    inherited;
    FFrontWheel := TBikeWheelXYZ.Create;
  end;

Answer 5

Brian Frost 建议的变体：

  TBikeWheel = class
  TBikeWheelXYZ = class( TBikeWheel ) 

  TBike = class
    FFrontWheel : TBikeWheel;
  protected
    function CreateWheel: TBikeWheel; virtual;
  public
    property FrontWheel : TBikeWheel
      read FrontWheel  
  end;

  TBikeABC = class( TBike)
  protected
    function CreateWheel: TBikeWheel; override;
  end;

  function TBikeABC.CreateWheel: TBikeWheel;
  begin
    result := TBikeWheel.Create;
  end;

  TBikeXYZ = class( TBike)
  protected
    function CreateWheel: TBikeWheel; override;
  end;

  function TBikeXYZ.CreateWheel: TBikeWheel;
  begin
    result := TBikeWheelXYZ.Create;
  end;

Answer 6

基本上 - 你不能。 Delphi 不支持多重继承。

因此，留下这样的困境，问题是：你是否可以重构该库，以便你可以摆脱使用接口的束缚？ 多重继承主要是关于函数和方法吗？ 如果是这样 - 使用接口。 Delphi 可以支持一个类上的多个接口。

如果多重继承更多的是继承类中的实际功能，那么恐怕您可能会考虑更大规模的重构。 您需要找到一种方法来分解这些功能依赖关系，这样您就可以使其继承自单个基类，可能还需要添加一些附加接口。

抱歉，我无法提供一个简单的答案 - 这只是它的现实。

马克

Answer 7

您可以尝试从 TBikeWheelFront 中提取一个接口，例如 IFrontWheel，这样它就是 TBikeWheel 的子类，但实现了 IFrontWheel。 然后TBikeWheelXYZ继承自TBikeWheel，TBikeWheelFrontXYZ继承自TBikeWheelXYZ并实现IFrontWheel。

然后，您可以定义一个类 TFrontwheel 并为其提供与接口相同的方法，但现在您可以实现它们。 然后 TBikeWheelFront 和 TBikeWheelXYZ 获得类型 TFrontwheel 的私有成员，并且它们的 IFrontWheel 实现简单地委托给私有成员方法。

这样你就不会有双重实现。

Answer 8

新版本 Delphi 的另一种选择是在组合模型中利用泛型。 这在多个基类（本例中的TBarA 和TBarB）不可访问修改（即：框架或库类）的情况下特别有用。 例如（请注意，为简洁起见，此处省略了 TFoo 中必要的析构函数）：

program Project1;

uses SysUtils;

{$APPTYPE CONSOLE}

type    
  TFooAncestor  = class
    procedure HiThere; virtual; abstract;
  end;
  TBarA = class(TFooAncestor)
    procedure HiThere; override;
  end;
  TBarB = class(TFooAncestor)
    procedure HiThere; override;
  end;
  TFoo<T: TFooAncestor, constructor> = class
    private
      FFooAncestor: T;
    public
      constructor Create;
      property SomeBar : T read FFooAncestor write FFooAncestor;
  end;

procedure TBarA.HiThere;
begin
  WriteLn('Hi from A');
end;

procedure TBarB.HiThere;
begin
  WriteLn('Hi from B');
end;

constructor TFoo<T>.Create;
begin
  inherited;
  FFooAncestor := T.Create;
end;

var
  FooA : TFoo<TBarA>;
  FooB : TFoo<TBarB>;
begin
  FooA := TFoo<TBarA>.Create;
  FooB := TFoo<TBarB>.Create;
  FooA.SomeBar.HiThere;
  FooB.SomeBar.HiThere;
  ReadLn;
end.

Answer 9

如果您不想多次重复代码并且想要解耦代码，您可以尝试这种方式。

type
   TForm1 = class(TForm)
    btnTest: TButton;
    procedure btnTestClick(Sender: TObject);
   private
      { Private declarations }
   public
      { Public declarations }
   end;

   TBike = class
   end;

   IBikeWheel = interface
      procedure DoBikeWheel;
   end;

   TBikeWheel = class(TInterfacedObject, IBikeWheel)
   public
      procedure DoBikeWheel;
   end;

   IBikeWheelFront = interface
      procedure DoBikeWheelFront;
   end;

   TBikeWheelFront = class(TInterfacedObject, IBikeWheelFront)
   public
      procedure DoBikeWheelFront;
   end;

   IBikeWheelBack = interface
   end;

   TBikeWheelBack = class(TInterfacedObject, IBikeWheelBack)
   end;

   TBikeWheelFrontXYZ = class(TInterfacedObject, IBikeWheel, IBikeWheelFront)
   private
      FIBikeWheel: IBikeWheel;
      FBikeWheelFront: IBikeWheelFront;
   public
      constructor Create();
      property BikeWheel: IBikeWheel read FIBikeWheel implements IBikeWheel;
      property BikeWheelFront: IBikeWheelFront read FBikeWheelFront implements IBikeWheelFront;
   end;

var
   Form1: TForm1;

implementation

{$R *.DFM}

{ TBikeWheel }

procedure TBikeWheel.DoBikeWheel;
begin
   ShowMessage('TBikeWheel.DoBikeWheel');
end;

{ TBikeWheelFrontXYZ }

constructor TBikeWheelFrontXYZ.Create;
begin
   inherited Create;
   Self.FIBikeWheel := TBikeWheel.Create;
   Self.FBikeWheelFront := TBikeWheelFront.Create;
end;

{ TBikeWheelFront }

procedure TBikeWheelFront.DoBikeWheelFront;
begin
   ShowMessage('TBikeWheelFront.DoBikeWheelFront');
end;

procedure TForm1.btnTestClick(Sender: TObject);
var
   bikeWhell: TBikeWheelFrontXYZ;
begin
   bikeWhell := nil;
   try
      try
         bikeWhell := TBikeWheelFrontXYZ.Create;
         IBikeWheelFront(bikeWhell).DoBikeWheelFront;
         IBikeWheel(bikeWhell).DoBikeWheel;
      except
         on E: Exception do
         begin
            raise;
         end;
      end;
   finally
      if Assigned(bikeWhell) then FreeAndNil(bikeWhell);
   end;                                          
end;

Answer 10

抱歉，Delphi 不支持多重继承。