6 ‐ Programación orientada a objetos (POO) - Jabes-Gonzalez/Checkpoint-8 GitHub Wiki

La Programación Orientada a Objetos (POO) es un paradigma de programación que organiza el código en torno a entidades llamadas objetos, permitiendo modelar problemas del mundo real de forma más intuitiva, modular y reutilizable. Es la base de muchos lenguajes modernos como Java, Python, C++, JavaScript, entre otros.

Conceptos Fundamentales de la POO

Clases y Objetos

  • Clase: Es una plantilla o molde que define las características (atributos) y comportamientos (métodos) que tendrán los objetos. Ejemplo: una clase Coche puede tener atributos como marca y modelo, y métodos como arrancar() o frenar().

  • Objeto: Es una instancia concreta de una clase. Si la clase es el plano, el objeto es el producto real. Por ejemplo, un coche rojo marca Toyota creado a partir de la clase Coche.

Ejemplo
class Persona {
  constructor(nombre, edad) {
    this.nombre = nombre;
    this.edad = edad;
  }
  saludar() {
    console.log(`Hola, mi nombre es ${this.nombre} y tengo ${this.edad} años.`);
  }
}

const juan = new Persona("Juan", 25);
juan.saludar(); // Hola, mi nombre es Juan y tengo 25 años.
  • constructor: Método especial para inicializar nuevas instancias.
  • this: Referencia al objeto actual.
Atributos y Métodos
  • Atributos: Son las propiedades o datos que describen el estado de un objeto (ej: color, velocidad).
  • Métodos: Son las funciones o acciones que puede realizar el objeto (ej: avanzar, frenar).

Los Cuatro Pilares de la POO

Encapsulamiento

Permite ocultar los detalles internos de un objeto, exponiendo solo lo necesario. Esto protege los datos y controla el acceso mediante métodos públicos y privados. En JavaScript moderno, se puede usar el prefijo # para declarar propiedades privadas:

class CuentaBancaria {
  #saldo;
  constructor(saldoInicial) {
    this.#saldo = saldoInicial;
  }
  depositar(cantidad) {
    this.#saldo += cantidad;
  }
  mostrarSaldo() {
    console.log(`Saldo: ${this.#saldo}`);
  }
}

const cuenta = new CuentaBancaria(1000);
cuenta.depositar(500);
cuenta.mostrarSaldo(); // Saldo: 1500
// cuenta.#saldo; // Error: propiedad privada
Beneficios:
  • Protección de datos.
  • Facilidad de mantenimiento.
  • Control de acceso.
Abstracción

Consiste en identificar y modelar solo los aspectos esenciales de un objeto, ocultando la complejidad innecesaria. Permite centrarse en lo importante para la solución del problema.

Herencia

Permite crear nuevas clases basadas en otras existentes, reutilizando y extendiendo sus atributos y métodos. Facilita la reutilización de código y la creación de jerarquías lógicas.

Ejemplo:

class Animal {
  constructor(nombre) {
    this.nombre = nombre;
  }
  hacerSonido() {
    console.log("El animal hace un sonido.");
  }
}

class Perro extends Animal {
  hacerSonido() {
    console.log(`${this.nombre} ladra: ¡Guau, guau!`);
  }
}

const miPerro = new Perro("Rex");
miPerro.hacerSonido(); // Rex ladra: ¡Guau, guau!
  • extends: Indica que Perro hereda de Animal.
  • Sobrescritura de métodos para polimorfismo.
Polimorfismo

Es la capacidad de los objetos de diferentes clases relacionadas por herencia de responder de manera distinta al mismo mensaje o método. Permite que un mismo método tenga comportamientos diferentes según el objeto que lo invoque.

Ejemplo
class Gato extends Animal {
  hacerSonido() {
    console.log(`${this.nombre} maulla: ¡Miau, miau!`);
  }
}

const gato = new Gato("Michi");
gato.hacerSonido(); // Michi maulla: ¡Miau, miau!

Componentes Fundamentales

  • Clases: Plantillas para crear objetos; definen atributos y métodos.
  • Objetos: Instancias de clases con datos propios.
  • Atributos: Datos o propiedades de los objetos.
  • Métodos: Acciones o comportamientos de los objetos.

Ejemplo Práctico

class Animal {
  constructor(nombre) {
    this.nombre = nombre;
  }
  hablar() {
    console.log(`${this.nombre} hace un ruido.`);
  }
}

class Perro extends Animal {
  hablar() {
    console.log(`${this.nombre} ladra.`);
  }
}

const miPerro = new Perro("Rex");
miPerro.hablar(); // Rex ladra.

Aquí se muestra herencia, encapsulamiento y polimorfismo en acción.

Beneficios de la POO

  • Modularidad: El código se divide en partes independientes (clases/objetos).
  • Reutilización: La herencia permite reutilizar código existente.
  • Mantenibilidad: Cambios en una clase no afectan otras partes si están bien encapsuladas.
  • Escalabilidad: Facilita el crecimiento y la complejidad del software.

Resumen Visual de los Pilares

image

Resumen de Diagramas UML Comunes en POO

image