Tutorial: Clases Abstractas y Estáticos en
TypeScript
📚 Parte 1: Clases Abstractas
1.1 ¿Qué son las Clases Abstractas?
Las clases abstractas son clases base que no pueden ser instanciadas directamente. Sirven como plantilla para
otras clases y pueden contener tanto métodos abstractos (que deben ser implementados por las clases hijas)
como métodos concretos (con implementación).
Ejemplo 1: Clase Abstracta Básica
abstract class Figura {
protected color: string;
constructor(color: string) {
this.color = color;
}
// Método abstracto - debe ser implementado por las clases hijas
abstract calcularArea(): number;
// Método concreto - implementación compartida
mostrarColor(): string {
return `Esta figura es de color ${this.color}`;
}
}
// Implementación de una clase hija
class Cuadrado extends Figura {
private lado: number;
constructor(color: string, lado: number) {
super(color);
this.lado = lado;
}
calcularArea(): number {
return this.lado * this.lado;
}
}
// Uso
const cuadrado = new Cuadrado("rojo", 5);
console.log(cuadrado.mostrarColor()); // "Esta figura es de color rojo"
console.log(cuadrado.calcularArea()); // 25
🏋 Ejercicio Práctico 1
Completa el siguiente código implementando una clase Circulo que herede de Figura:
// Tu implementación aquí
class Circulo extends Figura {
private radio: number;
constructor(color: string, radio: number) {
// Completa el constructor
}
calcularArea(): number {
// Implementa el cálculo del área de un círculo (π * r²)
}
}
📚 Parte 2: Miembros Estáticos
2.1 ¿Qué son los Miembros Estáticos?
Los miembros estáticos (propiedades y métodos) pertenecen a la clase misma y no a las instancias individuales.
Se acceden directamente a través de la clase y son compartidos por todas las instancias.
Ejemplo 2: Propiedades y Métodos Estáticos
class Calculadora {
static PI: number = 3.14159;
static contador: number = 0;
constructor() {
Calculadora.contador++;
}
static sumar(a: number, b: number): number {
return a + b;
}
static obtenerInstanciasCreadas(): number {
return Calculadora.contador;
}
}
// Uso
console.log(Calculadora.PI); // 3.14159
console.log(Calculadora.sumar(5, 3)); // 8
const calc1 = new Calculadora();
const calc2 = new Calculadora();
console.log(Calculadora.obtenerInstanciasCreadas()); // 2
🏋 Ejercicio Práctico 2
Implementa una clase Conversor con métodos estáticos para conversión de unidades:
class Conversor {
// Implementa las siguientes propiedades y métodos estáticos:
// 1. Una propiedad KILOMETROS_A_MILLAS que almacene el factor de conversión
(0.621371)
// 2. Un método kilometrosAMillas que convierta kilómetros a millas
// 3. Un método millasAKilometros que convierta millas a kilómetros
}
🎯 Ejercicios Propuestos
Ejercicio 1: Sistema de Vehículos
Crea un sistema de vehículos con las siguientes características:
1. Una clase abstracta Vehiculo con:
o Propiedades: marca, modelo, año
o Método abstracto: calcularVelocidadMaxima()
o Método abstracto: obtenerInformacion()
o Método concreto: obtenerEdad()
2. Implementa dos clases hijas: Coche y Motocicleta
Ejercicio 2: Registro de Usuarios
Implementa un sistema de registro de usuarios con:
1. Una clase estática RegistroUsuarios que:
o Mantenga un contador de usuarios registrados
o Tenga un método para registrar nuevos usuarios
o Tenga un método para verificar si un usuario existe
o Almacene los usuarios en un array estático
🔍 Soluciones Sugeridas
Solución Ejercicio Práctico 1
class Circulo extends Figura {
private radio: number;
constructor(color: string, radio: number) {
super(color);
this.radio = radio;
}
calcularArea(): number {
return Math.PI * this.radio * this.radio;
}
}
Solución Ejercicio Práctico 2
class Conversor {
static readonly KILOMETROS_A_MILLAS: number = 0.621371;
static kilometrosAMillas(km: number): number {
return km * Conversor.KILOMETROS_A_MILLAS;
}
static millasAKilometros(millas: number): number {
return millas / Conversor.KILOMETROS_A_MILLAS;
}
}
📝 Puntos Clave a Recordar
1. Clases Abstractas:
o No pueden ser instanciadas directamente
o Pueden contener métodos abstractos y concretos
o Los métodos abstractos deben ser implementados por las clases hijas
o Sirven como plantilla para otras clases
2. Miembros Estáticos:
o Pertenecen a la clase, no a las instancias
o Se acceden directamente desde la clase
o Son compartidos por todas las instancias
o Útiles para utilidades y constantes compartidas
🔄 Práctica Adicional
Para reforzar estos conceptos, intenta:
1. Combinar clases abstractas con miembros estáticos
2. Crear jerarquías más complejas de clases
3. Implementar patrones de diseño que utilicen estas características
🤔 Preguntas de Autoevaluación
1. ¿Por qué usarías una clase abstracta en lugar de una interfaz?
2. ¿Cuándo es apropiado usar miembros estáticos?
3. ¿Puede una clase abstracta tener constructor?
4. ¿Pueden los métodos estáticos acceder a propiedades no estáticas?
