ObjectPascal
Overload
Directive 		Allows 2 or more routines to have the same name
  Subroutine declaration; Overload; {Other directives...}
Description
The Overload directive allows you to have different versions of the same named function or procedure with different arguments.
 
This is useful when there are a number of ways that code may want to use the routine. For example, if the routine is a class constructor, you may want one version of Create that sets default values, and another that takes these values as parameters.
 
You must code the Overload directive before any other directives.
 
When calling an overloaded routine, Delphi chooses the appropriate version based first on number of arguments, then on the argument types. If it cannot make a decision, it throws an exception.
 
When the argument count is the same, it always tries to satisfy the simplest/smallest data types first - for example, the above value 23 would satisfy a Byte argument ahead of an Integer argument.
 
Sometimes, you can avoid the need for overloading by giving final arguments default values. The caller can then call with or without these final parameters.
 
procedure MyProc(a : Byte; b : Byte = 23);
 
can be called in two ways:
 
MyProc(15, 16);
MyProc(45);      // Defaults b to value 23
 
Overloading is not restricted to class methods. In line functons and procedures can be similarly overloaded.
Related commands
Abstract Defines a class method only implemented in subclasses
Function Defines a subroutine that returns a value
Override Defines a method that replaces a virtual parent class method
Procedure Defines a subroutine that does not return a value
 
Example code : Two versions of a class constructor
// 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;

type
  // Class with overloaded methods
  TRectangle = class
  private
    coords: array[0..3] of Integer;
  public
    constructor Create(left, top, right, bottom : Integer); Overload;
  published
    // Only one version of an overloaded method can be published
    constructor Create(topLeft, bottomRight : TPoint); Overload;
  end;

  // The form class itself
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

// Constructor version 1 : takes integers as the coordinate values
constructor TRectangle.Create(left, top, right, bottom: Integer);
begin
  // Save the passed values
  coords[0] := left;
  coords[1] := top;
  coords[2] := right;
  coords[3] := bottom;
end;

// Constructor version 2 : takes points as the coordinate values
constructor TRectangle.Create(topLeft, bottomRight: TPoint);
begin
  // Save the passed values
  coords[0] := topLeft.X;
  coords[1] := topLeft.Y;
  coords[2] := bottomRight.X;
  coords[3] := bottomRight.Y;
end;

// Main line code
procedure TForm1.FormCreate(Sender: TObject);
var
  rect1, rect2   : TRectangle;
  point1, point2 : TPoint;

begin
  point1 := Point(122,133);
  point2 := Point(144,155);

  // Create two rectangles using two different constructors
  rect1 := TRectangle.Create(22, 33, 44, 55);
  rect2 := TRectangle.Create(point1, point2);
end;

end.
   The program runs wihtout producing any output
 
Example code : Ilustrating how Delphi chooses routines according to parameter value
// 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, StdCtrls;

type
  // The form class itself
  TForm1 = class(TForm)
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  form1.close;
end;

// In line overloaded functions
function MaxValue(a, b : Byte) : string; Overload;
begin
  if a > b
  then ShowMessageFmt('%d byte >  %d',[a,b])
  else ShowMessageFmt('%d byte <= %d',[a,b]);
end;

function MaxValue(a, b : Integer) : string; Overload;
begin
  if a > b
  then ShowMessageFmt('%d integer >  %d',[a,b])
  else ShowMessageFmt('%d integer <= %d',[a,b]);
end;

function MaxValue(a, b : Extended) : string; Overload;
begin
  if a > b
  then ShowMessageFmt('%f extended >  %f',[a,b])
  else ShowMessageFmt('%f extended <= %f',[a,b]);
end;

function MaxValue(a, b : string) : string; Overload;
begin
  if a > b
  then ShowMessageFmt('''%s'' string >  ''%s''',[a,b])
  else ShowMessageFmt('''%s'' string <= ''%s''',[a,b]);
end;

// Main line code
procedure TForm1.FormCreate(Sender: TObject);
begin
  // Demonstrate different calls using the same name
  MaxValue(15  , 23);
  MaxValue(1500, 23);
  MaxValue(15.0, 23.0);
  MaxValue('15', '23');
end;
end.
   15 byte <= 23
   1500 integer > 23
   15.0 extended <= 23.0
   '15' string <= '23'