Herança em Delphi — _{Filhote de cachorro e gato lado a lado.}

Índice

Introdução

Nesse post iremos aprender sobre Herança em Delphi dentro da Orientação a Objetos. Iremos pontuar o conceito, utilização e exemplo prático com código fonte completo, para elevar seus conhecimentos em Delphi para outros nível.

O que é Herança e Como Utilizá-la

Herança é um dos pilares fundamentais da programação orientada a objetos (POO) e permite que uma classe (chamada classe derivada ou subclasse) herde propriedades e métodos de outra classe (chamada classe base ou superclasse). Esse mecanismo promove a reutilização de código e facilita a manutenção e extensão de sistemas complexos.

Em Delphi, a herança é utilizada para criar hierarquias de classes onde uma classe derivada pode herdar e, se necessário, estender ou modificar o comportamento de sua classe base. A herança facilita a criação de novas classes baseadas em classes existentes, sem a necessidade de reescrever o código que já foi testado e validado.

Como Criar Classes Base e Derivadas

Para demonstrar a herança, vamos criar um exemplo prático em Delphi com uma classe base TAnimal e duas classes derivadas TCachorro e TGato.

Classe Base: `TAnimal`

type
  TAnimal = class
  private
    FNome: String;
  public
    constructor Create(Nome: String);
    procedure EmitirSom; virtual; // Método virtual para ser sobrescrito
    property Nome: String read FNome write FNome;
  end;

constructor TAnimal.Create(Nome: String);
begin
  FNome := Nome;
end;

procedure TAnimal.EmitirSom;
begin
  ShowMessage('Som do animal');
end;

Classe Derivada: `TCachorro`

type
  TCachorro = class(TAnimal)
  public
    procedure EmitirSom; override; // Sobrescrevendo o método EmitirSom
  end;

procedure TCachorro.EmitirSom;
begin
  ShowMessage('Latido');
end;

Classe Derivada: `TGato`

type
  TGato = class(TAnimal)
  public
    procedure EmitirSom; override; // Sobrescrevendo o método EmitirSom
  end;

procedure TGato.EmitirSom;
begin
  ShowMessage('Miau');
end;

Uso da Palavra-chave `inherited`

A palavra-chave inherited em Delphi é utilizada para chamar métodos e construtores da classe base a partir da classe derivada. Isso é particularmente útil quando queremos estender a funcionalidade de um método na classe derivada sem substituir completamente o comportamento da classe base.

Exemplo Prático com `inherited`

Vamos modificar nosso exemplo para incluir a utilização da palavra-chave inherited.

type
  TCachorro = class(TAnimal)
  public
    constructor Create(Nome: String);
    procedure EmitirSom; override;
  end;

constructor TCachorro.Create(Nome: String);
begin
  inherited Create(Nome); // Chama o construtor da classe base
end;

procedure TCachorro.EmitirSom;
begin
  inherited EmitirSom; // Opcional: Chama o método EmitirSom da classe base
  ShowMessage('Latido');
end;

Exemplo Completo e Prático

Vamos criar um exemplo completo em Delphi para ilustrar a herança com as classes TAnimal, TCachorro e TGato. Este exemplo inclui um formulário com dois botões para demonstrar a emissão de sons de diferentes animais.

Configurando o Ambiente

Abrindo o Delphi: Abra o Delphi e crie um novo projeto VCL Forms Application.
Configurando o Formulário Principal: Adicione o seguinte componente ao formulário:

TButton (ButtonDog): Para executar exibir os dados de TCachorro.
TButton (ButtonCat): Para executar exibir os dados de TGato.

Código Completo Herança em Delphi

unit Unit1;

interface

uses
  Vcl.Forms, Vcl.StdCtrls, System.Classes;

type
  TAnimal = class
  private
    FNome: String;
  public
    constructor Create(Nome: String);
    procedure EmitirSom; virtual;
    property Nome: String read FNome write FNome;
  end;

  TCachorro = class(TAnimal)
  public
    constructor Create(Nome: String);
    procedure EmitirSom; override;
  end;

  TGato = class(TAnimal)
  public
    constructor Create(Nome: String);
    procedure EmitirSom; override;
  end;

  TForm1 = class(TForm)
    ButtonDog: TButton;
    ButtonCat: TButton;
    procedure ButtonDogClick(Sender: TObject);
    procedure ButtonCatClick(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

constructor TAnimal.Create(Nome: String);
begin
  FNome := Nome;
end;

procedure TAnimal.EmitirSom;
begin
  ShowMessage('Som do animal');
end;

constructor TCachorro.Create(Nome: String);
begin
  inherited Create(Nome);
end;

procedure TCachorro.EmitirSom;
begin
  inherited EmitirSom;
  ShowMessage('Latido');
end;

constructor TGato.Create(Nome: String);
begin
  inherited Create(Nome);
end;

procedure TGato.EmitirSom;
begin
  inherited EmitirSom;
  ShowMessage('Miau');
end;

procedure TForm1.ButtonDogClick(Sender: TObject);
var
  Cachorro: TCachorro;
begin
  Cachorro := TCachorro.Create('Rex');
  try
    Cachorro.EmitirSom;
  finally
    Cachorro.Free;
  end;
end;

procedure TForm1.ButtonCatClick(Sender: TObject);
var
  Gato: TGato;
begin
  Gato := TGato.Create('Mimi');
  try
    Gato.EmitirSom;
  finally
    Gato.Free;
  end;
end;

end.

Explicação do Código

Definição das Classes: Definimos as classes TAnimal, TCachorro e TGato. TAnimal é a classe base com um método virtual EmitirSom. TCachorro e TGato são classes derivadas que sobrescrevem o método EmitirSom.
Uso de inherited: Nos construtores de TCachorro e TGato, usamos inherited Create(Nome) para chamar o construtor da classe base. Nos métodos EmitirSom, usamos inherited EmitirSom para chamar a implementação da classe base antes de adicionar o comportamento específico da subclasse.
Formulário com Botões: Criamos um formulário com dois botões. Cada botão cria uma instância de TCachorro ou TGato, chama o método EmitirSom e libera a instância.

Veja abaixo como ficou a ilustração do projeto utilizando Herança:

Código fonte do exemplo

Você pode fazer o download do exemplo do projeto através do repositório do github:

https://github.com/Gisele-de-Melo/Heranca

Conclusão

A herança é uma poderosa característica da programação orientada a objetos que permite a criação de classes derivadas a partir de classes base, promovendo a reutilização de código e facilitando a manutenção de sistemas complexos. Em Delphi, a herança é implementada de forma simples e eficaz, permitindo que você crie hierarquias de classes robustas. Ao entender e aplicar o conceito de herança, você estará preparado para desenvolver aplicações mais organizadas, eficientes e fáceis de manter.

Posts Relacionados

Propriedades e Métodos em Delphi

Encapsulamento em Delphi