Programación Orientada a Objetos - Una abstracción de la realidad

Hola, en este artículo, que parece tutorial, abordaremos un tema que en lo particular al principio me dio muchos dolores de cabeza. Sin embargo, esta dificultad me llevó a estudiar, estudiar y estudiar para hacer como propia la abstracción de la vida cotidiana y así llevar a líneas de código, la representación de algo tangible (créeme que esto puede llegar a ser una tarea titánica a veces). El tema terminó apasionándome de manera tal que ahora comparto en este artículo datos importantes para comprenderlo, así que vamos al hueso del asunto.

Explicaré o intentaré hacerlo de la mejor manera posible, programación orientada a objetos o por sus siglas (POO) utilizando JavaScript como mi lenguaje de elección. Para entender cómo aplicar la POO a situaciones del mundo real, tienes que internalizar que la programación orientada a objetos no es solo una técnica, ¡es un enfoque de vida! En este artículo, exploraremos conceptos fundamentales de POO y los aplicaremos a ejemplos tangibles de la vida cotidiana.

¿Qué es la Programación Orientada a Objetos?

La programación orientada a objetos es un paradigma de programación que se basa en el concepto de "objetos", puedes imaginarte en este mismo instante literalmente un objeto de la vida: una manzana, un perro, una casa, un auto, un papito de hule. Ahora, visualiza que estos objetos pueden contener datos en forma de propiedades o características y funcionalidades, es decir, pueden hacer cosas. Imagina que estás modelando un mundo virtual donde cada entidad puede ser representada como un objeto independiente con características únicas.

Objetos en la Vida Real y en la POO

Para entender mejor la POO, echemos un vistazo a un ejemplo de la vida real: un auto. Un auto puede tener propiedades como modelo, color y velocidad, así como métodos como arrancar y detener. Transpolar esto al mundo de la POO sería bastante sencillo:

class Auto {
  constructor(modelo, color) {
    this.modelo = modelo;
    this.color = color;
    this.velocidad = 0;
  }

  arrancar() {
    console.log(`El auto ${this.modelo} ha arrancado.`);
  }

  detener() {
    console.log(`El auto ${this.modelo} se ha detenido.`);
    this.velocidad = 0;
  }

  acelerar(kmh) {
    this.velocidad += kmh;
    console.log(`El auto ${this.modelo} acelera a ${this.velocidad} km/h.`);
  }
}

// Crear un objeto auto
const miAuto = new Auto('Sedán', 'Rojo');

// Utilizar métodos del objeto auto
miAuto.arrancar();
miAuto.acelerar(50);
miAuto.detener();

En este ejemplo, hemos creado una clase Auto con propiedades como modelo, color y velocidad, así como métodos, es decir, las cosas que puede hacer: como arrancar, detener y acelerar. Luego, creamos un objeto miAuto basado en esta clase y lo utilizamos para simular acciones de la vida real.

Herencia: La Clave de la Jerarquía

Imagina ahora que queremos modelar no solo coches, sino también motocicletas. Ambos comparten algunas similitudes, pero también tienen características únicas. Aquí es donde entra en juego el concepto de herencia en la POO.

class Camioneta extends Auto {
  constructor(modelo, color, tipo) {
    super(modelo, color);
    this.tipo = tipo;
  }

  realizarTruco() {
    console.log(`La camioneta ${this.modelo} ${this.tipo} realiza un asombroso truco.`);
  }
}

// Crear un objeto camioneta
const miCamioneta = new Camioneta('Explorer', 'Negra', '4x4');

// Utilizar métodos del objeto camioneta
miCamioneta.arrancar();
miCamioneta.acelerar(80);
miCamioneta.realizarTruco();
miCamioneta.detener();

Aquí, hemos creado una nueva clase Camioneta que extiende la clase Auto. La palabra clave extends nos permite heredar todas las propiedades y métodos de la clase padre (Auto). Además, la clase hija (Camioneta) puede tener propiedades y métodos adicionales.

Encapsulamiento: Protegiendo tus Secretos

El encapsulamiento es otro pilar de la POO que nos permite proteger los detalles internos de un objeto y exponer solo lo necesario. Veamos un ejemplo sencillo utilizando una "Cuenta Bancaria":

class CuentaBancaria {
  constructor(titular, saldoInicial) {
    this.titular = titular;
    this._saldo = saldoInicial; // El saldo se designa con el prefijo _ para indicar que es privado
  }

  get saldo() {
    return this._saldo;
  }

  depositar(cantidad) {
    if (cantidad > 0) {
      this._saldo += cantidad;
      console.log(`${cantidad} depositados. Nuevo saldo: ${this._saldo}`);
    } else {
      console.log("Error: La cantidad debe ser mayor que cero.");
    }
  }

  retirar(cantidad) {
    if (cantidad > 0 && cantidad <= this._saldo) {
      this._saldo -= cantidad;
      console.log(`${cantidad} retirados. Nuevo saldo: ${this._saldo}`);
    } else {
      console.log("Error: Cantidad inválida o saldo insuficiente.");
    }
  }
}

// Crear una cuenta bancaria
const miCuenta = new CuentaBancaria('Juan Pérez', 1000);

// Utilizar métodos del objeto cuenta bancaria
console.log(`Saldo inicial: ${miCuenta.saldo}`);
miCuenta.depositar(500);
miCuenta.retirar(200);

En este ejemplo, hemos encapsulado el saldo de la cuenta utilizando un método get para acceder a él. Esto protege el saldo de ser modificado directamente desde fuera de la clase, manteniendo la integridad de nuestra cuenta bancaria.

Polimorfismo: La Magia de la Versatilidad

El polimorfismo permite que diferentes clases compartan el mismo nombre de método, pero con comportamientos específicos para cada una. Para ilustrar esto, imaginemos un zoológico con animales que emiten sonidos.

class Animal {
  hacerSonido() {
    console.log('Algunos sonidos genéricos de animal.');
  }
}

class Perro extends Animal {
  hacerSonido() {
    console.log('¡Guau! ¡Guau!');
  }
}

class Gato extends Animal {
  hacerSonido() {
    console.log('¡Miau! ¡Miau!');
  }
}

// Crear objetos animales
const miAnimal = new Animal();
const miPerro = new Perro();
const miGato = new Gato();

// Utilizar el método hacerSonido de cada objeto
miAnimal.hacerSonido();
miPerro.hacerSonido();
miGato.hacerSonido();

En este ejemplo, las clases Perro y Gato heredan de la clase Animal, pero cada una sobrescribe el método hacerSonido con su propia implementación única. Esto permite que diferentes tipos de animales utilicen el mismo método de manera distinta.

Conclusión: POO... ponlo en Acción

¡Te agradezco mucho llegar este punto! Exploramos conceptos clave como objetos, herencia, encapsulamiento y polimorfismo, y los hemos aplicado a situaciones de la vida real. Recuerda, la POO es una forma de pensar que te permite modelar y entender el mundo de manera más efectiva...y llevarla a código.

Así que la próxima vez que veas un auto, una cuenta bancaria o incluso a tu mascota, piensa en cómo podrías representarlos como objetos en tu código. La programación orientada a objetos no solo es una herramienta poderosa, ¡es una forma de dar vida a tus programas!

Espero que hayas disfrutado este artículo y que le puedas sacar provecho en tus proyectos. Déjeme tus comentarios para saber que te pareció y si tienes alguna otra abstracción de la vida real. ;)