many Interfaces heritage in delphi - oop

Question

I hope to make some Class D heritage and implements all properties and methods of Interfaces A,B and C. Please help-me with an example in Delphi.
I use Delphi Xe7
How One class Implement Many Interfaces?
I'm trying something like:
Unit1
Type
IRefresher = Interface
['{B289720C-FFA4-4652-9F16-0826550DFCF9}']
procedure Refresh;
function getRefreshed: boolean;
property Refreshed:Boolean read getRefreshed;
End;
Unit2
Type
IRecorder = Interface
['{AB447097-C654-471A-A06A-C65CE5606721}']
procedure Reader;
procedure Writer;
end;
Unit3
ICustomer=Interface ['{F49C0018-37DA-463D-B5B4-4ED76416C7D4}']
procedure SetName(Value:String);
procedure SetDocument(Value:String);
function getName:String;
function getDocument:String;
End;
Unit4
Uses Unit1,Unit2,Unit3;
TGovernmentCustomer = class(TInterfacedObject, ICustomer, IRecorder,
IRefresher)
a: String;
public
{$REGION 'Customer'}
procedure SetName(Value: String); override;
procedure SetDocument(Value: String);
function getName: String; override;
function getDocument: String; override;
{$ENDREGION}
{$REGION 'Recorder'}
procedure Reader; override;
procedure Writer; override;
{$ENDREGION}
{$REGION 'Refresher'}
procedure Refresh; override;
function getRefreshed: boolean; override;
{$ENDREGION}
End;
It not works, because of many errors, such as 'Refresh not found in base class',

Answer 1

You have at least 3 implementation options for this:
1) virtual and abstract methods. In this case, you cannot instantiate this class and you must override abstract methods in descendant classes. Such methods would look like this:
type
TGovernmentCustomer = class(TInterfacedObject, ICustomer, IRecorder, IRefresher)
a: String;
public
procedure SetName(Value: String); virtual; abstract;
end;
There is no implementation, once the method is abstract.
2) virtual methods. In this case, you can instantiate this class and you may override some virtual methods in descendant classes. Such methods would look like this:
type
TGovernmentCustomer = class(TInterfacedObject, ICustomer, IRecorder, IRefresher)
a: String;
public
procedure SetName(Value: String); virtual;
end;
implementation
procedure TGovernmentCustomer.SetName(Value: String);
begin
// do something here. You can also leave it empty
end;
3) Static methods. In this case, you can instantiate this class and you cannot override static methods in descendant classes. Such methods would look like this:
type
TGovernmentCustomer = class(TInterfacedObject, ICustomer, IRecorder, IRefresher)
a: String;
public
procedure SetName(Value: String);
end;
implementation
procedure TGovernmentCustomer.SetName(Value: String);
begin
// do something here. This will be the behavior of all instances of this class and descendant classes if they exist
end;
One last note: Case (3) has the best performance. Calling virtual methods on interfaces has a performance penalty that may or may not be relevant in your specific application.
PS: As pointed out by Stefan, my link to another SO question was wrong. However, you can read about performance of virtual methods called through an interface from Andreas Hausladen blog: http://andy.jgknet.de/blog/2016/05/whats-wrong-with-virtual-methods-called-through-an-interface/

Answer 2

Remove the override word from your code as there is no explicit method binding directive for the interface method implementation. The override directive you've used in your code applies just for the virtual (abstract) or dynamic class methods of an ancestor class that are about to be implemented by the current class.
Here's an example that demonstrates a meaning of the override directive with a pseudo-abstract class that uses interfaces (sample from your code):
type
ICustomer = interface
['{F49C0018-37DA-463D-B5B4-4ED76416C7D4}']
procedure SetName(Value: string);
end;
IRefresher = interface
['{B289720C-FFA4-4652-9F16-0826550DFCF9}']
procedure Refresh;
end;
// sort of "abstract" class (not precisely) that does not yet "implement"
// the methods of the interfaces, only "includes" the interfaces
TAnyCustomer = class(TInterfacedObject, ICustomer, IRefresher)
private
FSomething: string;
public
// though the interfaces are "included" as a part of this class, their
// method implementation is not yet specific (missing implementantion
// exception is raised only, which is self-explaining, I'd say); that
// "virtual" directive of the following class methods lets this class'
// descendants "override" them to write the specific implementation
procedure SetName(Value: string); virtual;
procedure Refresh; virtual;
end;
// specific implementation of the class defined above; here you "override"
// the virtual methods of the "abstract" class defined above and implement
// the specific behavior of the class
TGovernmentCustomer = class(TAnyCustomer)
public
// "override" the ancestor's class method behavior and write a specific
// implementation (which finally implements some specific functionality
// here)
procedure SetName(Value: string); override;
procedure Refresh; override;
end;
implementation
procedure TAnyCustomer.SetName(Value: string);
begin
raise ENotImplemented.Create('Ouch! You missed to implement me!');
end;
procedure TAnyCustomer.Refresh;
begin
raise ENotImplemented.Create('Ouch! You missed to implement me!');
end;
procedure TGovernmentCustomer.SetName(Value: string);
begin
ShowMessage('I''m a government customer. How can I increase your budget?');
end;
procedure TGovernmentCustomer.Refresh;
begin
ShowMessage('Tell someone I''m fresh!');
end;