Programación Orientada a Objetos explicada simple

Programación Orientada a Objetos explicada simple

Publicado el Oct 2, 2025

#tutorial#OOP

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?

  1. Organización: Tu código está mejor estructurado
  2. Reutilización: Puedes usar las mismas clases en diferentes lugares
  3. Mantenimiento: Es más fácil encontrar y arreglar errores
  4. Colaboración: Otros programadores entienden tu código más fácilmente
  5. 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.