
Programación Orientada a Objetos explicada simple
Publicado el Oct 2, 2025
Mira el video de este artículo.
OOP es simplemente una forma de organizar tu código: en lugar de tener variables y funciones sueltas por todos lados, las agrupas en “clases” que representan cosas del mundo real. Un Perro
tiene propiedades como nombre
y métodos como ladrar()
.
Ahora, OOP está genial para proyectos medianos, pero cuando crece mucho puede convertirse en un laberinto de clases heredando de clases que implementan interfaces que extienden otras clases… (sí Java, te estamos viendo 👀). La clave es usarlo con moderación.
¿Por qué usar OOP?
- Organización: Tu código está mejor estructurado
- Reutilización: Puedes usar las mismas clases en diferentes lugares
- Mantenimiento: Es más fácil encontrar y arreglar errores
- Colaboración: Otros programadores entienden tu código más fácilmente
- Escalabilidad: Puedes agregar nuevas funciones sin romper lo existente
¿Qué es una Clase?
Una clase es como un molde o una plantilla para crear cosas similares. Es como el plano de una casa: no es una casa real, pero contiene las instrucciones para construir muchas casas.
Imagínate que quieres programar diferentes tipos de perros. Sin clases, tendrías que hacer esto:
# Sin clases - repetitivo y desorganizado
perro1_nombre = "Max"
perro1_raza = "Labrador"
perro1_edad = 3
perro2_nombre = "Luna"
perro2_raza = "Pastor Alemán"
perro2_edad = 5
def ladrar_perro1():
print("Max dice: ¡Guau!")
def ladrar_perro2():
print("Luna dice: ¡Guau!")
Con clases, puedes hacer esto:
# Con clases - organizado y reutilizable
class Perro {
nombre
raza
edad
function ladrar() {
print(nombre + " dice: ¡Guau!")
}
}
La clase Perro
es el molde. Contiene las características (nombre, raza, edad) y comportamientos (ladrar) que todos los perros van a tener.
Propiedades y Métodos
Las clases tienen dos tipos de elementos:
Propiedades (Variables)
Son las características o datos que guarda el objeto:
class Perro {
nombre # Propiedad
raza # Propiedad
edad # Propiedad
energia # Propiedad
}
Métodos (Funciones)
Son las acciones que puede hacer el objeto:
class Perro {
nombre
raza
edad
energia = 100
function ladrar() { # Método
print(nombre + " dice: ¡Guau!")
}
function correr() { # Método
energia = energia - 10
print(nombre + " está corriendo!")
}
function dormir() { # Método
energia = 100
print(nombre + " está durmiendo... zzz")
}
}
¿Qué es un Objeto?
Un objeto es una “cosa real” creada usando la clase como molde. Es como construir una casa real usando el plano.
# Crear objetos (instancias) de la clase Perro
max = new Perro()
max.nombre = "Max"
max.raza = "Labrador"
max.edad = 3
luna = new Perro()
luna.nombre = "Luna"
luna.raza = "Pastor Alemán"
luna.edad = 5
# Usar los objetos
max.ladrar() # "Max dice: ¡Guau!"
luna.ladrar() # "Luna dice: ¡Guau!"
Ahora tienes dos objetos (max
y luna
) creados a partir de la misma clase (Perro
), pero cada uno tiene sus propios datos.
Constructor
El constructor es un método especial que se ejecuta automáticamente cuando creas un nuevo objeto. Te permite inicializar las propiedades desde el principio:
class Perro {
nombre
raza
edad
energia
# Constructor - se ejecuta al crear el objeto
constructor(nombre_inicial, raza_inicial, edad_inicial) {
nombre = nombre_inicial
raza = raza_inicial
edad = edad_inicial
energia = 100
}
function ladrar() {
print(nombre + " dice: ¡Guau!")
}
}
# Ahora es más fácil crear objetos
max = new Perro("Max", "Labrador", 3)
luna = new Perro("Luna", "Pastor Alemán", 5)
Herencia
La herencia es cuando una clase “hereda” propiedades y métodos de otra clase. Es como decir “esta nueva clase es como la anterior, pero con algunas diferencias”.
Imagínate que quieres crear diferentes tipos de animales:
# Clase padre (clase base)
class Animal {
nombre
edad
energia
function constructor(nombre_inicial, edad_inicial) {
nombre = nombre_inicial
edad = edad_inicial
energia = 100
}
function dormir() {
energia = 100
print(nombre + " está durmiendo...")
}
function comer() {
energia = energia + 20
print(nombre + " está comiendo")
}
}
# Clase hija - hereda de Animal
class Perro extends Animal {
raza
function constructor(nombre_inicial, edad_inicial, raza_inicial) {
super(nombre_inicial, edad_inicial) # Llamar al constructor del padre
raza = raza_inicial
}
function ladrar() { # Método específico de Perro
print(nombre + " dice: ¡Guau!")
}
}
# Otra clase hija
class Gato extends Animal {
color
function constructor(nombre_inicial, edad_inicial, color_inicial) {
super(nombre_inicial, edad_inicial)
color = color_inicial
}
function maullar() { # Método específico de Gato
print(nombre + " dice: ¡Miau!")
}
}
Ahora puedes crear perros y gatos que automáticamente tienen los métodos de Animal
:
max = new Perro("Max", 3, "Labrador")
whiskers = new Gato("Whiskers", 2, "Negro")
max.dormir() # Heredado de Animal
max.ladrar() # Específico de Perro
whiskers.comer() # Heredado de Animal
whiskers.maullar() # Específico de Gato
Interfaces
Una interfaz es como un contrato que dice “cualquier clase que use esta interfaz DEBE tener estos métodos”. No dice cómo hacerlo, solo dice qué debe hacer.
# Interfaz (contrato)
interface Volador {
function volar() # Cualquier clase que implemente Volador DEBE tener este método
function aterrizar() # Y también este método
}
# Clase que implementa la interfaz
class Pajaro implements Volador {
nombre
function constructor(nombre_inicial) {
nombre = nombre_inicial
}
function volar() { # OBLIGATORIO por la interfaz
print(nombre + " está volando!")
}
function aterrizar() { # OBLIGATORIO por la interfaz
print(nombre + " ha aterizado")
}
function cantar() { # Método adicional específico de Pajaro
print(nombre + " está cantando")
}
}
class Avion implements Volador {
modelo
function constructor(modelo_inicial) {
modelo = modelo_inicial
}
function volar() { # OBLIGATORIO por la interfaz
print("El avión " + modelo + " está volando")
}
function aterrizar() { # OBLIGATORIO por la interfaz
print("El avión " + modelo + " ha aterizado")
}
}
Las interfaces te aseguran que diferentes clases tengan métodos compatibles, aunque funcionen de manera diferente por dentro.
Polimorfismo
El polimorfismo suena complicado, pero es súper simple: significa que diferentes objetos pueden responder al mismo método de diferentes maneras. Es como decir “hablar” a un humano y a un perro - ambos entienden la instrucción, pero cada uno la ejecuta diferente.
Imagínate que tienes diferentes animales y quieres que todos “hagan sonido”:
class Animal {
nombre
function constructor(nombre_inicial) {
nombre = nombre_inicial
}
function hacer_sonido() {
print(nombre + " hace algún sonido")
}
}
class Perro extends Animal {
function hacer_sonido() { # Sobrescribe el método del padre
print(nombre + " dice: ¡Guau!")
}
}
class Gato extends Animal {
function hacer_sonido() { # Sobrescribe el método del padre
print(nombre + " dice: ¡Miau!")
}
}
class Vaca extends Animal {
function hacer_sonido() { # Sobrescribe el método del padre
print(nombre + " dice: ¡Muu!")
}
}
Ahora puedes usar polimorfismo:
# Crear diferentes animales
animales = [
new Perro("Max"),
new Gato("Whiskers"),
new Vaca("Lola")
]
# Polimorfismo en acción
for animal in animales {
animal.hacer_sonido() # Cada animal responde diferente al mismo método
}
# Resultado:
# Max dice: ¡Guau!
# Whiskers dice: ¡Miau!
# Lola dice: ¡Muu!
Lo genial del polimorfismo es que puedes tratar diferentes objetos de la misma manera, sin importar qué tipo específico sean. Tu código no necesita saber si es un perro o un gato - simplemente le dice “haz sonido” y cada uno sabe qué hacer.
Conclusión
La Programación Orientada a Objetos no es un concepto místico y complicado. Es simplemente una forma de organizar tu código usando conceptos que ya entiendes de la vida real.
Piénsalo así:
- Variables → se convierten en propiedades de objetos
- Funciones → se convierten en métodos de objetos
- Organización → se hace con clases
- Reutilización → se logra con herencia
- Consistencia → se garantiza con interfaces
Ya no necesitas tener 50 variables sueltas y 30 funciones dispersas. Con OOP, organizas todo en clases lógicas que representan cosas del mundo real.