Programação orientada o objeto em typescript

Programação Orientada a Objeto em TypeScript: Dominando Classes, Interfaces e Herança

A Programação Orientada a Objeto (POO ou OOP, do inglês Object-Oriented Programming) é um paradigma de programação poderoso que visa organizar o código de forma mais modular, reutilizável e fácil de manter. Com a ascensão do TypeScript, a POO ganha uma nova dimensão, combinando a estrutura orientada a objetos com a segurança de tipos, resultando em aplicações mais robustas e menos propensas a erros. Neste artigo, vamos mergulhar nos conceitos essenciais da Programação orientada o objeto em TypeScript.

TypeScript, sendo um superconjunto tipado de JavaScript, oferece suporte completo aos princípios da POO, como classes, interfaces, encapsulamento, herança e polimorfismo. Essa combinação é particularmente vantajosa para projetos de grande escala, onde a clareza e a previsibilidade do código são cruciais.

Fundamentos da Programação Orientada a Objeto em TypeScript

Para entender a Programação Orientada a Objeto em TypeScript, é fundamental conhecer seus pilares.

Classes e Objetos

Uma classe é um “molde” ou “planta” para criar objetos. Ela define as propriedades (atributos) e os métodos (comportamentos) que os objetos criados a partir dela terão. Um objeto é uma instância de uma classe.

No TypeScript, definimos classes de forma similar a outras linguagens orientadas a objeto:

class Carro {
    marca: string;
    modelo: string;
    ano: number;

    constructor(marca: string, modelo: string, ano: number) {
        this.marca = marca;
        this.modelo = modelo;
        this.ano = ano;
    }

    acelerar(): void {
        console.log(`${this.modelo} está acelerando!`);
    }

    frear(): void {
        console.log(`${this.modelo} está freando.`);
    }
}

// Criando um objeto (instância da classe Carro)
const meuCarro = new Carro("Toyota", "Corolla", 2023);
console.log(meuCarro.marca); // Saída: Toyota
meuCarro.acelerar(); // Saída: Corolla está acelerando!

Encapsulamento

O encapsulamento é o princípio de agrupar dados e os métodos que operam sobre esses dados em uma única unidade (a classe), protegendo os dados de acessos externos diretos e não autorizados. TypeScript implementa isso através de modificadores de acesso:

• public: Acessível de qualquer lugar (padrão).
• private: Acessível apenas dentro da própria classe.
• protected: Acessível dentro da própria classe e de suas subclasses.

class ContaBancaria {
    private _saldo: number;
    readonly numeroConta: string;

    constructor(numeroConta: string, saldoInicial: number) {
        this.numeroConta = numeroConta;
        this._saldo = saldoInicial;
    }

    public depositar(valor: number): void {
        if (valor > 0) {
            this._saldo += valor;
            console.log(`Depósito de R$${valor} realizado. Novo saldo: R$${this._saldo}`);
        }
    }

    public sacar(valor: number): boolean {
        if (valor > 0 && valor <= this._saldo) {
            this._saldo -= valor;
            console.log(`Saque de R$${valor} realizado. Novo saldo: R$${this._saldo}`);
            return true;
        }
        console.log("Saldo insuficiente ou valor inválido.");
        return false;
    }

    public get saldoAtual(): number {
        return this._saldo;
    }
}

const minhaConta = new ContaBancaria("12345-6", 1000);
minhaConta.depositar(500);
// console.log(minhaConta._saldo); // Erro: Propriedade '_saldo' é privada
console.log(`Saldo atual: R$${minhaConta.saldoAtual}`);

Herança

A herança permite que uma classe (subclasse ou classe derivada) herde propriedades e métodos de outra classe (superclasse ou classe base). Isso promove a reutilização de código e estabelece uma relação “é um tipo de”.

class Animal {
    nome: string;

    constructor(nome: string) {
        this.nome = nome;
    }

    mover(distancia: number = 0): void {
        console.log(`${this.nome} moveu ${distancia}m.`);
    }
}

class Cachorro extends Animal {
    raca: string;

    constructor(nome: string, raca: string) {
        super(nome); // Chama o construtor da classe base
        this.raca = raca;
    }

    latir(): void {
        console.log(`${this.nome} (${this.raca}) está latindo!`);
    }

    // Sobrescrita de método
    mover(distancia: number = 5): void {
        console.log(`${this.nome} correu ${distancia}m.`);
    }
}

const bob = new Cachorro("Bob", "Labrador");
bob.latir();
bob.mover(10); // Chamada do método sobrescrito

Polimorfismo

Polimorfismo significa “muitas formas”. Na POO, refere-se à capacidade de um objeto assumir muitas formas, geralmente através da sobrescrita de métodos em classes derivadas ou da implementação de interfaces. Isso permite que objetos de diferentes classes sejam tratados de maneira uniforme, desde que compartilhem uma interface ou superclasse comum.

// Usando as classes Animal e Cachorro do exemplo anterior
function fazerMover(animal: Animal): void {
    animal.mover(20);
}

const umAnimal = new Animal("Tartaruga");
const umCachorro = new Cachorro("Rex", "Poodle");

fazerMover(umAnimal);    // Saída: Tartaruga moveu 20m.
fazerMover(umCachorro); // Saída: Rex correu 20m. (Polimorfismo em ação!)

Abstração e Interfaces

A abstração foca nos aspectos essenciais de um objeto, escondendo os detalhes complexos de implementação. Em TypeScript, isso é alcançado principalmente através de classes abstratas e interfaces.

Classes Abstratas: Não podem ser instanciadas diretamente e podem conter métodos abstratos (sem implementação) que devem ser implementados pelas subclasses concretas. Funcionam como um contrato para subclasses.

abstract class FormaGeometrica {
    abstract calcularArea(): number;
    abstract calcularPerimetro(): number;

    exibirTipo(): void {
        console.log("Esta é uma forma geométrica.");
    }
}

class Circulo extends FormaGeometrica {
    raio: number;

    constructor(raio: number) {
        super();
        this.raio = raio;
    }

    calcularArea(): number {
        return Math.PI * this.raio * this.raio;
    }

    calcularPerimetro(): number {
        return 2 * Math.PI * this.raio;
    }
}

// const forma = new FormaGeometrica(); // Erro: Não é possível criar uma instância de uma classe abstrata
const meuCirculo = new Circulo(5);
console.log(`Área do círculo: ${myCirculo.calcularArea()}`);

Interfaces: Definem um “contrato” de quais propriedades e métodos um objeto deve ter, sem fornecer qualquer implementação. São puramente para verificação de tipos e são uma ferramenta poderosa para garantir a estrutura de objetos e classes na Programação orientada o objeto em TypeScript.

interface Saudavel {
    estaSaudavel(): boolean;
}

interface Voador {
    voar(): void;
}

class Pato implements Saudavel, Voador {
    nome: string;
    peso: number;

    constructor(nome: string, peso: number) {
        this.nome = nome;
        this.peso = peso;
    }

    estaSaudavel(): boolean {
        return this.peso < 3; // Exemplo simplificado
    }

    voar(): void {
        console.log(`${this.nome} está voando.`);
    }
}

const patoDonald = new Pato("Donald", 2);
console.log(`${patoDonald.nome} está saudável? ${patoDonald.estaSaudavel()}`);
patoDonald.voar();

Por Que Usar Programação Orientada a Objeto em TypeScript?

A combinação da Programação orientada o objeto em TypeScript oferece vantagens significativas:

• Organização e Manutenibilidade: Código bem estruturado em classes é mais fácil de entender, manter e escalar.
• Reutilização de Código: Herança e polimorfismo permitem a construção de componentes reutilizáveis, reduzindo a duplicação.
• Segurança de Tipos: O TypeScript adiciona verificação de tipos estática, capturando erros relacionados a tipos em tempo de compilação, antes mesmo do código ser executado. Isso é um benefício enorme para a POO, garantindo que os objetos e suas interações sigam o contrato definido.
• Colaboração: Em equipes, a POO com TypeScript padroniza a forma como o código é escrito e interagido, facilitando o trabalho em conjunto.
• Legibilidade: Com modificadores de acesso e interfaces, a intenção do código se torna mais clara para outros desenvolvedores.

Conclusão

A Programação orientada o objeto em TypeScript é uma abordagem robusta para o desenvolvimento de software, combinando os princípios testados da POO com a segurança e clareza que o TypeScript oferece. Dominar classes, encapsulamento, herança, polimorfismo e interfaces é fundamental para construir aplicações escaláveis, fáceis de manter e com menos bugs. Se você busca elevar a qualidade do seu código JavaScript, mergulhar na POO com TypeScript é, sem dúvida, um excelente caminho. Comece a aplicar esses conceitos em seus projetos e observe a diferença na organização e confiabilidade do seu código!

Continue explorando a vasta documentação do TypeScript e pratique a implementação desses conceitos em diferentes cenários para aprimorar suas habilidades.