Programação orientada a objetos: princípios e boas práticas

Mas... o que é programação orientada a objetos?

Os 4 pilares da programação orientada a objetos

1. Encapsulamento: guardando os segredos

class Curso {
  #conteudoCompleto;

  constructor(nome, duracao) {
    this.nome = nome;
    this.duracao = duracao;
    this.#conteudoCompleto = "Material exclusivo para alunos";
  }

  acessarConteudo() {
    return `Acessando conteúdo do curso ${this.nome}: ${this.#conteudoCompleto}`;
  }
}

const cursoJavaScript = new Curso("JavaScript", "3 meses");
console.log(cursoJavaScript.acessarConteudo());

2. Herança: aproveitando o que já existe

class Curso {
  iniciar() {
    console.log("Iniciando o curso...");
  }
}

class CursoNode extends Curso {
  assistirAula() {
    console.log("Assistindo aula de Node.js!");
  }
}

const cursoNode = new CursoNode();
cursoNode.iniciar();    // Herda o método iniciar da classe Curso
cursoNode.assistirAula(); // Método específico da classe CursoNode

3. Polimorfismo: várias formas de ser

class Formacao {
  iniciar() {
    console.log("Iniciando a formação...");
  }
}

class FormacaoReact extends Formacao {
  iniciar() {
    console.log("Iniciando a formação de React!");
  }
}

class FormacaoJava extends Formacao {
  iniciar() {
    console.log("Iniciando a formação de Java!");
  }
}

const react = new FormacaoReact();
const java = new FormacaoJava();

react.iniciar(); // Inicia a formação de React
java.iniciar();  // Inicia a formação de Java

4. Abstração: só o que importa

class Curso {
  constructor(nome) {
    if (new.target === Curso) {
      throw new Error("Curso é uma classe abstrata e não pode ser instanciada diretamente");
    }
    this.nome = nome;
  }

  iniciarCurso() {
    throw new Error("Método iniciarCurso() deve ser implementado");
  }
}

class CursoGo extends Curso {
  iniciarCurso() {
    return `${this.nome} está iniciando, se prepare para aprender Go!`;
  }
}

class CursoCSharp extends Curso {
  iniciarCurso() {
    return `${this.nome} está iniciando, se prepare para aprender C#!`;
  }
}

const go = new CursoGo("Curso de Go");
const csharp = new CursoCSharp("Curso de C#");

console.log(go.iniciarCurso());
console.log(csharp.iniciarCurso());

Princípios SOLID: levando a POO ao próximo nível

• SRP (single responsibility principle): cada classe deve ter uma única responsabilidade. Isso evita que uma classe fique “fazendo tudo” e facilita a manutenção do código.

• OCP (open/closed principle): classes devem estar abertas para extensão, mas fechadas para modificação. Ou seja, se você precisar adicionar funcionalidades, estenda a classe ao invés de modificá-la diretamente.

• LSP (Liskov substitution principle): subclasses devem ser substituíveis por suas superclasses. Se você substitui uma classe base por uma derivada, o código ainda deve funcionar sem problemas.

• ISP (interface segregation principle): interfaces específicas para cada tipo de cliente. Ou seja, as classes não devem depender de métodos que não usam.

• DIP (dependency inversion principle): dependências devem apontar para abstrações, e não para implementações concretas.

Boas práticas de POO

• Nomeação clara e direta: escolha nomes que sejam claros e significativos para variáveis, métodos e classes. Em vez de abreviações ou siglas, use nomes descritivos, como AlunoCursoNode ou FormacaoJavaScript. Nomes claros ajudam o time a entender o código sem precisar de muita documentação extra.

• Comente apenas o essencial: escreva o código de forma que ele “fale por si”. Comentários devem esclarecer o que não é óbvio e explicar lógicas complexas ou específicas. Em uma formação da Rocketseat, por exemplo, ao definir um método iniciarModulo, deixe claro o que cada etapa do módulo faz, mas sem sobrecarregar o código com comentários excessivos.

• Escreva testes unitários: testes são a garantia de que o código está funcionando como esperado e de que mudanças futuras não quebrem funcionalidades. Imagine um sistema de acesso a cursos onde os alunos podem iniciar e pausar aulas. Ter testes que garantem que os alunos só conseguem acessar o conteúdo correto é essencial para um sistema funcional e seguro.

• Refatore sempre que possível: não tenha medo de revisar e reescrever partes do código para deixá-lo mais claro ou eficiente. Se você percebeu uma oportunidade de simplificar uma função acessarCurso ou gerarCertificado, por exemplo, faça a refatoração e compartilhe com o time. Um código limpo é a base para um sistema sustentável e fácil de manter.

Exemplo prático: sistema de formações na Rocketseat com herança

class Formacao {
  constructor(nome, duracao) {
    this.nome = nome;
    this.duracao = duracao;
  }

  iniciar() {
    console.log(`Iniciando a formação ${this.nome} com duração de ${this.duracao} meses.`);
  }
}

class FormacaoNode extends Formacao {
  projetoFinal() {
    console.log(`Projeto final da formação ${this.nome}: Criar uma API completa com Node.js!`);
  }
}

class FormacaoReact extends Formacao {
  projetoFinal() {
    console.log(`Projeto final da formação ${this.nome}: Desenvolver uma aplicação web completa com React!`);
  }
}

const formacaoNode = new FormacaoNode("Node.js", 3);
formacaoNode.iniciar();           // Método herdado da classe Formacao
formacaoNode.projetoFinal();       // Método específico de FormacaoNode

const formacaoReact = new FormacaoReact("React", 3);
formacaoReact.iniciar();
formacaoReact.projetoFinal();

Conclusão

Para te ajudar com seus estudos em POO, que tal descobrir estratégias e técnicas para gerenciar seu próprio aprendizado, definir objetivos e alcançar sucesso no desenvolvimento pessoal e profissional? Acesse o nosso material exclusivo de Educação Autodirigida e leve sua jornada de estudos para o próximo nível: Acesse aqui.

Outra ferramenta incrível que vai te ajudar a organizar seus estudos é o nosso Calendário de Estudos Personalizável. Com ele, você pode definir suas metas, organizar o tempo e maximizar sua produtividade, planejando cada etapa da sua jornada no aprendizado de POO e outras tecnologias. Acesse e crie seu próprio calendário agora: Baixe o calendário.

📽️

E se você gostou desse conteúdo e quer saber ainda mais sobre POO, venha conferir um vídeo especial que gravei sobre esse tema no meu canal! Nele, explico com detalhes cada conceito da Programação Orientada a Objetos, como encapsulamento, herança, polimorfismo e abstração, com exemplos práticos e linguagem acessível. Você vai entender, de uma vez por todas, como esses pilares podem transformar o jeito que você escreve e organiza seu código. Não perca essa oportunidade de aprender de forma prática e divertida!