TypeScript Academy · Aula

Implementando interfaces com classes

Garanta a estrutura da classe com a palavra-chave implements

Implementando interfaces com classes é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Boas-vindas

A palavra-chave `implements` garante que uma classe cumpra um contrato de interface. O TypeScript verifica se a classe fornece todas as propriedades e os métodos necessários.

Implementação básica

Utilize `implements InterfaceName` após o nome da classe. O TypeScript gera um erro se algum membro necessário estiver ausente.

interface Printable {
  print(): void;
}
class Document implements Printable {
  print() { console.log('Printing...'); }
}

Membros ausentes causam erros

Se a classe não implementar todos os membros necessários, o TypeScript informará um erro na declaração da classe.

interface Serializable { serialize(): string; }
// Error: Class 'Broken' incorrectly implements interface 'Serializable'
// class Broken implements Serializable {}

Implementando várias interfaces

Uma classe pode implementar várias interfaces de uma só vez, separando-as por vírgulas.

interface Flyable { fly(): void; }
interface Swimmable { swim(): void; }
class Duck implements Flyable, Swimmable {
  fly() { console.log('Flying'); }
  swim() { console.log('Swimming'); }
}

interface não fornece implementação

As interfaces descrevem apenas a estrutura. A classe fornece a implementação real.

implementação com membros opcionais

Os membros opcionais da interface não precisam ser implementados. A classe pode fornecê-los, mas isso não é obrigatório.

interface Logger {
  log(msg: string): void;
  warn?(msg: string): void; // optional
}
class SimpleLogger implements Logger {
  log(msg: string) { console.log(msg); }
  // warn is not required
}

Interface para injeção de dependências

Usar interfaces como tipos de parâmetros do construtor permite a injeção de dependências — você pode passar qualquer classe que implemente a interface.

interface Storage { save(data: string): void; }
class Service {
  constructor(private storage: Storage) {}
  run() { this.storage.save('data'); }
}
class LocalStorage implements Storage {
  save(data: string) { localStorage.setItem('key', data); }
}

Extensão versus implementação

`extends` herda de outra classe (compartilha a implementação). `implements` apenas verifica a estrutura — nenhum código é herdado.

Classe implementando uma interface e estendendo uma classe

Uma classe pode estender uma classe base E implementar interfaces simultaneamente.

class Animal { breathe() { return 'breathing'; } }
interface Trainable { train(): void; }
class Dog extends Animal implements Trainable {
  train() { console.log('Sit!'); }
}

Implementações de interfaces genéricas

Uma classe pode implementar uma interface genérica fornecendo o argumento de tipo.

interface Repository<T> {
  findById(id: number): T | null;
}
class UserRepo implements Repository<User> {
  findById(id: number): User | null {
    return null; // stub
  }
}

Segurança de tipos da implementação

`implements` não adiciona comportamento em tempo de execução. Em tempo de execução, a classe não tem conhecimento da interface. Trata-se puramente de um contrato em tempo de compilação.

Verificação rápida

O que o TypeScript verifica quando uma classe usa a palavra-chave `implements`?

Recapitulação

`implements` impõe, em tempo de compilação, que uma classe cumpra um contrato de interface. Uma classe pode implementar várias interfaces. Utilize interfaces para injeção de dependências, facilidade de teste e separação entre comportamento e implementação.

Perguntas Frequentes

A aula “Implementando interfaces com classes” é grátis?

Sim — o texto completo de “Implementando interfaces com classes” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “Implementando interfaces com classes”?

Garanta a estrutura da classe com a palavra-chave implements Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Implementando interfaces com classes”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Classes e construtores em TypeScript
Modificadores public, private e protected
Propriedades readonly e propriedades de parâmetros
Implementando interfaces com classes

← Voltar para TypeScript Academy