Classes e Interfaces Genéricas no TS: Guia
⚡ Curso de TypeScript • Web-ZoneWare

Classes e Interfaces Genéricas na Prática: Estruturas de Dados e Repositórios no TypeScript

Lição 28 de 50

Classes e Interfaces Genéricas na Prática: Estruturas de Dados e Repositórios no TypeScript

⚡ Módulo 4 • Aula 28 de 50

Os Generics atingem seu ápice arquitetural quando aplicados à Programação Orientada a Objetos. Descubra como projetar Classes e Interfaces Genéricas no TypeScript para construir estruturas de dados robustas, camadas de cache e o consagrado Generic Repository Pattern adotado em sistemas corporativos.

1. O Conceito de Classes e Interfaces Genéricas

Até agora, aplicamos parâmetros de tipo no escopo de funções individuais. No entanto, muitas vezes precisamos que o estado interno de uma classe inteira ou que todos os métodos de um contrato operem sobre o mesmo tipo abstrato compartilhado.

A sintaxe é direta: declaramos os parâmetros genéricos logo após o nome da classe ou interface:

typescript

CODE 4 linhas
interface CaixaArmazenamento<T> {
    guardar(item: T): void;
    obter(): T | null;
}

2. Caso Prático 1: Estruturas de Dados Tipadas (Pilha / Stack)

Um exemplo clássico e elegante é a implementação de uma Pilha (Stack) que segue a política LIFO (Last-In, First-Out). A mesma classe pode ser reutilizada para armazenar números, comandos de histórico de desfazer (undo/redo) ou objetos de domínio:

typescript

JavaScript 34 linhas
class Pilha<T> {
    private elementos: T[] = [];
 
    // Adiciona um item ao topo da pilha:
    empilhar(item: T): void {
        this.elementos.push(item);
    }
 
    // Remove e retorna o item do topo:
    desempilhar(): T | undefined {
        return this.elementos.pop();
    }
 
    // Consulta o item do topo sem remover:
    espiar(): T | undefined {
        return this.elementos[this.elementos.length - 1];
    }
 
    obterTamanho(): number {
        return this.elementos.length;
    }
}
 
// 1. Pilha exclusiva de Histórico de Ações (Strings):
const historicoComandos = new Pilha<string>();
historicoComandos.empilhar("DIGITAR_TEXTO");
historicoComandos.empilhar("APLICAR_NEGRITO");
 
// O TypeScript garante que o item desempilhado é STRING:
const ultimoComando = historicoComandos.desempilhar();
console.log(ultimoComando?.toLowerCase()); // ___WZW_STR_0___
 
// ❌ Tentativa de empilhar número em pilha de string:
// historicoComandos.empilhar(123); // TS2345: Argument of type 'number' is not assignable to type 'string'.

3. Caso Prático 2: O Padrão Generic Repository (DDD / Clean Architecture)

Em aplicações empresariais com arquitetura limpa ou Domain-Driven Design (DDD), é padrão isolar o acesso a bancos de dados através de repositórios. Graças às interfaces genéricas, definimos um contrato universal de operações CRUD:

typescript

JavaScript 44 linhas
// Contrato Base Universal de Repositório:
interface IRepositorio<TEntidade, TId = string> {
    buscarPorId(id: TId): Promise<TEntidade | null>;
    salvar(entidade: TEntidade): Promise<void>;
    excluir(id: TId): Promise<boolean>;
    listarTodos(): Promise<TEntidade[]>;
}
 
// Entidade de Negócio:
interface UsuarioConta {
    id: string;
    nome: string;
    email: string;
}
 
// Implementação em Memória Genérica com Restrição:
class RepositorioEmMemoria<TEntidade extends { id: TId }, TId = string> 
    implements IRepositorio<TEntidade, TId> 
{
    private tabela = new Map<TId, TEntidade>();
 
    async buscarPorId(id: TId): Promise<TEntidade | null> {
        return this.tabela.get(id) ?? null;
    }
 
    async salvar(entidade: TEntidade): Promise<void> {
        this.tabela.set(entidade.id, entidade);
    }
 
    async excluir(id: TId): Promise<boolean> {
        return this.tabela.delete(id);
    }
 
    async listarTodos(): Promise<TEntidade[]> {
        return Array.from(this.tabela.values());
    }
}
 
// Instanciando o repositório fortemente tipado para Usuários:
const repoUsuario = new RepositorioEmMemoria<UsuarioConta>();
await repoUsuario.salvar({ id: "usr_10", nome: "Mariana", email: "[email protected]" });
 
const user = await repoUsuario.buscarPorId("usr_10");
console.log("Usuário recuperado:", user?.nome); // Autocompletar total!

4. Herança e Extensão de Interfaces Genéricas

Uma interface genérica pode estender outra interface genérica, propagando ou transformando o tipo. Este padrão é amplamente utilizado em paginações de listas:

typescript

JavaScript 19 linhas
interface RespostaBase<T> {
    sucesso: boolean;
    dados: T;
}
 
// Estendendo e adicionando metadados de paginação ao array de T:
interface RespostaPaginada<TItem> extends RespostaBase<TItem[]> {
    totalItens: number;
    paginaAtual: number;
    totalPaginas: number;
}
 
const resultadoAlunos: RespostaPaginada<string> = {
    sucesso: true,
    dados: ["Alice", "Bernardo", "Camila"], // Obrigatoriamente string[]
    totalItens: 45,
    paginaAtual: 1,
    totalPaginas: 15
};

5. A Regra Estrita dos Membros Estáticos (static)

Uma classe no TypeScript possui dois lados em tempo de execução: o lado da instância (criado com new) e o lado estático (a própria função construtora). Por essa razão estrutural, membros estáticos NÃO podem referenciar o tipo genérico da classe:

typescript

CODE 13 linhas
class GerenciadorSessao<T> {
    // ✅ Membro de Instância: Válido!
    dadoSessao: T | null = null;
 
    // ❌ ERRO DE COMPILAÇÃO:
    // TS2302: Static members cannot reference class type arguments.
    // static instanciaPadrao: T;
 
    // ✅ Se um método estático precisar ser genérico, declare seu próprio tipo:
    static criarVazio<U>(): GerenciadorSessao<U> {
        return new GerenciadorSessao<U>();
    }
}
💡

Dica Pro de Engenharia Web-ZoneWare: Adote o padrão de repositórios genéricos como a espinha dorsal de suas APIs corporativas. Ao criar um IRepositorio<T, TId>, você desacopla completamente sua camada de regras de negócio (Controllers e Use Cases) de qualquer banco de dados específico (PostgreSQL, MongoDB, Prisma ou TypeORM), facilitando testes unitários com mocks em memória.

🚀

Próximo Passo Prático: Agora que você domina classes e interfaces genéricas, na Lição 29 aprenderemos como extrair dinamicamente chaves e tipos de propriedades com segurança cirúrgica: O Operador keyof e Lookup Types (Indexação Tipada).

🛠️ Laboratório Prático & Prática Imediata

Aplique o que você aprendeu nesta lição

Utilize nossas ferramentas online gratuitas para experimentar os conceitos ou teste o código ao vivo no Playground IDE.

💻 Desenvolvedor & Código

Editor de Códigos Web Online

Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.

Abrir Ferramenta Online
⚡ Live Code Studio

Playground Web Online

Escreva seu código HTML, CSS ou JavaScript e veja o resultado renderizado ao vivo no navegador com zero configuração.

⚡ Codificar no Playground IDE
Foto de Web-Zoneware
✓ Verificado
🎓 Tutor & Coordenador da Web Academy

Web-Zoneware

Tutor Técnico & Desenvolvedor Full-Stack

Desenvolvedor web e instrutor focado na formação prática de novos programadores. Defensor ferrenho de código semântico, arquitetura limpa e acessibilidade W3C/WCAG, dedicando-se a construir cursos estruturados em metodologia passo a passo com execução ao vivo no Playground IDE.

Especialidades: HTML5 Semântico CSS3 & Flexbox/Grid JavaScript Moderno Acessibilidade WCAG 2.2 Didática Prática
Rolar para cima