Entendendo Programação Orientada a Objetos (POO) com Exemplos em TypeScript

// vehicle.ts
// Classe representando um Carro
class Carro {
  // Propriedade privada para armazenar o modelo do carro
  private modelo: string;

  // Construtor para inicializar o modelo do carro
  constructor(modelo: string) {
    this.modelo = modelo;
  }

  // Método público para simular a partida do motor do carro
  public ligarMotor(): void {
    console.log('Motor ligado');
    // Registra uma mensagem indicando que o motor foi ligado
  }
}

// Cria uma instância da classe Carro com o modelo 'Sedan'
const meuCarro = new Carro('Sedan');

// Registra a instância do Carro no console
console.log(meuCarro); // Saída: Carro { modelo: 'Sedan' }

// vehicle.ts
// Classe base representando um Veículo genérico
class Veiculo {
  // Propriedade protegida para armazenar o nível de combustível do veículo
  protected nivelCombustivel: number;

  // Construtor para inicializar o nível de combustível do veículo
  constructor(nivelCombustivel: number) {
    this.nivelCombustivel = nivelCombustivel;
  }

  // Método protegido para verificar se o nível de combustível é suficiente
  // Retorna verdadeiro se o nível de combustível for maior que 10
  protected verificarCombustivel(): boolean {
    return this.nivelCombustivel > 10;
  }
}

// Classe derivada representando um tipo específico de Veículo: Carro
// Nota: Renomeei 'CarClass' para 'Carro' para seguir o padrão do exemplo anterior
// e para ser mais idiomático em português.
class Carro extends Veiculo {
  // Método público para simular a condução do carro
  public dirigir(): void {
    // Verifica se o nível de combustível é suficiente usando o método herdado verificarCombustivel
    if (this.verificarCombustivel()) {
      console.log('Dirigindo...'); // Saída se o nível de combustível for suficiente
    } else {
      console.log('Combustível baixo!'); // Saída se o nível de combustível for insuficiente
    }
  }
}

// Cria uma instância da classe Carro com um nível inicial de combustível de 11
const meuCarro = new Carro(11); // Usei 'meuCarro' como no exemplo anterior

// Chama o método dirigir na instância do Carro
// Saída: 'Dirigindo...' porque o nível de combustível (11) é maior que 10
meuCarro.dirigir();

// Classe representando uma Conta Bancária
class ContaBancaria {
  // Propriedade privada para armazenar o número da conta
  // Nota: É convenção usar 'string' (tipo primitivo) em vez de 'String' (objeto) em TypeScript.
  private numeroConta: string;

  // Construtor para inicializar o número da conta
  constructor(numeroConta: string) {
    this.numeroConta = numeroConta;
  }

  // Método privado para obter o número completo da conta
  // Este método não é acessível fora da classe
  private obterNumeroConta(): string {
    return this.numeroConta;
  }

  // Método público para exibir o número da conta parcialmente mascarado
  public exibirNumeroContaParcial(): void {
    // Registra o número da conta com os primeiros 4 dígitos mascarados
    // Usando 'this.numeroConta' que agora está em português
    console.log('Número da Conta: ****' + this.numeroConta.slice(4));
  }
}

// Cria uma instância da classe ContaBancaria com um número de conta específico
const conta = new ContaBancaria('456049584456');

// Chama o método exibirNumeroContaParcial para mostrar o número da conta mascarado
// Saída: 'Número da Conta: ****9584456'
conta.exibirNumeroContaParcial();

// Classe base representando um Animal genérico
class Animal {
  // Propriedade pública para armazenar o nome do animal
  public nome: string; // Usando 'string'

  // Construtor para inicializar o nome do animal
  constructor(nome: string) {
    this.nome = nome;
  }

  // Método para simular o animal fazendo um som genérico
  fazerSom(): void { // Adicionado tipo de retorno 'void' para clareza
    console.log('Fazendo algum som genérico...');
  }
}

// Classe derivada representando um tipo específico de Animal: Cachorro
class Cachorro extends Animal {
  // Propriedade pública para armazenar a raça do cachorro
  public raca: string; // Usando 'string'

  // Construtor para inicializar o nome e a raça do cachorro
  // Chama o construtor da classe pai (Animal) para definir o nome
  constructor(nome: string, raca: string) {
    super(nome); // Chama o construtor da classe pai (Animal)
    this.raca = raca;
  }

  // Método sobrescrito (override) para simular o cachorro fazendo um som específico
  public fazerSom(): void { // Sobrescrevendo o método da classe pai
    console.log('Au au!'); // Som mais específico para cachorro
  }

  // Método específico da classe Cachorro para simular o latido
  latir(): void {
    console.log('Latindo...');
  }
}

// Cria uma instância da classe Cachorro com nome e raça
const cachorro = new Cachorro('Pimpolho', 'Salsicha');

// Chama o método latir na instância do Cachorro
// Saída: 'Latindo...'
cachorro.latir();

// Exemplo adicional: chamando o método sobrescrito
// Saída: 'Au au!'
// cachorro.fazerSom();

/**
 * Classe base representando uma forma geométrica.
 */
class Forma {
  /**
   * Calcula a área de uma forma.
   * @returns A área calculada como um número. Retorna 0 na classe base,
   * pois uma forma genérica não tem área definida.
   * Classes derivadas devem sobrescrever este método.
   */
  public calcularArea(): number {
    return 0;
  }
}

/**
 * Representa uma forma de círculo, estendendo a classe base `Forma`.
 * Fornece funcionalidade para calcular a área do círculo.
 */
class Circulo extends Forma {
  // O construtor declara e inicializa a propriedade pública 'raio' diretamente.
  constructor(public raio: number) {
    super(); // Chama o construtor da classe pai (Forma)
  }

  /**
   * Calcula a área do círculo (π * raio²).
   * @returns A área calculada como um número.
   */
  public calcularArea(): number {
    return Math.PI * this.raio * this.raio;
    // Ou: return Math.PI * Math.pow(this.raio, 2);
  }
}

/**
 * Representa uma forma de retângulo, estendendo a classe base `Forma`.
 * Fornece funcionalidade para calcular a área do retângulo.
 */
class Retangulo extends Forma {
  // O construtor declara e inicializa as propriedades públicas 'largura' e 'altura'.
  constructor(public largura: number, public altura: number) {
    super(); // Chama o construtor da classe pai (Forma)
  }

  /**
   * Calcula a área do retângulo (altura * largura).
   * @returns A área calculada como um número.
   */
  public calcularArea(): number {
    return this.altura * this.largura;
  }
}

/**
 * Registra (imprime) a área de uma forma geométrica dada no console.
 * @param forma - Uma instância de uma classe que estende a classe base `Forma` (ex: Circulo, Retangulo).
 * Graças ao polimorfismo, o método `calcularArea` correto será chamado.
 */
function imprimirArea(forma: Forma): void { // Especifica o tipo de retorno void
  // Chama o método calcularArea do objeto específico (Circulo ou Retangulo)
  console.log("Área:", forma.calcularArea());
}

// Cria instâncias das formas específicas
const circulo = new Circulo(5); // Um círculo com raio 5
const retangulo = new Retangulo(10, 4); // Um retângulo 10x4

// Imprime a área de cada forma usando a mesma função
imprimirArea(circulo);    // Saída esperada: Área: 78.5398...
imprimirArea(retangulo);  // Saída esperada: Área: 40