Herança com Classes: criando 'filhos' que herdam características

Na Programação Orientada a Objetos, herança é quando uma classe “filha” aproveita o que já existe em uma classe “mãe”.

Pense em família:

• classe mãe: regras e características gerais
• classe filha: herda essas regras e pode adicionar coisas próprias

Isso evita repetição e deixa o código mais organizado.

Ideia central da herança

Com herança, você reaproveita código.

Exemplo do mundo real:

• Classe mãe: Animal (nome, comer, dormir)
• Classe filha: Cachorro (herda tudo de Animal e ainda late)

Sintaxe principal: extends

Em JavaScript (ES6), usamos extends para dizer que uma classe herda de outra.

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

  comer() {
    return `${this.nome} está comendo.`;
  }
}

class Cachorro extends Animal {
  latir() {
    return `${this.nome} está latindo.`;
  }
}

const rex = new Cachorro("Rex");
console.log(rex.comer()); // herdado de Animal
console.log(rex.latir()); // próprio de Cachorro

super(): conversando com a classe mãe

Quando a classe filha tem constructor, ela precisa chamar super(...) antes de usar this.

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

class Gato extends Animal {
  constructor(nome, cor) {
    super(nome); // chama o constructor da mãe
    this.cor = cor;
  }
}

Sem super(...), dá erro.

Sobrescrita de métodos (override)

A classe filha pode redefinir um método herdado para comportamento específico.

class Animal {
  emitirSom() {
    return "Som genérico";
  }
}

class Gato extends Animal {
  emitirSom() {
    return "Miau!";
  }
}

Isso é útil quando cada “filho” precisa agir de forma diferente.

Herança na prática: exemplo de sistema

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

  resumo() {
    return `${this.nome} - ${this.email}`;
  }
}

class Admin extends Usuario {
  constructor(nome, email, nivel) {
    super(nome, email);
    this.nivel = nivel;
  }

  resumo() {
    return `${super.resumo()} | Nível: ${this.nivel}`;
  }

  excluirUsuario(usuarioNome) {
    return `Admin ${this.nome} excluiu ${usuarioNome}`;
  }
}

• Admin herda de Usuario
• reaproveita nome, email e resumo()
• adiciona nivel e excluirUsuario()

Boas práticas com herança

• Use herança quando houver relação real de “é um tipo de”.
• Evite hierarquias profundas demais (muitas camadas).
• Prefira nomes claros para classes mãe e filha.
• Se a relação não fizer sentido, talvez composição seja melhor.

Erros comuns de iniciantes

• Esquecer extends na classe filha.
• Criar constructor na filha e esquecer super(...).
• Usar herança só “porque sim”, sem relação lógica entre classes.
• Sobrescrever método sem necessidade.

Resumo da lição

• Herança permite que classes filhas reaproveitem código da classe mãe.
• Em JavaScript, usamos extends.
• super(...) chama o construtor da classe mãe.
• Você pode sobrescrever métodos para comportamentos específicos.
• Herança ajuda a reduzir repetição e melhorar organização.