Programación Orientada a Objetos (POO)

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

La Programación Orientada a Objetos (POO) es un paradigma de programación que organiza el software en torno a objetos, que combinan datos (atributos) y comportamiento (métodos) en una misma entidad. Este enfoque busca modelar el mundo real de forma más natural e intuitiva.

Los cuatro pilares fundamentales de la POO son:

• Encapsulamiento: ocultar los detalles internos de un objeto y controlar el acceso a sus datos.
• Herencia: permite que una clase derive características de otra.
• Polimorfismo: capacidad de que distintos objetos respondan de manera diferente al mismo mensaje o método.
• Abstracción: representar las características esenciales de un objeto ignorando los detalles no relevantes.

2. Clases y Objetos

Clase

Una clase es una plantilla o molde que define la estructura y el comportamiento que tendrán los objetos creados a partir de ella. Define qué atributos (datos) y qué métodos (funciones) tendrán sus instancias.

class Coche {
    String marca;
    int velocidad;

    void acelerar() {
        velocidad += 10;
    }
}

Objeto

Un objeto es una instancia concreta de una clase. Es la entidad real en memoria que contiene valores específicos para los atributos definidos en la clase.

Coche miCoche = new Coche(); // Se crea un objeto de la clase Coche
miCoche.marca = "Toyota";

3. Constructores

Un constructor es un método especial de una clase cuya función es definir el proceso de creación e inicialización de un objeto. Se ejecuta automáticamente en el momento en que se instancia (crea) un objeto a partir de la clase.

Características de los constructores

• Tienen el mismo nombre que la clase.
• No devuelven ningún valor (ni siquiera void).
• Pueden recibir parámetros para inicializar los atributos del objeto con valores concretos.
• Si no se define ningún constructor, el lenguaje proporciona uno por defecto (vacío).
• Una clase puede tener varios constructores con distintos parámetros (sobrecarga de constructores).

Lo que hace un constructor

El constructor no declara la clase ni limita el número de objetos que se pueden instanciar. Su única responsabilidad es establecer el estado inicial del objeto en el momento de su creación.

class Coche {
    String marca;
    int velocidad;

    // Constructor
    Coche(String marca) {
        this.marca = marca;
        this.velocidad = 0;
    }
}

// Al instanciar, se invoca el constructor automáticamente
Coche miCoche = new Coche("Toyota");

En el ejemplo anterior, al escribir new Coche("Toyota"), se ejecuta el constructor, que asigna "Toyota" al atributo marca y 0 al atributo velocidad.

4. Encapsulamiento y Niveles de Acceso

El encapsulamiento es el mecanismo que permite controlar qué partes de un objeto son accesibles desde el exterior y cuáles están ocultas. Se implementa mediante modificadores de acceso.

Niveles de acceso estándar en POO

Los niveles de acceso que existen en los lenguajes orientados a objetos más extendidos (como Java, C# o C++) son:

🔒 Privado (private)

Los atributos y métodos marcados como privados solo son accesibles desde la propia clase donde están definidos. Ninguna otra clase, ni siquiera las subclases (clases hijas), puede acceder a ellos directamente.

class CuentaBancaria {
    private double saldo; // Solo accesible dentro de CuentaBancaria

    public void depositar(double cantidad) {
        saldo += cantidad; // Acceso válido: estamos dentro de la misma clase
    }
}

🛡️ Protegido (protected)

Los atributos y métodos marcados como protegidos son accesibles desde:
- La propia clase donde están definidos.
- Todas las clases que heredan de ella (subclases o clases hijas).

class Animal {
    protected String nombre; // Accesible en Animal y sus subclases
}

class Perro extends Animal {
    void mostrarNombre() {
        System.out.println(nombre); // Válido: Perro hereda de Animal
    }
}

🌐 Público (public)

Los atributos y métodos marcados como públicos son accesibles desde cualquier clase, sin restricciones, independientemente del paquete o módulo en que se encuentren.

class Persona {
    public String nombre; // Accesible desde cualquier parte del programa
}

📦 Paquete / Sin modificador (en lenguajes como Java)

En algunos lenguajes existe un nivel adicional de acceso a nivel de paquete o módulo: el atributo o método es accesible desde todas las clases del mismo paquete, pero no desde fuera. En Java, esto se obtiene simplemente no especificando ningún modificador.

⚠️ Nivel que NO existe: "Nivel cerrado"

Es importante destacar que no existe ningún nivel de acceso denominado "nivel cerrado" en la nomenclatura estándar de la programación orientada a objetos. Los modificadores de acceso reconocidos universalmente son private, protected y public (más el nivel de paquete en algunos lenguajes). Cualquier denominación distinta a estas no forma parte del estándar de la POO.

Resumen de niveles de acceso

*En Java, las subclases de otro paquete no tienen acceso al nivel de paquete.

5. Herencia

La herencia permite que una clase (subclase o clase hija) adquiera los atributos y métodos de otra clase (superclase o clase padre). Esto fomenta la reutilización de código y la creación de jerarquías.

class Vehiculo {
    int velocidad;

    void moverse() {
        System.out.println("El vehículo se mueve");
    }
}

class Moto extends Vehiculo {
    int cilindrada;
    // Moto hereda velocidad y moverse() de Vehiculo
}

6. Polimorfismo

El polimorfismo permite que objetos de distintas clases respondan de manera diferente al mismo método. Existen dos tipos principales:

• Polimorfismo en tiempo de compilación (sobrecarga): varios métodos con el mismo nombre pero distintos parámetros.
• Polimorfismo en tiempo de ejecución (sobreescritura): una subclase redefine un método heredado.

class Animal {
    void hacerSonido() {
        System.out.println("...");
    }
}

class Gato extends Animal {
    @Override
    void hacerSonido() {
        System.out.println("Miau");
    }
}

class Perro extends Animal {
    @Override
    void hacerSonido() {
        System.out.println("Guau");
    }
}

7. Abstracción

La abstracción consiste en representar solo las características relevantes de un objeto, ocultando los detalles de implementación. Se logra mediante clases abstractas e interfaces.

• Una clase abstracta no puede instanciarse directamente; sirve como base para otras clases.
• Una interfaz define un contrato (qué métodos debe implementar una clase) sin proporcionar la implementación.

abstract class Figura {
    abstract double calcularArea(); // Método abstracto: sin implementación
}

class Circulo extends Figura {
    double radio;

    @Override
    double calcularArea() {
        return Math.PI * radio * radio;
    }
}

8. Conceptos clave para recordar