TypeScript Academy · Lección

Implementación de interfaces con clases

Exija una estructura de clase mediante la palabra clave implements.

Implementación de interfaces con clases es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

Bienvenida

La palabra clave `implements` garantiza que una clase cumpla el contrato de una interfaz. TypeScript verifica que la clase proporcione todas las propiedades y métodos necesarios.

implements básico

Use `implements InterfaceName` después del nombre de la clase. TypeScript genera un error si falta algún miembro requerido.

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

Los miembros ausentes provocan errores

Si la clase no implementa todos los miembros requeridos, TypeScript informa de un error en la declaración de la clase.

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

Implementar varias interfaces

Una clase puede implementar varias interfaces a la vez, separándolas mediante comas.

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

interface no proporciona una implementación

Las interfaces solo describen la estructura. La clase proporciona la implementación real.

implements con miembros opcionales

Los miembros opcionales de una interfaz no tienen que implementarse. La clase puede proporcionarlos, pero no está obligada a hacerlo.

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 la inyección de dependencias

Utilizar interfaces como tipos de parámetros del constructor permite la inyección de dependencias: puede pasar cualquier clase que implemente la interfaz.

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); }
}

extends frente a implements

`extends` hereda de otra clase (comparte la implementación). `implements` solo comprueba la estructura; no se hereda ningún código.

Una clase que implementa una interfaz y extiende una clase

Una clase puede extender una clase base e implementar interfaces al mismo tiempo.

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

Implementaciones de interfaces genéricas

Una clase puede implementar una interfaz genérica proporcionando el argumento de tipo.

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

Seguridad de tipos de implements

`implements` no añade ningún comportamiento en tiempo de ejecución. En tiempo de ejecución, la clase no tiene conocimiento de la interfaz. Es únicamente un contrato en tiempo de compilación.

Comprobación rápida

¿Qué comprueba TypeScript cuando una clase utiliza la palabra clave `implements`?

Resumen

`implements` garantiza en tiempo de compilación que una clase cumpla el contrato de una interfaz. Una clase puede implementar varias interfaces. Use interfaces para la inyección de dependencias, la capacidad de prueba y la separación entre el comportamiento y la implementación.

Preguntas frecuentes

¿La lección «Implementación de interfaces con clases» es gratis?

Sí — el texto completo de «Implementación de interfaces con clases» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Implementación de interfaces con clases»?

Exija una estructura de clase mediante la palabra clave implements. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Implementación de interfaces con clases»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Clases y constructores de TypeScript
Modificadores public, private y protected
Propiedades readonly y propiedades de parámetros
Implementación de interfaces con clases

← Volver a TypeScript Academy