Por qué la programación orientada a objetos sigue siendo clave
Cuando un programa crece más allá de unos cientos de líneas, el principal problema deja de ser la sintaxis y pasa a ser la organización. Aparecen decenas de funciones que comparten datos, variables globales que cambian de valor sin que nadie sepa quién las tocó y módulos que no se pueden modificar sin romper otro. La programación orientada a objetos, que abreviaremos como POO, nació como respuesta a ese caos: agrupar los datos y el comportamiento que los manipula en una misma unidad, de modo que cada pieza del sistema tenga una responsabilidad clara y una frontera visible.
En este tutorial vamos a recorrer la POO de forma práctica, con ejemplos escritos en Python y en TypeScript. Elegimos estos dos lenguajes porque representan dos formas distintas de entender el paradigma. Python es dinámico, flexible y confía en las convenciones. TypeScript añade un sistema de tipos estático sobre JavaScript y obliga a declarar con precisión qué forma tiene cada objeto. Comparar ambos ayuda a separar lo esencial del paradigma de lo que es solo una decisión de cada lenguaje.
Sobre versiones: Python 3.14 es la versión estable más reciente que he podido confirmar, publicada en octubre de 2025, y los ejemplos son compatibles con ella. En TypeScript he confirmado la serie 5.9, y todo lo que se muestra funciona con cualquier versión 5.x reciente; antes de instalar conviene comprobar la última con el comando npm view typescript version. Los ejemplos no dependen de funciones experimentales, así que seguirán siendo válidos durante bastante tiempo.
Si quieres reforzar la base conceptual antes de seguir, puedes consultar los pilares de la programación orientada a objetos, que los describe con más detalle teórico. Aquí nos centraremos en escribir código, en equivocarnos a propósito y en corregirlo.
Lo que cubriremos, en orden, es lo siguiente:
- Un repaso rápido del origen del paradigma y de su estado actual.
- Las piezas básicas: clases, objetos, atributos y métodos.
- Los cuatro pilares aplicados a un ejemplo coherente.
- La eterna discusión entre composición y herencia.
- Errores frecuentes, buenas prácticas y casos reales de uso.
De Simula a los lenguajes actuales
La idea de combinar datos y procedimientos en una sola entidad apareció en los años sesenta con Simula, un lenguaje pensado para escribir simulaciones. Un simulador necesita representar muchos elementos parecidos, como clientes en una cola o vehículos en una carretera, cada uno con su propio estado y su propia conducta. Simula introdujo las clases y los objetos precisamente para modelar esa realidad. Poco después, Smalltalk llevó la idea al extremo: todo era un objeto y todo se resolvía enviando mensajes.
En las décadas siguientes el paradigma se extendió con C++, que lo trajo al mundo de los sistemas, y con Java, que lo convirtió en el estándar de la empresa a partir de los noventa. C# siguió el mismo camino en la plataforma de Microsoft a comienzos de los dos mil. Ruby, Python y PHP incorporaron sus propios modelos de objetos, y JavaScript tomó un camino singular con herencia basada en prototipos, que más tarde se envolvió con la sintaxis de clases para resultar familiar.
Hoy casi ningún lenguaje popular es puramente orientado a objetos. Python, TypeScript, Kotlin, Swift, Rust o Go mezclan objetos con funciones de primera clase, inmutabilidad, tipos algebraicos y programación funcional. Lo sensato no es adoptar el paradigma como una religión, sino saber cuándo un objeto es la herramienta adecuada y cuándo basta una función o una estructura de datos simple. Esa es la perspectiva que seguiremos.
Clases, objetos, atributos y métodos
Una clase es una plantilla que describe qué datos tiene una cosa y qué puede hacer. Un objeto es una instancia concreta creada a partir de esa plantilla, con valores propios. Los datos se llaman atributos y las operaciones se llaman métodos. Para verlo con un ejemplo distinto al típico de animales, modelemos una biblioteca que presta libros.
class Libro:
def __init__(self, titulo: str, isbn: str, copias: int = 1) -> None:
self.titulo = titulo
self.isbn = isbn
self.copias = copias
def hay_disponibles(self) -> bool:
return self.copias > 0
def prestar(self) -> None:
if not self.hay_disponibles():
raise ValueError(f"No quedan copias de {self.titulo}")
self.copias -= 1
def devolver(self) -> None:
self.copias += 1
novela = Libro("La sombra del viento", "9788408163435", copias=2)
novela.prestar()
print(novela.copias)
La salida de ese fragmento es muy simple:
1
Cada llamada a Libro(...) crea un objeto independiente. Si creamos otro libro, sus copias no se mezclan con las del primero. El parámetro self representa al objeto concreto sobre el que se invoca el método, y es la forma en que Python conecta el comportamiento con los datos.
El mismo concepto en TypeScript exige declarar los tipos de los atributos y su visibilidad:
class Libro {
constructor(
public readonly titulo: string,
public readonly isbn: string,
private copias: number = 1,
) {}
hayDisponibles(): boolean {
return this.copias > 0;
}
prestar(): void {
if (!this.hayDisponibles()) {
throw new Error(`No quedan copias de ${this.titulo}`);
}
this.copias -= 1;
}
devolver(): void {
this.copias += 1;
}
}
const novela = new Libro("La sombra del viento", "9788408163435", 2);
novela.prestar();
Fíjate en dos diferencias. Primero, TypeScript permite declarar los atributos directamente en la lista de parámetros del constructor, lo que ahorra repetición. Segundo, readonly impide reasignar el título o el ISBN después de crear el objeto, algo que en Python tendrías que lograr con propiedades o con dataclasses congeladas.
Un detalle útil de Python moderno es el decorador dataclass, que genera el constructor, la representación y la comparación a partir de las anotaciones de tipo. Para clases cuyo propósito principal es guardar datos, reduce mucho el código repetitivo:
from dataclasses import dataclass
@dataclass(frozen=True)
class Socio:
numero: int
nombre: str
correo: str
ana = Socio(numero=17, nombre="Ana", correo="[email protected]")
print(ana)
Socio(numero=17, nombre='Ana', correo='[email protected]')
Con frozen=True el objeto es inmutable, lo que evita toda una familia de errores asociados al estado compartido. Más adelante veremos por qué esto importa.
Encapsulamiento: proteger el estado interno
El encapsulamiento consiste en esconder los detalles internos de un objeto y exponer solo una interfaz controlada. La idea no es la privacidad por sí misma, sino garantizar que el objeto siempre se encuentre en un estado válido. Si cualquiera puede escribir directamente en un atributo, nadie puede asegurar que se respeten las reglas del negocio.
Imagina una cuenta de ahorro. Si el saldo es un atributo público, cualquier parte del programa puede dejarlo en negativo. Si el saldo solo se modifica mediante métodos que validan la operación, la regla vive en un único lugar.
class CuentaAhorro:
def __init__(self, titular: str, saldo_inicial: float = 0.0) -> None:
if saldo_inicial < 0:
raise ValueError("El saldo inicial no puede ser negativo")
self._titular = titular
self._saldo = saldo_inicial
@property
def saldo(self) -> float:
return self._saldo
def ingresar(self, cantidad: float) -> None:
if cantidad <= 0:
raise ValueError("La cantidad debe ser positiva")
self._saldo += cantidad
def retirar(self, cantidad: float) -> None:
if cantidad <= 0:
raise ValueError("La cantidad debe ser positiva")
if cantidad > self._saldo:
raise ValueError("Fondos insuficientes")
self._saldo -= cantidad
En Python no existe la privacidad estricta. La convención del guion bajo inicial indica a otros desarrolladores que un atributo es interno y que no debe tocarse desde fuera. La propiedad saldo ofrece lectura sin permitir escritura, porque no hemos definido un setter. Si alguien intenta asignar a cuenta.saldo, Python lanzará un error de atributo.
TypeScript ofrece modificadores de acceso verificados en compilación. Además, el lenguaje admite campos privados reales con la almohadilla, que se aplican también en tiempo de ejecución:
class CuentaAhorro {
#saldo: number;
constructor(private readonly titular: string, saldoInicial = 0) {
if (saldoInicial < 0) {
throw new Error("El saldo inicial no puede ser negativo");
}
this.#saldo = saldoInicial;
}
get saldo(): number {
return this.#saldo;
}
retirar(cantidad: number): void {
if (cantidad <= 0) throw new Error("La cantidad debe ser positiva");
if (cantidad > this.#saldo) throw new Error("Fondos insuficientes");
this.#saldo -= cantidad;
}
}
Hay una diferencia importante entre ambos mecanismos. La palabra private de TypeScript desaparece al compilar a JavaScript, así que alguien con acceso al objeto en ejecución podría saltársela. El campo con almohadilla, en cambio, está protegido por el propio motor de JavaScript. Elige según el nivel de garantía que necesites.
Un buen indicador de que tu encapsulamiento funciona es que puedes cambiar la representación interna sin tocar al resto del programa. Si mañana el saldo pasa a guardarse en céntimos como entero para evitar errores de redondeo, los usuarios de la clase no deberían enterarse.
Abstracción: mostrar solo lo necesario
La abstracción trabaja sobre la interfaz, no sobre los datos. Consiste en definir qué se puede pedir a un objeto sin explicar cómo lo hace. Quien usa un método de pago no necesita saber si detrás hay una pasarela, un banco o un monedero electrónico; solo necesita poder cobrar una cantidad y saber si salió bien.
En Python, las clases base abstractas permiten declarar ese contrato de forma explícita:
from abc import ABC, abstractmethod
class MetodoPago(ABC):
@abstractmethod
def cobrar(self, importe: float) -> str:
"""Devuelve un identificador de transacción."""
class PagoTarjeta(MetodoPago):
def __init__(self, ultimos_digitos: str) -> None:
self._ultimos = ultimos_digitos
def cobrar(self, importe: float) -> str:
return f"TARJ-{self._ultimos}-{importe:.2f}"
class PagoTransferencia(MetodoPago):
def __init__(self, iban: str) -> None:
self._iban = iban
def cobrar(self, importe: float) -> str:
return f"TRANS-{self._iban[-4:]}-{importe:.2f}"
Si intentas instanciar MetodoPago directamente, Python lanza un error, porque la clase tiene un método abstracto sin implementar. Lo mismo ocurre con una subclase que olvide definir cobrar. El error aparece pronto, al crear el objeto, y no mucho después en mitad de una operación real.
En TypeScript lo habitual es usar interfaces, que describen la forma que debe tener un objeto sin generar código en ejecución:
interface MetodoPago {
cobrar(importe: number): string;
}
class PagoTarjeta implements MetodoPago {
constructor(private readonly ultimosDigitos: string) {}
cobrar(importe: number): string {
return `TARJ-${this.ultimosDigitos}-${importe.toFixed(2)}`;
}
}
Una peculiaridad de TypeScript es el tipado estructural: un objeto cumple una interfaz si tiene los miembros adecuados, aunque nunca haya declarado implements. Es el equivalente estático del duck typing de Python, donde lo único que importa es que el objeto responda a los métodos que se le piden. Ambos enfoques favorecen el desacoplamiento, porque el código cliente depende del comportamiento y no de una clase concreta.
Herencia: reutilizar y especializar
La herencia permite que una clase derive de otra y reciba sus atributos y métodos, con la posibilidad de añadir nuevos o redefinir los existentes. Es útil cuando existe una relación genuina de especialización: una subclase es un caso particular de la clase base. Un gerente es un empleado, pero con responsabilidades adicionales.
class Empleado:
def __init__(self, nombre: str, salario_base: float) -> None:
self.nombre = nombre
self.salario_base = salario_base
def salario_mensual(self) -> float:
return self.salario_base
class Gerente(Empleado):
def __init__(self, nombre: str, salario_base: float, bono: float) -> None:
super().__init__(nombre, salario_base)
self.bono = bono
def salario_mensual(self) -> float:
return super().salario_mensual() + self.bono
equipo = [Empleado("Luis", 2100.0), Gerente("Marta", 3200.0, bono=450.0)]
for persona in equipo:
print(persona.nombre, persona.salario_mensual())
Luis 2100.0
Marta 3650.0
La función super() da acceso a la implementación de la clase padre, de modo que la subclase extiende el comportamiento en lugar de copiarlo. En TypeScript la sintaxis es parecida, con extends y super:
class Empleado {
constructor(public nombre: string, protected salarioBase: number) {}
salarioMensual(): number {
return this.salarioBase;
}
}
class Gerente extends Empleado {
constructor(nombre: string, salarioBase: number, private bono: number) {
super(nombre, salarioBase);
}
override salarioMensual(): number {
return super.salarioMensual() + this.bono;
}
}
La palabra override es un detalle valioso: si el método de la clase padre se renombra, el compilador avisa de que la redefinición ya no corresponde a nada, evitando que el cambio pase desapercibido. Para aprovecharla del todo conviene activar la opción de configuración que obliga a marcarla.
Python soporta herencia múltiple, y esto merece una advertencia. Cuando una clase hereda de varias, el lenguaje decide el orden de búsqueda de métodos mediante el algoritmo conocido como MRO. Funciona bien con mixins pequeños y bien delimitados, pero se vuelve difícil de razonar cuando las jerarquías se cruzan. Si necesitas profundizar en cómo el lenguaje implementa todo esto, tienes una guía específica sobre programación orientada a objetos en Python con más detalle sobre métodos especiales y el modelo de datos.
Polimorfismo: un mismo mensaje, muchas respuestas
El polimorfismo es la capacidad de tratar objetos distintos a través de una interfaz común, de modo que cada uno responda a su manera. Es la razón por la que, en el ejemplo anterior, el bucle puede recorrer empleados y gerentes sin preguntar de qué tipo es cada uno. El código que llama no contiene condicionales por tipo; delega la decisión en el objeto.
Veamos un caso donde esto brilla: un sistema de notificaciones que puede enviar avisos por varios canales.
interface Canal {
enviar(destinatario: string, mensaje: string): Promise<void>;
}
class CanalCorreo implements Canal {
async enviar(destinatario: string, mensaje: string): Promise<void> {
console.log(`Correo a ${destinatario}: ${mensaje}`);
}
}
class CanalSms implements Canal {
async enviar(destinatario: string, mensaje: string): Promise<void> {
console.log(`SMS a ${destinatario}: ${mensaje}`);
}
}
async function avisar(canales: Canal[], destinatario: string, texto: string) {
for (const canal of canales) {
await canal.enviar(destinatario, texto);
}
}
La función avisar no sabe nada de correos ni de mensajes de texto. Mañana puedes añadir un canal de mensajería instantánea sin tocar una sola línea de ella. Esa propiedad, abierta a extensión y cerrada a modificación, es uno de los ideales que formula el principio abierto/cerrado; si te interesa ese marco, los principios SOLID en el desarrollo moderno lo desarrollan junto a otros cuatro.
Comparemos con la alternativa sin polimorfismo, que es una cadena de condicionales:
def enviar_aviso(canal: str, destinatario: str, mensaje: str) -> None:
if canal == "correo":
print(f"Correo a {destinatario}: {mensaje}")
elif canal == "sms":
print(f"SMS a {destinatario}: {mensaje}")
else:
raise ValueError(f"Canal desconocido: {canal}")
Con tres canales parece manejable. Con quince, cada nueva variante obliga a editar esta función y todas las demás que hagan lo mismo repartidas por el proyecto. El polimorfismo traslada ese crecimiento a clases nuevas, que son más fáciles de probar y revisar.
Composición frente a herencia
La herencia es atractiva porque ahorra código, pero crea el acoplamiento más fuerte que ofrece el paradigma. La subclase depende de los detalles internos de la clase padre, y cualquier cambio en ella puede romper a todas las hijas. La alternativa es la composición: en lugar de decir que un objeto es otro, decimos que un objeto tiene otro y le delega trabajo.
Una pauta muy extendida entre diseñadores de software es preferir la composición cuando dudes. Para decidir, haz dos preguntas. La primera: ¿la relación es realmente de tipo es-un en todos los casos, incluidos los futuros? La segunda: ¿necesitas cambiar el comportamiento en tiempo de ejecución? Si la respuesta a la primera es dudosa o la segunda es afirmativa, la composición suele ser mejor opción.
Veamos un ejemplo clásico donde la herencia se queda corta. Supón que modelas robots de un almacén con distintas formas de moverse y de trabajar. Si usas herencia, acabarás con clases como RobotRuedasConBrazo y RobotOrugasConPinza, y el número de combinaciones explota. Con composición, cada capacidad es una pieza intercambiable:
from typing import Protocol
class Movimiento(Protocol):
def desplazar(self, metros: float) -> str: ...
class Ruedas:
def desplazar(self, metros: float) -> str:
return f"Rodando {metros} m"
class Orugas:
def desplazar(self, metros: float) -> str:
return f"Avanzando sobre orugas {metros} m"
class Robot:
def __init__(self, nombre: str, movimiento: Movimiento) -> None:
self.nombre = nombre
self._movimiento = movimiento
def ir_a(self, metros: float) -> str:
return f"{self.nombre}: {self._movimiento.desplazar(metros)}"
explorador = Robot("R-12", Orugas())
print(explorador.ir_a(8))
R-12: Avanzando sobre orugas 8.0 m
Aquí Protocol define la interfaz de forma estructural, igual que haría TypeScript. El robot no hereda de nada: recibe su estrategia de movimiento desde fuera. Esto se conoce como inyección de dependencias y es la base del patrón estrategia. Cambiar el comportamiento es tan sencillo como pasar otro objeto, incluso mientras el programa se ejecuta, y para probar la clase basta con inyectar un doble de prueba.
Esto no significa que la herencia esté prohibida. Funciona bien cuando la jerarquía es estable, poco profunda y modela un concepto real del dominio, o cuando un framework la exige, como ocurre al extender una clase base de excepciones o de componentes. Lo que conviene evitar es la herencia usada solo para reutilizar código de otra clase que no es realmente una versión más general de la tuya.
Un ejemplo completo: gestor de pedidos
Para unir los conceptos, construyamos un pequeño gestor de pedidos con una tienda en línea. Tendremos un producto, un pedido que agrupa líneas, y una política de descuento intercambiable. El objetivo es ver encapsulamiento, abstracción, composición y polimorfismo trabajando juntos, en lugar de por separado.
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
@dataclass(frozen=True)
class Producto:
sku: str
nombre: str
precio: float
class Descuento(ABC):
@abstractmethod
def aplicar(self, subtotal: float) -> float: ...
class SinDescuento(Descuento):
def aplicar(self, subtotal: float) -> float:
return subtotal
class DescuentoPorcentaje(Descuento):
def __init__(self, porcentaje: float) -> None:
if not 0 < porcentaje < 100:
raise ValueError("Porcentaje fuera de rango")
self._factor = 1 - porcentaje / 100
def aplicar(self, subtotal: float) -> float:
return round(subtotal * self._factor, 2)
@dataclass
class Pedido:
descuento: Descuento = field(default_factory=SinDescuento)
_lineas: list[tuple[Producto, int]] = field(default_factory=list)
def agregar(self, producto: Producto, cantidad: int = 1) -> None:
if cantidad < 1:
raise ValueError("La cantidad mínima es 1")
self._lineas.append((producto, cantidad))
def total(self) -> float:
subtotal = sum(p.precio * c for p, c in self._lineas)
return self.descuento.aplicar(subtotal)
pedido = Pedido(descuento=DescuentoPorcentaje(15))
pedido.agregar(Producto("TEC-01", "Teclado mecánico", 80.0))
pedido.agregar(Producto("RAT-02", "Ratón ergonómico", 45.0), cantidad=2)
print(pedido.total())
144.5
Analicemos el diseño. El producto es inmutable, así que nadie puede cambiarle el precio por accidente una vez metido en un pedido. El pedido encapsula sus líneas y valida la cantidad al agregarlas. El descuento es una abstracción con varias implementaciones, y el pedido lo recibe por composición, de modo que añadir un descuento por volumen o por cupón no modifica la clase Pedido. Cada pieza es pequeña, se puede probar de forma aislada y tiene un único motivo para cambiar.
Para comprobarlo, una prueba unitaria sencilla no necesita montar nada complicado:
def test_descuento_porcentaje_se_aplica_al_subtotal():
pedido = Pedido(descuento=DescuentoPorcentaje(10))
pedido.agregar(Producto("X-1", "Cable", 20.0), cantidad=5)
assert pedido.total() == 90.0
Errores comunes al aplicar la POO
Conocer los fallos habituales te ahorrará semanas de refactorización. Estos son los que más se repiten en proyectos reales, junto con la manera de corregirlos.
El primero son las clases que son solo contenedores de funciones. A veces se crea una clase con métodos estáticos únicamente para agrupar utilidades, sin estado alguno. En Python esto no aporta nada frente a un módulo con funciones, y en TypeScript tampoco frente a un archivo que exporta funciones. Si una clase no tiene datos que proteger ni variaciones que permitir, probablemente no necesita existir.
El segundo error es la jerarquía demasiado profunda. Cuando para entender un método tienes que subir cinco niveles de herencia, el código se vuelve opaco. Una regla práctica es no pasar de dos o tres niveles y revisar si algunos de ellos pueden sustituirse por composición. Cada nivel adicional aumenta el riesgo de que un cambio en la base tenga efectos inesperados abajo.
El tercero es la clase dios, un objeto que acumula cientos de líneas y mezcla acceso a datos, reglas de negocio, formato y envío de correos. Se reconoce porque su nombre termina en genérico, como Manager o Utils, y porque cualquier cambio del proyecto la toca. La solución es dividirla siguiendo responsabilidades, de manera que cada clase responda a una sola razón de cambio.
Otro problema habitual es exponer atributos mutables sin pensarlo. En Python, devolver directamente una lista interna permite que el código externo la modifique sin pasar por ningún método de validación. La solución es devolver una copia, una tupla o una vista de solo lectura:
class Playlist:
def __init__(self) -> None:
self._canciones: list[str] = []
def agregar(self, titulo: str) -> None:
self._canciones.append(titulo)
@property
def canciones(self) -> tuple[str, ...]:
return tuple(self._canciones)
Un error muy conocido de Python es usar valores mutables como argumentos por defecto. Una lista vacía escrita en la firma de un método se crea una sola vez y se comparte entre todas las llamadas, con efectos sorprendentes:
class Carrito:
def __init__(self, articulos=[]):
self.articulos = articulos
a = Carrito()
b = Carrito()
a.articulos.append("lápiz")
print(b.articulos)
['lápiz']
Ambos carritos comparten la misma lista. La forma correcta es usar None como valor inicial y crear la lista dentro del constructor, o bien emplear field(default_factory=list) si usas dataclasses.
En TypeScript, un tropiezo frecuente es la pérdida del contexto de this al pasar un método como función de devolución de llamada. Si pasas contador.incrementar a un temporizador, dentro del método this ya no apunta al contador. Se resuelve con una función flecha, con bind o declarando el método como propiedad de flecha, según el estilo del proyecto.
Por último, está el exceso de ingeniería. Crear interfaces, fábricas y capas de abstracción para un script de cien líneas solo añade ruido. La abstracción debe aparecer cuando hay una variación real o una necesidad de prueba, no por anticipación. Una buena heurística es esperar a tener dos implementaciones concretas antes de extraer la interfaz.
Buenas prácticas para diseñar objetos
Primero, modela comportamiento, no solo datos. Si todos tus objetos tienen únicamente atributos y la lógica vive en servicios externos que los manipulan, estás usando clases como si fueran estructuras. Esa práctica, a veces llamada modelo anémico, pierde la ventaja principal del paradigma. Pregúntate qué operaciones tienen sentido sobre el objeto y llévalas dentro de él.
En segundo lugar, favorece la inmutabilidad siempre que puedas, porque un objeto que no cambia es más fácil de entender, de compartir entre hilos y de probar. Las dataclasses congeladas en Python y los campos readonly en TypeScript son herramientas sencillas para lograrlo. Reserva la mutabilidad para los objetos cuyo propósito es precisamente cambiar de estado, como un carrito o una cuenta.
Tercero, depende de abstracciones pequeñas. Una interfaz con diez métodos obliga a sus implementadores a cargar con operaciones que quizá no necesitan. Es preferible tener varias interfaces cortas y específicas, y componer lo necesario. Los protocolos de Python y las interfaces de TypeScript lo facilitan, porque no exigen jerarquías formales.
Cuarto, usa nombres que expresen el dominio. Una clase Factura con un método anular comunica mucho más que DocumentoManager con un método procesar. Si los nombres de tus clases coinciden con el vocabulario que usa el negocio, las conversaciones con el resto del equipo se simplifican y los errores de interpretación disminuyen.
Quinto, mantén los constructores honestos. Un constructor debe dejar el objeto listo para usarse y en un estado válido; no debería abrir conexiones de red ni leer archivos como efecto secundario escondido. Si la creación es compleja, una función de fábrica o un método de clase con un nombre descriptivo, como desde_json, comunica mejor la intención.
Sexto, anota los tipos. En Python, las anotaciones no se verifican en ejecución, pero un verificador estático las usa para detectar errores antes de ejecutar nada, y los editores las aprovechan para autocompletar. Python 3.14 introdujo la evaluación diferida de anotaciones, lo que reduce los problemas de referencias circulares entre clases que antes obligaban a escribir los tipos como cadenas de texto. En TypeScript, activa el modo estricto del compilador desde el inicio del proyecto; añadirlo más tarde es mucho más costoso.
Séptimo, escribe pruebas que verifiquen el comportamiento observable y no los detalles internos. Si una prueba se rompe cada vez que renombras un método privado, el problema está en la prueba. El encapsulamiento también protege a tus tests.
Si quieres seguir profundizando, el libro clásico sobre soluciones reutilizables a problemas de diseño con objetos es Design Patterns: Elements of Reusable Object-Oriented Software. Sus ejemplos usan C++ y Smalltalk, pero los patrones se traducen sin esfuerzo a Python o TypeScript, y leerlo ayuda a reconocer cuándo una estructura ya tiene nombre y solución conocida.
Casos reales donde la POO marca la diferencia
La teoría se entiende mejor cuando se ve en acción. Estos escenarios son habituales en el trabajo diario y muestran dónde compensa pensar en objetos.
Pasarelas de pago: una tienda en línea suele integrar varios proveedores, y cada uno tiene su propia API, formatos y errores. Definir una interfaz común de cobro y una clase adaptadora por proveedor aísla las diferencias. Cuando el negocio decide cambiar de proveedor o añadir uno nuevo, el resto del sistema no se entera. Además, en las pruebas se sustituye por un objeto falso que simula respuestas sin llamar a servicios externos.
Frameworks web y ORM: los frameworks de backend modelan las tablas de la base de datos como clases, y cada fila es un objeto. Los controladores, los middlewares y las vistas basadas en clases heredan de una base que ofrece el comportamiento común. Conocer los fundamentos del paradigma te permite entender por qué se te pide extender una clase concreta o implementar un método determinado, en lugar de copiar plantillas sin comprender.
Interfaces gráficas por componentes: un botón, un campo de texto y una tabla comparten comportamientos básicos como dibujarse, responder a eventos y apilarse en un diseño. Aunque en el desarrollo web moderno se prefiere componer funciones, el modelo mental de objetos con estado, eventos y jerarquía de contenedores sigue presente. En aplicaciones de escritorio y móviles nativas, la herencia de vistas continúa siendo la base del sistema.
Videojuegos y simulaciones: volvemos al origen del paradigma. Un juego maneja cientos de entidades con posición, salud y comportamiento. Aquí se ha aprendido a la fuerza la lección de la composición: los motores modernos suelen emplear arquitecturas de entidades y componentes, donde un personaje no es una subclase de algo, sino un conjunto de componentes combinables como movimiento, daño o inventario.
Procesamiento de datos y automatización: un pipeline con etapas de lectura, limpieza, transformación y escritura se modela bien con objetos que comparten un método común de ejecución. Cada etapa se prueba por separado, se reordena con facilidad y se reutiliza en otros flujos. Los registros de configuración y las políticas de reintento también encajan de forma natural como objetos inyectables.
Sistemas heredados: en muchas empresas, buena parte del trabajo consiste en mantener código escrito hace años. Reconocer patrones como fábricas, adaptadores u observadores acelera la lectura, y saber qué problema intentaba resolver cada jerarquía ayuda a decidir si conviene refactorizar o dejarla como está.
Cuándo no usar objetos
Un paradigma es una herramienta, y reconocer sus límites es parte del oficio. Hay situaciones donde una función pura es más clara que una clase: transformar una lista, calcular un impuesto o formatear una fecha no requiere estado ni polimorfismo. Forzar un objeto en esos casos solo añade ceremonia.
Tampoco conviene modelar con clases cada elemento que aparece en el dominio. Los datos que se leen de una API y se envían a otra a menudo se manejan mejor como estructuras simples, tipos de datos con campos o diccionarios tipados, con funciones que los transforman. En TypeScript, las uniones discriminadas permiten modelar variantes sin una jerarquía de clases, con el compilador comprobando que se hayan tratado todos los casos:
type Resultado =
| { tipo: "exito"; valor: number }
| { tipo: "error"; motivo: string };
function describir(r: Resultado): string {
switch (r.tipo) {
case "exito":
return `Obtenido ${r.valor}`;
case "error":
return `Falló: ${r.motivo}`;
}
}
Para equipos que trabajan con concurrencia intensa, el estado mutable compartido entre objetos es una fuente de errores difíciles de reproducir. En esos contextos, combinar objetos inmutables con funciones puras suele producir sistemas más predecibles. La mayoría de los proyectos sanos de hoy mezclan ambos estilos: objetos para las entidades y servicios con identidad y responsabilidades, funciones para las transformaciones.
Ruta de práctica recomendada
Leer no basta; el diseño con objetos se aprende escribiendo y rehaciendo. Una ruta razonable consiste en elegir un problema pequeño y resolverlo varias veces con enfoques distintos, comparando el resultado.
- Implementa el gestor de pedidos de este tutorial en el segundo lenguaje que no hayas usado y compara cómo cambian las decisiones.
- Añade un nuevo tipo de descuento y comprueba que no tienes que modificar la clase del pedido.
- Reescribe una jerarquía de herencia de tres niveles usando composición y mide cuánto código desaparece o se simplifica.
- Escribe pruebas con dobles para el pago y la notificación, y observa qué clases resultan difíciles de aislar; esa dificultad suele revelar un acoplamiento oculto.
- Revisa un proyecto propio antiguo y busca clases dios, atributos públicos mutables y condicionales por tipo.
Si trabajas en equipo, propón revisiones de código centradas en el diseño, no solo en el estilo. Preguntas como quién es responsable de esta regla o qué ocurre si añadimos otra variante abren conversaciones mucho más productivas que discutir el nombre de una variable.
Conclusiones
La programación orientada a objetos no es un conjunto de palabras clave, sino una forma de repartir responsabilidades. Las clases y los objetos agrupan datos y comportamiento; el encapsulamiento protege la validez del estado; la abstracción define contratos pequeños; la herencia especializa cuando la relación es genuina; y el polimorfismo permite que el código cliente ignore los detalles de cada variante.
Los ejemplos en Python y TypeScript muestran que los conceptos son los mismos aunque las herramientas difieran. Python te da flexibilidad, protocolos y dataclasses; TypeScript te da verificación en compilación, modificadores de acceso y tipado estructural. En ambos casos, la composición suele ser más segura que la herencia profunda, la inmutabilidad simplifica el razonamiento y las abstracciones deben ganarse con casos reales en lugar de anticiparse.
Si te quedas con una idea, que sea esta: diseña objetos pequeños, con un propósito claro y fronteras bien definidas, y usa el paradigma solo donde aporte claridad. Con práctica constante, la revisión crítica de tu propio código y el estudio de patrones consolidados, pasarás de escribir clases porque el lenguaje lo permite a diseñarlas porque el problema lo pide.
