DelphiBasics
Interface
Keyword
Used for Unit external definitions, and as a Class skeleton System unit
1   Unit Name;
  Interface
    Declarations...
  Implementation
    Declarations...
  end.
2   type Name = Interface{(BaseInterface,...)};
Description
The Interface keyword is used in two different ways.
 
Version 1
 
It starts the definition of external interface of a Unit. Declarations here are externally visible by other units. All of these declarations must be implemented in the Implementation section.
 
The Uses statement, if present, must be at the start.
 
Version 2
 
In Object Oriented programming, we often use Abstract class methods in a base class as a placeholder. All derived classes must implement these methods.
 
Taking this one step further, an Interface defines a grouping of just abstract properties and methods. It provides a template for a class to use to ensure consistency. It is like a class with only abstract methods. It has the benefits that classes can be based on one parent class, and implement one or more interfaces. It adds a predictable flavour of operation to each class that implements the interface.
 
Take a look at the Delphi tutorial for more on this complex subject.
Notes
When implementing an interface, you must implement QueryInterface, _AddRef and _Release standard interface methods, unless you base your class on one that already has these implemented, such as TInterfacedObject.

Thanks to Dietmar Brueckmann for the example code.
Related commands
Abstract Defines a class method only implemented in subclasses
Class Starts the declaration of a type of object class
Constructor Defines the method used to create an object from a class
Destructor Defines the method used to destroy an object
Function Defines a subroutine that returns a value
Implementation Starts the implementation (code) section of a Unit
Object Allows a subroutine data type to refer to an object method
Procedure Defines a subroutine that does not return a value
TObject The base class type that is ancestor to all other classes
Unit Defines the start of a unit file - a Delphi module
Uses Declares a list of Units to be imported
 Author links

 Buy Website Traffic at
 Buywebsitetrafficexperts.com

 Buy Proxies at
 Buyproxies.io
 
 Download this web site as a Windows program.




 
Example code : Creating a car class from a vehicle interface
// Full Unit code.
// -----------------------------------------------------------
// You must store this code in a unit called Unit1 with a form
// called Form1 that has an OnCreate event called FormCreate.

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, DateUtils, StdCtrls;

type
   // An interface definition
   IRecyclable = Interface(IInterface)
     // A single function supporting the property
     function GetIsRecyclable : Boolean;
     // A single property
     property isRecyclable : Boolean read GetIsRecyclable;
   end;

  // Define our Car class
  TCar = class // (TInterfacedObject, IRecyclable)
  private
    carName  : String;
    carAge   : Byte;
    carIsRecyclable : Boolean;
    function GetIsRecyclable : Boolean;   // Added for IRecyclable
  published
    // Car properties
    property Name : String read carName;
    property Age : Byte read carAge write carAge;

    // Added for IRecyclable
    property isRecyclable : Boolean read GetIsRecyclable;

    // Car constructor
    constructor Create(name : String);
  end;

  // Define our Bicycle class
  TBicycle = class // (TInterfacedObject, IRecyclable)
  private
    bikeIsMale       : Boolean;
    bikeWheelSize    : Byte;
    function GetIsRecyclable : Boolean;   // Added for IRecyclable
  published
    // Bicycles properties
    property isMale : Boolean read bikeIsMale;
    property wheelSize : Byte read bikeWheelSize write bikeWheelSize;

    // Added for IRecyclable
    property isRecyclable : Boolean read GetIsRecyclable;

    // Bicycle constructor
    constructor Create(isMale : Boolean; wheelSize : Byte);
  end;

  // The definition of the program form
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

// Constructor implmentation for the car class
constructor TCar.Create(name : String);
begin
  // Save the car name and set default age and miles
  carName         := name;
  carAge          := 0;
  carIsRecyclable :=true    // Sets the recyclable indicator
end;

// Car function required for IsRecyclable attribute
function TCar.GetIsRecyclable : Boolean;
begin
  Result := carIsRecyclable;
end;

// Constructor implmentation for the bicycle class
constructor TBicycle.Create(isMale : Boolean; wheelSize : Byte);
begin
  // Save the passed parameters
  bikeIsMale    := isMale;
  bikeWheelSize := wheelSize;
end;

// Bicycle function required for IsRecyclable attribute
function TBicycle.GetIsRecyclable : Boolean;
begin
  // We'll asy that only male bicycles are recyclable
  if self.isMale
  then Result := true
  else Result := false;
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  mumsBike : TBicycle;
  dadsCar  : TCar;
begin
  // Instantiate our bike and car objects
  mumsBike := TBicycle.Create(false, 24);
  dadsCar  := TCar.Create('Nissan bluebird');

  // Ask if each is recyclable
  if dadsCar.isRecyclable
  then ShowMessage('Dads car is recyclable')
  else ShowMessage('Dads car is not recyclable');

  if mumsBike.isRecyclable
  then ShowMessage('Mums bike is recyclable')
  else ShowMessage('Mums bike is not recyclable');
end;

end.
   Dads car is recyclable
   Mums bike is not recyclable
 
Delphi Programming Neil Moffatt 2002 - 2017. All rights reserved.  |  Home Page