Curso de Programação Orientada a Objetos – 2.2 Atributos e Métodos

2.2 Atributos e Métodos

Na Programação Orientada a Objetos (POO), atributos e métodos são elementos fundamentais de uma classe.

• Atributos são variáveis que representam as propriedades ou características de um objeto.
• Métodos são funções ou procedimentos que definem o comportamento de um objeto.

Vamos implementar esses conceitos com um exemplo prático para ver como eles funcionam na prática.

 

Exemplo Prático: Criando uma Classe TCarro

Neste exemplo, vamos criar uma classe TCarro que representa um carro, com atributos como modelo, cor e velocidade atual. Também implementaremos métodos para acelerar e frear o carro.

unit CarroUnit;

interface

type
  TCarro = class
  private
    FModelo: string;
    FCor: string;
    FVelocidade: Integer;
  public
    // Construtor da classe
    constructor Create(Modelo, Cor: string);
    // Métodos
    procedure Acelerar(Valor: Integer);
    procedure Frear(Valor: Integer);
    procedure ExibirStatus;
    // Propriedades
    property Modelo: string read FModelo write FModelo;
    property Cor: string read FCor write FCor;
    property Velocidade: Integer read FVelocidade;
  end;

implementation

uses
  SysUtils;

{ TCarro }

constructor TCarro.Create(Modelo, Cor: string);
begin
  FModelo := Modelo;
  FCor := Cor;
  FVelocidade := 0; // Velocidade inicial é zero
end;

procedure TCarro.Acelerar(Valor: Integer);
begin
  FVelocidade := FVelocidade + Valor;
end;

procedure TCarro.Frear(Valor: Integer);
begin
  FVelocidade := FVelocidade - Valor;
  if FVelocidade < 0 then
    FVelocidade := 0; // A velocidade não pode ser negativa
end;

procedure TCarro.ExibirStatus;
begin
  WriteLn('Modelo: ' + FModelo);
  WriteLn('Cor: ' + FCor);
  WriteLn('Velocidade Atual: ' + IntToStr(FVelocidade) + ' km/h');
end;

end.

Neste código, a classe TCarro possui:

• Atributos Privados FModelo, FCor e FVelocidade:
  • FModelo e FCor são do tipo string e representam o modelo e a cor do carro.
  • FVelocidade é do tipo Integer e representa a velocidade atual do carro.
• Construtor Create:
  • Inicializa o carro com um modelo e cor especificados e define a velocidade inicial como zero.
• Métodos:
  • Acelerar: Aumenta a velocidade atual do carro em um valor especificado.
  • Frear: Diminui a velocidade do carro em um valor especificado. Se a velocidade resultante for negativa, ela é ajustada para zero.
  • ExibirStatus: Exibe o modelo, a cor e a velocidade atual do carro.
• Propriedades:
  • Modelo e Cor permitem acessar e modificar os valores dos atributos FModelo e FCor.
  • Velocidade é uma propriedade somente leitura que retorna o valor de FVelocidade.

 

Instanciando e Usando a Classe TCarro

Agora que temos a classe TCarro, vamos criar um objeto dessa classe e utilizar seus métodos para manipular seus atributos.

program ExemploCarro;

uses
  SysUtils, CarroUnit;

var
  Carro: TCarro;

begin
  // Criando uma instância de TCarro
  Carro := TCarro.Create('Sedan', 'Vermelho');

  // Exibindo o status inicial
  Carro.ExibirStatus;

  // Acelerando o carro
  Carro.Acelerar(50);
  Carro.ExibirStatus;

  // Acelerando mais uma vez
  Carro.Acelerar(30);
  Carro.ExibirStatus;

  // Freando o carro
  Carro.Frear(60);
  Carro.ExibirStatus;

  // Freando novamente para testar a velocidade negativa
  Carro.Frear(30);
  Carro.ExibirStatus;

  // Liberando a memória do objeto
  Carro.Free;
end.

Explicação do Código

1. Instanciação do Objeto Carro:
   • Carro := TCarro.Create('Sedan', 'Vermelho'); – Cria um novo objeto Carro do tipo TCarro, com o modelo “Sedan” e cor “Vermelho”.
2. Usando o Método ExibirStatus:
   • Carro.ExibirStatus; – Exibe o modelo, a cor e a velocidade atual do carro.
3. Acelerando o Carro:
   • Carro.Acelerar(50); – Aumenta a velocidade do carro em 50 km/h.
   • Chamamos ExibirStatus novamente para ver a atualização da velocidade.
4. Freando o Carro:
   • Carro.Frear(60); – Reduz a velocidade do carro em 60 km/h. Se a velocidade resultante for negativa, o método Frear ajusta a velocidade para zero.
5. Liberando a Memória:
   • Carro.Free; – É importante liberar a memória quando terminamos de usar o objeto.

 

Conclusão

Neste tópico, exploramos os conceitos de atributos e métodos em uma classe. Aprendemos a criar atributos para armazenar dados e métodos para manipular esses dados, mantendo a lógica encapsulada dentro da classe. Nos próximos tópicos, aprofundaremos outros conceitos essenciais da POO, como encapsulamento e herança.

 

 

Continue o curso no próximo post!

Curso de Programação Orientada a Objetos – 2.3 Encapsulamento