The Project | About Us | Contribute | Donations | License

HOME

In this section, we will delve into two fundamental concepts in Object-Oriented Programming (OOP) with Delphi/Object Pascal: Interfaces and Abstract Classes. These concepts are crucial for designing flexible and maintainable software.

What are Interfaces?

An interface in Delphi is a reference type that defines a contract of methods and properties that implementing classes must fulfill. Unlike classes, interfaces do not contain any implementation details. They are purely abstract and are used to define a set of methods that a class must implement.

Key Characteristics of Interfaces:

Abstract: Interfaces cannot be instantiated directly.
Contract: They define a set of methods and properties that must be implemented by any class that implements the interface.
Multiple Inheritance: A class can implement multiple interfaces, providing a way to achieve multiple inheritance in Delphi.

Defining an Interface

Here is an example of how to define an interface in Delphi:

type
  IShape = interface
    ['{8A1E2B3C-4D5F-6A7B-8C9D-0E1F2A3B4C5D}']
    function GetArea: Double;
    function GetPerimeter: Double;
    procedure Draw;
  end;

Implementing an Interface

To implement an interface, a class must provide concrete implementations for all the methods and properties defined in the interface:

type
  TCircle = class(TInterfacedObject, IShape)
  private
    FRadius: Double;
  public
    constructor Create(ARadius: Double);
    function GetArea: Double;
    function GetPerimeter: Double;
    procedure Draw;
  end;

constructor TCircle.Create(ARadius: Double);
begin
  FRadius = ARadius;
end;

function TCircle.GetArea: Double;
begin
  Result := Pi * FRadius * FRadius;
end;

function TCircle.GetPerimeter: Double;
begin
  Result := 2 * Pi * FRadius;
end;

procedure TCircle.Draw;
begin
  // Code to draw the circle
end;

What are Abstract Classes?

An abstract class in Delphi is a class that cannot be instantiated on its own and is intended to be a base class for other classes. Abstract classes can contain both abstract methods (methods without implementation) and concrete methods (methods with implementation).

Key Characteristics of Abstract Classes:

Cannot be instantiated: Abstract classes are meant to be inherited from, not instantiated directly.
Abstract Methods: These methods must be implemented by any non-abstract subclass.
Concrete Methods: These methods can be used directly by subclasses or overridden.

Defining an Abstract Class

Here is an example of how to define an abstract class in Delphi:

type
  TShape = class
  public
    function GetArea: Double; virtual; abstract;
    function GetPerimeter: Double; virtual; abstract;
    procedure Draw; virtual; abstract;
  end;

Implementing an Abstract Class

To implement an abstract class, a subclass must provide concrete implementations for all the abstract methods:

type
  TRectangle = class(TShape)
  private
    FWidth, FHeight: Double;
  public
    constructor Create(AWidth, AHeight: Double);
    function GetArea: Double; override;
    function GetPerimeter: Double; override;
    procedure Draw; override;
  end;

constructor TRectangle.Create(AWidth, AHeight: Double);
begin
  FWidth := AWidth;
  FHeight := AHeight;
end;

function TRectangle.GetArea: Double;
begin
  Result := FWidth * FHeight;
end;

function TRectangle.GetPerimeter: Double;
begin
  Result := 2 * (FWidth + FHeight);
end;

procedure TRectangle.Draw;
begin
  // Code to draw the rectangle
end;

Practical Exercise

Exercise 1: Implementing an Interface

Define an interface IVehicle with methods StartEngine, StopEngine, and GetSpeed.
Implement the IVehicle interface in a class TCar.

Solution:

type
  IVehicle = interface
    ['{D1E2F3A4-B5C6-7D8E-9F0A-1B2C3D4E5F6A}']
    procedure StartEngine;
    procedure StopEngine;
    function GetSpeed: Double;
  end;

  TCar = class(TInterfacedObject, IVehicle)
  private
    FSpeed: Double;
  public
    procedure StartEngine;
    procedure StopEngine;
    function GetSpeed: Double;
  end;

procedure TCar.StartEngine;
begin
  FSpeed := 60; // Assume the car starts at 60 km/h
end;

procedure TCar.StopEngine;
begin
  FSpeed := 0;
end;

function TCar.GetSpeed: Double;
begin
  Result := FSpeed;
end;

Exercise 2: Implementing an Abstract Class

Define an abstract class TAnimal with abstract methods MakeSound and Move.
Implement the TAnimal class in a subclass TDog.

Solution:

type
  TAnimal = class
  public
    procedure MakeSound; virtual; abstract;
    procedure Move; virtual; abstract;
  end;

  TDog = class(TAnimal)
  public
    procedure MakeSound; override;
    procedure Move; override;
  end;

procedure TDog.MakeSound;
begin
  WriteLn('Bark');
end;

procedure TDog.Move;
begin
  WriteLn('Run');
end;

Summary

In this section, we explored the concepts of interfaces and abstract classes in Delphi/Object Pascal. We learned how to define and implement interfaces, as well as how to create and extend abstract classes. These concepts are essential for creating flexible and maintainable code, allowing for better abstraction and separation of concerns in your applications.

Next, we will delve into Exception Handling in OOP, where we will learn how to manage errors and exceptions in an object-oriented context.

Interfaces and Abstract Classes

What are Interfaces?

Key Characteristics of Interfaces:

Defining an Interface

Implementing an Interface

What are Abstract Classes?

Key Characteristics of Abstract Classes:

Defining an Abstract Class

Implementing an Abstract Class

Practical Exercise

Exercise 1: Implementing an Interface

Solution:

Exercise 2: Implementing an Abstract Class

Solution:

Summary

Delphi/Object Pascal Programming Course

Module 1: Introduction to Delphi/Object Pascal

Module 2: Control Structures and Procedures

Module 3: Working with Data

Module 4: Object-Oriented Programming

Module 5: Advanced Delphi Features

Module 6: GUI Development with VCL and FMX

Module 7: Web and Mobile Development

Module 8: Best Practices and Design Patterns

Module 9: Final Project