发贴娱乐一下

Question

本帖最后由 liangpei2008 于 2010-03-25 09:31:20 编辑

Answer 1

本帖最后由 liangpei2008 于 2010-03-24 23:44:19 编辑

  

Answer 2

可能写成一个父类AA,即AA派生A,B,C

Answer 3

#include <iostream>
using namespace std;class A 
{
public:
void M1(){std::cout<<"M1"<<endl;}
void M2(){std::cout<<"M2"<<endl;}
void M3(){std::cout<<"M3"<<endl;}
void M7(){std::cout<<"m7"<<endl;}protected:
private:
};
class B
{
public:
void M1(){std::cout<<"M1"<<endl;}
void M2(){std::cout<<"M2"<<endl;}
void M3(){std::cout<<"M3"<<endl;}
void M4(){std::cout<<"m4"<<endl;}protected:
private:
};class AB: public A, public B
{
public:
protected:
private:
};int main()
{
AB *test = new AB;
test->A::M1();
test->B::M1();
test->M4();
delete test;
return 0;
}

Answer 4

type
  AB = class
   private
     Fa: A;
     Fb: B;
   public
     procedure M1;
     procedure M4
  end; procedure AB.M1;
 begin
   Fa.M1;
 end; procedure AB.M4;
 begin
   Fb.M4;
 end;

Answer 5

A和B类是一开始就设计好的还是要你自己设计？，看你题目象是A，B类已经成型了，
但是看你代码A，B类还没成型 

Answer 6

本帖最后由 liangpei2008 于 2010-03-24 23:51:05 编辑

  

Answer 7

java 没有研究过这个问题
delphi下可以重名方法名　或　委托实现（这个应该类似java接口的implements）

Answer 8

C類應該是一個組合類，采用委托實現接口IMethod = Interface
  procedure m1;
  procedure m2;
  procedure m3;
end;
IA = Interface
  procedure m4;
  procedure m5;
end;
IB = Interface
  procedure m7;
  procedure m9;
end;  TExample=class(TInterfacedObject,IExample)
  private
    //子类共用的数据成员
  public
     procedure M1;virtual;
     procedure M2;virtual;
     procedure M3;virtual;
     procedure other;virtual;abstract;  end;
  
  TExampleA(TExample,IA)
  public
    procedure M4;  
    procedure M5;
  end;  TExampleB(TExample,IB)
  public
    procedure M7;  
    procedure M9;
  end;  TExampleC(TExample,IA,IB)
  private
    FA: IA;
    FB: IB;
  public
    constructor Create; 
    property ExampleA: IA read FA implements IA;
    property ExampleB: IB read FB implements IB;
  end;implement
  ....
constructor TExampleC.Create;      
begin
  FA:= TExampleA.Create;
  FB:= TExampleB.Create;
end;抽象類，可以自己控制生存周期，接口自動控制，結合實際情況吧。至于提純，我覺得沒有啥原則或限制。
設計模式，只記得幾個常用的...

Answer 9

對比三國的做法，要是A或B的方法改名，也不會影響C的實現；
若三國的做法改為公布A、B的對象，這樣反而會暴露不必要的成員出來；所以看起來接口委托實現，應該是可以接受的。

Answer 10

【A类的m1，m2，m3和B类的方法同名，同功能】
就需要重构了

Answer 11

!!!!!!!!!!!!!!!!!!!!!!!!!!!!
對比三國的做法，要是A或B的方法改名，也不會影響C的實現；
若三國的做法改為公布A、B的對象，這樣反而會暴露不必要的成員出來；所以看起來接口委托實現，應該是可以接受的。

Answer 12

写个玩玩，不过可能不是很合题意type
  TCustomFuncArgs = class(TObject);  TM1FuncArgs = class(TCustomFuncArgs);
  TM2FuncArgs = class(TCustomFuncArgs);
  TM3FuncArgs = class(TCustomFuncArgs);
  TM1FuncArgs = class(TCustomFuncArgs);
  TM4FuncArgs = class(TCustomFuncArgs);
  TM5FuncArgs = class(TCustomFuncArgs);
  TM7FuncArgs = class(TCustomFuncArgs);
  TM9FuncArgs = class(TCustomFuncArgs);type
  TCustomFunction = class(TObject)
  public
    function Execute(AArgs: TCustomFuncArgs): Variant;
  end;  TM1Function = class(TCustomFunction);
  TM2Function = class(TCustomFunction);
  TM3Function = class(TCustomFunction);
  TM4Function = class(TCustomFunction);
  TM5Function = class(TCustomFunction);
  TM7Function = class(TCustomFunction);
  TM9Function = class(TCustomFunction);  TFunctionFactory = class(TObject)
  public
    function GetFunction(AName: string): TCustomFunction;
  end;type
  TCustomClassInvoker = class(TObject)
  private
    FFunctionFactory: TFunctionFactory;
  protected
    function IsValidFuncName(AName: string): boolean; virtual; abstract;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Call(AFuncName: string; AArgs: TCustomFuncArgs): Variant;
  end;constructor TCustomClassInvoker.Create;
begin
  FFunctionFactory := TFunctionFactory.Create;
end;destructor TCustomClassInvoker.Destroy;
begin
  FFunctionFactory.Free;
  inherited;
end;procedure TCustomClassInvoker.Call(AFuncName: string; AArgs: TCustomFuncArgs): Variant;
var
  f: TCustomFunction;
begin
  if not IsValidFuncName(AFuncName) then
    raise exception.create('xxxxxxxxx');  f := FFunctionFactory.GetFunction(AFuncName);
  if f = nil then
    raise Exception.Create('xxxxxxxxx');  result := f.Execute(AArgs);
end;type
  TClassAInvoker = class(TCustomClassInvoker);
  protected
    function IsValidFuncName(AName: string): boolean; override;
  end;  TClassBInvoker = class(TCustomClassInvoker);
  protected
    function IsValidFuncName(AName: string): boolean; override;
  end;  TClassCInvoker = class(TCustomClassInvoker);
  protected
    function IsValidFuncName(AName: string): boolean; override;
  end;var
  AInvoker: TClassCInvoker;
  AArgs: TM3FuncArgs;
begin
  AArgs := TM3FuncArgs.Create;
  AInvoker := TClassCInvoker.Create;
  showmessage(AInvoker.Call('M3', AArgs));
  AArgs.Free;
  AInvoker.Free;
end;

Answer 13

sanguomi的话是有道理的，从LZ题目上看，显然应该是在类A和类B已经定义并实现基础上，再来设计类C的，并非要完全重构A、B、C。所以使用接口或者从同一基类继承的方法是不符合题意的，因为我们不知道A和B是否实现了相同的接口，或者说A和B是否都派生于同一基类，题目说的仅仅是A和B的m1、m2、m3方法功能一样而已。
Delphi的类没有多重继承功能，但还是有很多方法来解决的：
我试着写了3种方法（不见得很好， 各有优缺点），为了简化，将不需要的函数（m2,m3,m5,m9）省略。方法1：type
  TA = class
  public
    procedure m1;
    procedure m7;
  end;  TB = class
  public
    procedure m1;
    procedure m4;
  end;  TC = class
  private
    FA: TA;
    FB: TB;
  public
    constructor Create;
    destructor Destroy; override;
    procedure m1;
    procedure m4;
    procedure m7;
  end;
{ TA }procedure TA.m1;
begin
  ShowMessage('m1');
end;procedure TA.m7;
begin
  ShowMessage('m7');
end;{ TB }procedure TB.m1;
begin
  ShowMessage('m1');
end;procedure TB.m4;
begin
  ShowMessage('m4');
end;{ TC }constructor TC.Create;
begin
  FA := TA.Create;
  FB := TB.Create;
end;destructor TC.Destroy;
begin
  FA.Free;
  FB.Free;
  inherited;
end;procedure TC.m1;
begin
  FA.m1;
end;procedure TC.m4;
begin
  FB.m4;
end;procedure TC.m7;
begin
  FA.m7;
end;
方法2：type
  TA = class
  public
    procedure m1;
    procedure m7;
  end;  TB = class
  public
    procedure m1;
    procedure m4;
  end;  TC = class(TA)
  private
    FB: TB;
  public
    constructor Create;
    destructor Destroy; override;
    procedure m4;
  end;{ TA }procedure TA.m1;
begin
  ShowMessage('m1');
end;procedure TA.m7;
begin
  ShowMessage('m7');
end;{ TB }procedure TB.m1;
begin
  ShowMessage('m1');
end;procedure TB.m4;
begin
  ShowMessage('m4');
end;{ TC }constructor TC.Create;
begin
  FB := TB.Create;
end;destructor TC.Destroy;
begin
  FB.Free;
  inherited;
end;procedure TC.m4;
begin
  FB.m4;
end;方法3：type
  TA = class
  public
    procedure m1;
    procedure m7;
  end;  TB = class
  public
    procedure m1;
    procedure m4;
  end;  TC = class(TA)
  public
    procedure m4;
  end;{ TA }procedure TA.m1;
begin
  ShowMessage('m1');
end;procedure TA.m7;
begin
  ShowMessage('m7');
end;{ TB }procedure TB.m1;
begin
  ShowMessage('m1');
end;procedure TB.m4;
begin
  ShowMessage('m4');
end;{ TC }procedure TC.m4;
begin
  with TB.Create do
  begin
    m4;
    Free;
  end;
end;

Answer 14

c++就是这个好，多重继承，delphi好像用接口来实现多重继承

Answer 15

类里放2个对象的做法，可能有问题
因为对象的数据也成了孤立的2、3套  TC = class
  private
    FA: TA;
    FB: TB;
  public
    constructor Create;
    destructor Destroy; override;
    procedure m1;
    procedure m4;
    procedure m7;
  end;
  TC = class(TA)
  private
    FB: TB;
  public
    constructor Create;
    destructor Destroy; override;
    procedure m4;
  end;

Answer 16

TSomeEvent = procedure(Sender: TObject) of object;

Answer 17

我觉得阿发伯的代码更简练一点，结构更清楚，liangpei2008代码更符合设计模式，但是更复杂。这个我们完全可以通过试着画一下UML图就知道了。

Answer 18

com对象本身是不能继承的（虽然本身是一个"类"），只能继承接口．所以只能是委托一个现成的com对象.也是比较常见的．而现实的代码中，是可以很方便进行继承的，并且有源代码，所以没有必要去＂委托＂．如果没有a,b源代码的话又另当别论．

Answer 19

一个基类含m1,m2,m3三个方法
A继承基类，自有方法m7,m9
B继承基类，自有方法m4,m5

Answer 20

type
AB = class
private
Fa: A;
Fb: B;
public
procedure M1;
procedure M4
end;procedure AB.M1;
begin
Fa.M1;
end;procedure AB.M4;
begin
Fb.M4;
end;

Answer 21

如果AB类都有了的，那就是继承A调用B；如果没有，那就是先设计一个抽象类，其它再派生

Answer 22

可能写成一个父类AA,即AA派生A,B,C

Answer 23

现在招delphi的公司招人都成问题了，还敢出这样的面试题？
深度怀疑！