Construtores da Classe, Primrio e Secundrios

Mar 21, 2016

2 minute read

Voc pode implementar dezenas de Construtores para uma nica Classe, porm apenas um deles dever ser o Primrio enquanto os demais
devero ser apenas Secundrios.
Todos os construtores Secundrios devero fazer uma chamada ao construtor Primrio.

Os Construtores de Classes so utilizados para criar instncias de Objetos.

Uma Classe pode ter vrios construtores, mas somente o Primrio dever retornar uma instncia de um Objeto.
Os demais construtores so apenas Secundrios, pois iro fazer uso do construtor Primrio.

O construtor Primrio, na maioria das vezes, sempre ser aquele com mais parmetros.
Vamos a um exemplo.
type
TUser = class
private
FLogin: string;
FPassword: string;
public
constructor Create(const Login, Password: string);
constructor Create(const Login: string);
function Login: string;
function Password: string;
end;
implementation
constructor
begin
inherited
FLogin :=
FPassword
end;

TUser.Create(const Login, Password: string);

Create;
Login;
:= Password;

constructor TUser.Create(const Login: string);

begin
Create(Login, '123456');
end;
function TUser.Login: string;
begin
Result := FLogin;
end;
function TUser.Password: string;
begin
Result := FPassword;
end;

A Classe TUser tem 2 construtores.

O segundo construtor chama o primeiro, passando um valor default para o argumento Password.
Qualquer inicializao de atributos, sejam eles passados em argumentos pelo construtor ou no, dever ser executado em apenas um local, ou
seja, o construtor Primrio.
Este um padro que eu sigo em meus projetos.
Esse padro simplifica muito quando quero saber sobre tudo que um Objeto utiliza, inicializa ou encapsula, bastando olhar no seu construtor
Primrio. Esse construtor sempre ser o primeiro da lista de mtodos.

Argumentos Default
A linguagem Pascal permite que funes e mtodos tenham argumentos default. O exemplo acima poderia ser reescrito com apenas 1
construtor, desse jeito:
constructor Create(const Login, Password: string = '123456');

Apesar de escrever menos, eu no recomendo utilizar argumentos default.

O primeiro motivo que no podemos nomear os argumentos. Quando temos mais de um argumento default, essa vantagem de escrever
menos no faz muito sentido.
O segundo motivo que eu prefiro gerar os valores default em runtime. Se eu quisesse gerar uma senha aleatria, por exemplo, bastaria criar
um mtodo RandomPassword e cham-lo no construtor secundrio, ou seja, a implementao do construtor Secundrio poderia ser reescrita
assim:
constructor TUser.Create(const Login: string);
begin
Create(Login, RandomPassword);
end;

Construtores Secundrios e Mtodo New()

O uso do Mtodo New() pode ser considerado um substituto de construtores Secundrios. Se sua Classe implementa uma ou mais Interfaces,
no haveria motivos de implementar construtores Secundrios e Mtodos New() com a mesma assinatura.
Ao invs de criar novos construtores Secundrios, basta criar novas variaes de Mtodos New().
Exemplo.
type
IUser = interface
function Login: string;
function Password: string;
end;
TUser = class(TInterfacedObject, IUser)
private
FLogin: string;
FPassword: string;
public
constructor Create(const Login, Password: string);
class function New(const Login, Password: string): IUser;
class function New(const Login: string): IUser;
function Login: string;
function Password: string;
end;

Assim a implementao de suas Classes ficam ainda mais simples, pois teriam apenas 1 construtor onde todos os argumentos so
inicializados.
E voc, como implementa seus construtores?