Introducción a la Programación Avanzada

¿Por qué hay programas que son fáciles de mantener y ampliar mientras otros son un desastre? La diferencia está en usar los conceptos avanzados de programación orientada a objetos que vas a dominar en este tema.

Los tres pilares fundamentales son el encapsulamiento, la herencia y el polimorfismo. Estos conceptos te permiten crear código reutilizable, trabajar mejor en equipo y hacer programas que pueden crecer sin romperse.

Sí, al principio diseñar con estos principios es más difícil, pero el tiempo extra que inviertas ahora te ahorrará horas (¡o días!) de trabajo después.

💡 Tip clave: Los programas bien construidos no se reconocen por lo que hacen, sino por lo fácil que es cambiarlos y mejorarlos.

Encapsulamiento: Protege Tus Datos

El encapsulamiento es tu primera línea de defensa contra errores tontos. Imagínate poder asignar una edad de -238 años a una persona... ¡un desastre!

La regla de oro: las propiedades deben ser private y solo se accede a ellas mediante métodos. Así mantienes el control total sobre qué valores pueden tener.

// ❌ MAL - Cualquiera puede meter valores absurdos
public class Persona{
    public int edad;
}

// ✅ BIEN - Solo puedes cambiar la edad usando métodos
public class Persona{
    private int edad;
    
    public void setEdad(int e){
        if(e >= 0) edad = e; // Control de calidad
    }
}

Cuando encapsulas bien, conviertes tu clase en una caja fuerte donde solo entra lo que tiene sentido.

💡 Recuerda: Una clase bien encapsulada tiene propiedades privadas y métodos públicos para acceder a ellas de forma controlada.

Modificadores de Acceso Flexibles

A veces necesitas relajar un poco las reglas del encapsulamiento sin perder el control. Para eso tienes el modificador por defecto (sin escribir nada) y protected.

El modificador por defecto permite acceso a clases del mismo paquete. Es perfecto cuando trabajas en equipo y confías en tus compañeros:

package daw.oficina;
public class Empleado{
    int sueldo; // Solo accesible desde daw.oficina
}

public class Jefe {
    public void subirSueldo(Empleado empleado, double cantidad){
        empleado.sueldo += cantidad; // ¡Funciona!
    }
}

Cuándo usar cada modificador:

• private: Solo tú puedes acceder
• Por defecto: Tu equipo del mismo paquete puede acceder
• protected: Las clases hijas también pueden acceder
• public: Todo el mundo puede acceder

💡 Consejo práctico: Usa el modificador por defecto cuando trabajas en equipo y haces muchas clases relacionadas en el mismo paquete.

Herencia: Reutiliza Como Un Pro

La herencia te permite crear clases que "son un tipo de" otra clase. Es como tener un molde base (clase padre) y crear versiones especializadas (clases hijas).

La clave mental: cuando programas Empleado extends Persona, cada empleado automáticamente ES una persona. No necesitas crear objetos Persona dentro de Empleado.

public class Empleado extends Persona{
    private double sueldo;
    
    public double getIMC(){
        return peso/(altura*altura); // Usa propiedades heredadas
    }
}

Los constructores son especiales: no se heredan, pero la clase hija debe llamar al constructor del padre con super():

public Empleado(String n, int e, double t, double p, double s){
    super(n,e,t,p); // Primero inicializa la parte "Persona"
    sueldo = s;     // Luego la parte "Empleado"
}

💡 Truco: La llamada a super() siempre debe ser la primera línea del constructor de la clase hija.

Modificador Protected en Herencia

El modificador protected es tu aliado perfecto para la herencia. Permite que las clases hijas vean propiedades y métodos que están ocultos para el resto del mundo.

Tabla de permisos (de más restrictivo a menos):

• private → Solo la propia clase
• Por defecto → La propia clase + mismo paquete
• protected → La propia clase + mismo paquete + clases hijas
• public → Todo el mundo

public class Persona{
    private String nombre;   // Solo Persona puede acceder
    int edad;               // Persona + mismo paquete
    protected double peso;  // Persona + paquete + hijas
    public double altura;   // Todo el mundo
}

Esto significa que cuando programes Empleado extends Persona, podrás usar directamente peso y altura, pero necesitarás getters para acceder a nombre y edad (si están en paquetes diferentes).

La estrategia ganadora: usa private por defecto, protected solo para propiedades que las clases hijas necesiten modificar directamente, y public para la interfaz de tu clase.

💡 Dato curioso: Muchos programadores profesionales no saben que protected también incluye acceso por paquete. ¡Ya sabes más que ellos!