Acoplamiento

En esta lección vamos a hablar sobre el acoplamiento.
Es un principio muy importante en la programación orientada a objetos.

Metáfora 📱

Piensa en tu teléfono móvil:

• Si lo usas mucho, te vuelves dependiente de él.

• Si un día te lo quitan, tu vida se complica.

👉 Lo mismo pasa en la programación:

cuando una clase depende demasiado de otra, decimos que están acopladas.

Y mientras más dependencias haya, más difícil es cambiar el código sin romper otras partes.

---

Ejemplo en Java (Clase Empleado)

public class Empleado {
    private int salarioBase;   // privado
    private int tasaHoraria;   // privado
    public int horaExtra;      // público (por ahora)

    // Método para calcular salario total
    public int calcularSalarioBase(int horaExtra) {
        return salarioBase + (tasaHoraria * horaExtra);
    }

    public void setSalarioBase(int salarioBase) {
        if (salarioBase <= 0)
            throw new IllegalArgumentException("Salario no puede ser menor que 0");
        this.salarioBase = salarioBase;
    }

    public int getSalarioBase() {
        return salarioBase;
    }

    public void setTasaHoraria(int tasaHoraria) {
        if (tasaHoraria < 0)
            throw new IllegalArgumentException("La tarifa por hora no puede ser negativa");
        this.tasaHoraria = tasaHoraria;
    }

    public int getTasaHoraria() {
        return tasaHoraria;
    }
}

---

Clase Principal (dependencia)

public class Main {
    public static void main(String[] args) {
        Empleado e = new Empleado();  // Punto de acoplamiento

        e.setSalarioBase(1000);       // Otro punto de acoplamiento
        e.setTasaHoraria(50);         // Otro más

        System.out.println("Salario base: " + e.getSalarioBase());
        System.out.println("Tarifa por hora: " + e.getTasaHoraria());

        int total = e.calcularSalarioBase(10);
        System.out.println("Salario con horas extra: " + total);
    }
}

En esta clase Main tenemos varios puntos de acoplamiento con Empleado. Si mañana cambiamos Empleado (por ejemplo, que requiera un nombre en el constructor), tendremos que modificar también Main.

---

Reducción del acoplamiento ✅

public class Empleado {
    private int salarioBase;
    private int tasaHoraria;
    public int horaExtra;

    public int calcularSalarioBase(int horaExtra) {
        return salarioBase + (tasaHoraria * horaExtra);
    }

    public void setSalarioBase(int salarioBase) {
        if (salarioBase <= 0)
            throw new IllegalArgumentException("Salario no puede ser menor que 0");
        this.salarioBase = salarioBase;
    }

    // Cambiamos a privados → menos métodos expuestos
    private void setTasaHoraria(int tasaHoraria) {
        if (tasaHoraria < 0)
            throw new IllegalArgumentException("La tarifa por hora no puede ser negativa");
        this.tasaHoraria = tasaHoraria;
    }

    private int getTasaHoraria() {
        return tasaHoraria;
    }
}

👉 Al ocultar métodos innecesarios (private), la interfaz de la clase es más simple. Así reducimos los puntos de acoplamiento y el riesgo de romper otras partes del sistema.

---

Analogía final 🎛️

¿Alguna vez viste un control remoto con 100 botones? Es confuso y difícil de usar.

En cambio, un control remoto con solo lo esencial es mucho más simple.

👉 En programación, menos métodos públicos = menos acoplamiento = menos dolores de cabeza.

---

Abstracción vs Acoplamiento ⚖️

Concepto	Abstracción ☕	Acoplamiento 🔗
¿Qué es?	Ocultar los detalles internos y mostrar solo lo esencial.	Grado de dependencia entre una clase y otra.
Ejemplo real	Una cafetera: solo presionas el botón hacerCafe(), sin saber cómo funciona por dentro.	Una computadora que depende del teclado: puede estar muy unida (alto acoplamiento) o solo usar una interfaz simple (bajo acoplamiento).
En código	Métodos private para detalles, y uno o pocos métodos public (hacerCafe()).	Con alto acoplamiento: pc.usarTeclado().escribirLetra(). Con bajo acoplamiento: pc.usarTeclado().
Beneficio	Interfaz más simple → fácil de usar y entender.	Sistema más flexible → fácil de mantener y modificar.

---

Resumen 🎯

• Abstracción: simplifica lo que mostramos.
  
• Acoplamiento: minimiza dependencias entre clases.

👉 Juntos hacen que el software sea más claro, flexible y robusto.