Como funciona o paradigma de Programação Orientada a Objetos

Entenda como os paradigmas da Programação Orientada a Objetos podem te ajudar a criar códigos melhores.

Te encorajo a ler logo ao final deste conteúdo aqui, minha postagem sobre SOLID que está neste link.

Introdução

Quando estamos desenvolvendo um software, normalmente utilizamos paradigmas da programação. Paradigmas são formas e/ou abordagens para construir códigos bem estruturados e coesos.

Cada paradigma tem suas próprias regras, princípios e técnicas que guiam como os programas são estruturados, organizados e executados. Eles representam as filosofias subjacentes que definem a forma como os desenvolvedores abordam problemas e soluções na programação.

Nessa publicação vamos falar sobre a Programação Orientada a Objetos ou POO, como funciona, quais são seus pilares e como aplicá-los.

Como funciona a POO

Como o próprio nome sugere, esse paradigma está relacionado a utilização de “objetos” na programação. Estes objetos representam elementos do mundo real, no nosso caso, as entidades, seus atributos e comportamentos.

Por isso, toda organização de código gira em torno desses objetos, o que promove a reutilização da base código, manutenção e escalabilidade.

Um exemplo simples, que é realidade em quase todo software, é a entidade Cliente. Em um cenário hipotético, esse Cliente possui um nome e um endereço de email que serão transformados em atributos dessa entidade. Este Cliente pode ter seu nome atualizado, então teremos um comportamento chamado Atualizar Nome para esta entidade.

Colocando em código de forma simplificada, podemos escrever da seguinte forma:

class Cliente {
  constructor(nome, email) {
    this.nome = nome;
    this.email = email;
  }

  atualizarNome(novoNome) {
    this.nome = novoNome;
  }
}

Esta é a classe Cliente, uma definição de um conceito do mundo real. Nela estão definidos os atributos e os métodos que um objeto da classe Cliente pode ter.

Em nosso software podemos ter várias instâncias para esta mesma classe, que são os objetos. Estes poderão executar o método e ter seus atributos definidos.

Este exemplo acima descrever o pilar da Abstração na POO, vamos ver em detalhes a seguir.

Pilares da Programação Orientada à Objetos

Assim como os demais paradigmas, a POO também possui seus pilares que norteiam os desenvolvedores na construção de softwares com esta filosofia.

Os quatro pilares da POO são:

• Abstração: A própria identidade do objeto. O que ele é e o que pode fazer.
• Encapsulamento: O ato de ocultar detalhes de implementação e expor apenas a interface necessária.
• Herança: A capacidade de criar novas classes com base em classes existentes, compartilhando características e comportamentos.
• Polimorfismo: A capacidade de subclasses derivadas de uma mesma classe mãe, invocarem métodos iguais e realizarem comportamentos diferentes.

Abstração

Vamos continuar utilizando nosso exemplo da classe Cliente. O conceito de Abstração é a criação de Classes e Objetos a partir das ideias do nosso mundo real. As classes são os moldes e definem os dados/atributos e comportamentos/métodos que os objetos terão.

Para abstrair um elemento do mundo real e levar para o ambiente da Programação Orientada a Objetos, será necessário definir quais são os atributos da entidade (classe Cliente), que podem ser: nome, telefone, endereço, idade, cpf, etc. E quais comportamentos essa classe poderá ter, como: atualizar endereço, incrementar idade, etc.

Encapsulamento

O princípio Encapsulamento consiste, em esconder determinadas partes de uma classe de quem for utilizá-la e deixar exposto apenas o necessário para o seu acionamento.

Isso impede que atributos e métodos internos sejam utilizados de forma incorreta. Observe o exemplo abaixo que o atributo saldo não pode ser acessado diretamente, apenas através do método sacar(), depositar() ou verSaldo() .

class ContaBancaria {
  #saldo = 0; // Usando '#' para tornar o saldo privado

  depositar(valor) {
    this.#saldo += valor;
  }

  sacar(valor) {
    if (valor <= this.#saldo) {
      this.#saldo -= valor;
    } else {
      console.log("Saldo insuficiente.");
    }
  }

  verSaldo() {
    return this.#saldo;
  }
}

const conta = new ContaBancaria();
conta.depositar(1000);
conta.sacar(500);

console.log(`Saldo: ${conta.verSaldo()}`); // Saída: "Saldo: 500"

Herança

Este princípio é aplicado quando existe uma classe base ou superclasse que precisa compartilhar atributos e/ou métodos com classes filhas. Algumas linguagens de programação suportam heranças múltiplas, em outras, a classe filha pode herdar apenas de uma classe mãe.

Vamos ao nosso exemplo:

class Animal {
  constructor(nome) {
    this.nome = nome;
  }

  fazerBarulho() {
    console.log("Fazendo barulho...");
  }
}

class Cachorro extends Animal {
  //herda atributos e métodos da classe Animal
}

const meuCachorro = new Cachorro("Bilu");
meuCachorro.fazerBarulho(); // Saída: "Fazendo barulho"

Polimorfismo

Polimorfismo é a capacidade de classes filhas de uma determinada classe pai, terem métodos com a mesma assinatura (nome) da classe pai e se comportarem de forma distinta.

No nosso exemplo, o método calcularArea() é declarado na classe pai Forma e, além de ser herdado, a implementação do método é modificada em cada classe filha.

class Forma {
  calcularArea() {
    console.log("Calculando área da forma...");
  }
}

class Quadrado extends Forma {
  constructor(lado) {
    super();
    this.lado = lado;
  }

  calcularArea() {
    console.log(`Área do quadrado: ${this.lado * this.lado}`);
  }
}

class Circulo extends Forma {
  constructor(raio) {
    super();
    this.raio = raio;
  }

  calcularArea() {
    console.log(`Área do círculo: ${Math.PI * this.raio ** 2}`);
  }
}

const formas = [new Quadrado(4), new Circulo(3)];

formas.forEach((forma) => {
  forma.calcularArea();
});

Conclusão

Os conceitos estão expostos aqui de forma bastante simplificada, mas minha sugestão para você é que crie um repositório no Github e treine a utilização desses conceitos em cenários diversos. Só assim será possível entender o funcionamento deles mais a fundo.

Continue a leitura: SOLID: Princípios da Programação Orientada a Objetos