Introdução à Orientação a Objetos em Delphi

Nesse post abordaremos sobre Orientação a Objetos em Delphi, de forma simples e prática para que todos possam entender.

 

_{Honda Civic Vermelho}

Índice

• Introdução
• O Que é Orientação a Objetos?
  • Orientação a Objetos em Delphi
    • Definindo uma Classe em Delphi
    • Usando a Classe Carro
  • Exemplo Prático
    • Passo a Passo para Criar o Projeto
  • Código fonte do exemplo
• Conclusão

Introdução

Nesse post abordaremos sobre Orientação a Objetos em Delphi, de forma simples e prática para que todos possam entender.

A orientação a objetos (OO) é um paradigma de programação que organiza o software em torno de "objetos" em vez de "ações" e "dados". Em termos simples, a OO é como criar programas que imitam o mundo real, onde tudo ao nosso redor pode ser visto como objetos com características (atributos) e ações (métodos).

Delphi, uma linguagem de programação poderosa e versátil, suporta totalmente a programação orientada a objetos. Vamos explorar o que é a orientação a objetos, como ela se aplica em Delphi e por que ela é importante para o desenvolvimento de software moderno.

O Que é Orientação a Objetos?

A orientação a objetos se baseia em quatro conceitos principais:

1- Classes e Objetos:

• Classe: Uma classe é como um molde ou modelo que define as características e comportamentos de um tipo específico de objeto. Por exemplo, pense em uma classe Carro. Ela define que todos os carros têm características como marca, modelo e cor, e comportamentos como acelerar e frear.
• Objeto: Um objeto é uma instância de uma classe. É a concretização da classe. Se Carro é a classe, então um objeto seria um carro específico, como um Honda Civic vermelho.

2- Atributos e Métodos:

• Atributos: São as características ou propriedades de um objeto. No exemplo do Carro, atributos podem ser marca, modelo, cor, ano de fabricação, etc.
• Métodos: São as ações que um objeto pode realizar. Para o Carro, métodos poderiam ser acelerar, frear, virar à esquerda, etc.

3- Encapsulamento:

• Encapsulamento é o conceito de esconder os detalhes internos de um objeto e expor apenas o que é necessário. Isso significa que os atributos de um objeto são acessados e modificados apenas através de métodos específicos, garantindo que o objeto mantenha um estado consistente.

4- Herança:

• Herança permite que uma classe derive de outra, herdando seus atributos e métodos. Por exemplo, você pode ter uma classe Veículo com atributos e métodos comuns a todos os veículos, e classes Carro e Moto que herdam de Veículo, mas também têm seus próprios atributos e métodos específicos.

5- Polimorfismo:

• Polimorfismo permite que objetos de diferentes classes sejam tratados como objetos de uma classe comum. Isso facilita a escrita de código genérico e reutilizável. Por exemplo, se Carro e Moto herdam de Veículo, você pode escrever um método que funciona com qualquer Veículo, independentemente de ser um Carro ou uma Moto.

Orientação a Objetos em Delphi

Delphi é uma linguagem que implementa totalmente os princípios da orientação a objetos. Vamos ver como esses conceitos são aplicados na prática com um exemplo simples.

Definindo uma Classe em Delphi

Vamos criar uma classe Carro com atributos e métodos básicos:

Delphi

type
  TCarro = class
  private
    FMarca: string;
    FModelo: string;
    FCor: string;
  public
    constructor Create(Marca, Modelo, Cor: string);
    procedure Acelerar;
    procedure Frear;
    procedure MostrarDetalhes;
  end;

constructor TCarro.Create(Marca, Modelo, Cor: string);
begin
  FMarca := Marca;
  FModelo := Modelo;
  FCor := Cor;
end;

procedure TCarro.Acelerar;
begin
  ShowMessage('O carro está acelerando.');
end;

procedure TCarro.Frear;
begin
  ShowMessage('O carro está freando.');
end;

procedure TCarro.MostrarDetalhes;
begin
  ShowMessage('Marca: ' + FMarca + ', Modelo: ' + FModelo + ', Cor: ' + FCor);
end;
  

Usando a Classe Carro

Agora vamos criar um objeto da classe Carro e utilizar seus métodos:

Delphi

var
  MeuCarro: TCarro;
begin
  MeuCarro := TCarro.Create('Honda', 'Civic', 'Vermelho');
  MeuCarro.MostrarDetalhes;
  MeuCarro.Acelerar;
  MeuCarro.Frear;
end;
  

Neste exemplo, criamos um objeto MeuCarro da classe TCarro, definimos suas características e chamamos seus métodos.

Exemplo Prático

O código a seguir cria um aplicativo Delphi simples com 3 botões, cada um demonstrando o uso dos métodos da classe Carro. Veja como configurar e executar este exemplo:

Passo a Passo para Criar o Projeto

1. Abra o Delphi e crie um novo projeto:
   • Vá para File -> New -> VCL Forms Application - Delphi.
2. Adicione três botões ao formulário:
   • Arraste três componentes Button da Tool Palette e solte-os no formulário. Nomeie-os apropriadamente (por exemplo, Button1, Button2, etc.).
3. Configure os eventos OnClick para cada botão:
   • Clique duas vezes em cada botão para abrir o editor de código e criar o evento OnClick.
4. Adicione o código a seguir ao formulário

Delphi

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.Imaging.pngimage, Vcl.ExtCtrls, Vcl.StdCtrls;

type

  TCarro = class //Classe Carro
  private
    //Atributos da classe Carro
    FMarca: string;
    FModelo: string;
    FCor: string;
  public
    //Método construtor da classe
    constructor Create(Marca, Modelo, Cor: string);

    //Métodos da classe Carro
    procedure Acelerar;
    procedure Frear;
    procedure MostrarDetalhes;
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Button3: TButton;
    Image1: TImage;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
  private
    { Private declarations }

    //Declara um objeto chamado MeuCarro do tipo TCarro
    MeuCarro : TCarro;

  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TCarro }

procedure TCarro.Acelerar;
begin
  //Método Acelerar da classe Carro
  ShowMessage('O carro está acelerando.');
end;

constructor TCarro.Create(Marca, Modelo, Cor: string);
begin
  //Método construtor da classe Carro
  //onde serão setados os seus atributos assim que a classe for instanciada, ou seja, criada.
  FMarca := Marca;
  FModelo := Modelo;
  FCor := Cor;
end;

procedure TCarro.Frear;
begin
  //Método Frear da classe Carro
  ShowMessage('O carro está freando.');
end;

procedure TCarro.MostrarDetalhes;
begin
  //Método Mostrar Detalhes da classe Carro
  ShowMessage('Marca: ' + FMarca + ', Modelo: ' + FModelo + ', Cor: ' + FCor);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  //Chama o método Acelerar do objeto MeuCarro
  MeuCarro.Acelerar;
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
  //Chama o método Frear do objeto MeuCarro
  MeuCarro.Frear;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  //Instancía o objeto MeuCarro, passando os atributos do mesmo.
  MeuCarro := TCarro.Create('Honda', 'Civic', 'Vermelho');
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  //Verifica se o objeto meu carro foi instanciado e mata o mesmo,
  //para que não fique lixo na memória.
  if Assigned(MeuCarro) then
    FreeAndNil(MeuCarro);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  //Chama o método MostrarDetalhes do objeto MeuCarro
  MeuCarro.MostrarDetalhes;
end;

end.
  

Veja abaixo a ilustração do projeto:

Ilustração do Projeto - Orientação a Objetos em Delphi.

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/ClasseCarro

Conclusão

A orientação a objetos é uma abordagem poderosa e intuitiva para desenvolver software. Ela permite que você modele o mundo real de forma mais natural e organize seu código de maneira modular e reutilizável. Em Delphi, a orientação a objetos é implementada de forma robusta, facilitando a criação de programas complexos de maneira estruturada e eficiente.

Com a compreensão dos conceitos de classes, objetos, encapsulamento, herança e polimorfismo, você pode aproveitar ao máximo o poder da programação orientada a objetos em Delphi. Essa abordagem não só melhora a qualidade do seu código, mas também torna seu desenvolvimento mais ágil e flexível, permitindo que você crie aplicações sofisticadas de forma mais eficiente.

Posts Relacionados

Hello, World! O clássio desenvolvido em Delphi.