Java Programación Orientada a Objetos

La programación orientada a objetos (OOP) es un paradigma fundamental en el desarrollo de software moderno que permite crear aplicaciones robustas, mantenibles y escalables. Java, como lenguaje de programación orientado a objetos por excelencia, implementa este paradigma de manera completa y consistente, convirtiéndolo en una herramienta esencial para desarrolladores profesionales.

Fundamentos de la programación orientada a objetos en Java

Java se diseñó desde sus inicios como un lenguaje puramente orientado a objetos, lo que significa que prácticamente todo en Java es un objeto (con algunas excepciones como los tipos primitivos). Este enfoque permite modelar sistemas complejos de manera intuitiva, representando entidades del mundo real como objetos con características (atributos) y comportamientos (métodos).

La OOP en Java se sustenta en cuatro pilares fundamentales:

• Encapsulación: Permite ocultar los detalles internos de implementación y exponer solo lo necesario.
• Herencia: Facilita la reutilización de código y la creación de jerarquías de clases.
• Polimorfismo: Proporciona flexibilidad al permitir que objetos de diferentes clases respondan de manera distinta al mismo mensaje.
• Abstracción: Permite centrarse en lo que hace un objeto en lugar de cómo lo hace.

Clases y objetos: la base de Java

En Java, todo comienza con las clases, que son plantillas o moldes que definen la estructura y comportamiento de los objetos. Una clase encapsula datos (atributos) y comportamientos (métodos) relacionados en una única unidad.

public class Automovil {
    // Atributos
    private String marca;
    private String modelo;
    private int año;
    
    // Constructor
    public Automovil(String marca, String modelo, int año) {
        this.marca = marca;
        this.modelo = modelo;
        this.año = año;
    }
    
    // Métodos
    public void arrancar() {
        System.out.println("El automóvil está arrancando");
    }
    
    public void detener() {
        System.out.println("El automóvil se ha detenido");
    }
}

A partir de una clase, podemos crear instancias u objetos concretos:

Automovil miCoche = new Automovil("Toyota", "Corolla", 2023);
miCoche.arrancar();

Encapsulación y control de acceso

La encapsulación es uno de los conceptos más importantes en Java, permitiendo ocultar los detalles internos de implementación y proteger la integridad de los datos. Mediante los modificadores de acceso (private, protected, public), podemos controlar qué partes de nuestro código son accesibles desde otras clases.

public class CuentaBancaria {
    // Atributos encapsulados (privados)
    private String numeroCuenta;
    private double saldo;
    
    // Métodos públicos para acceder a los atributos (getters)
    public String getNumeroCuenta() {
        return numeroCuenta;
    }
    
    public double getSaldo() {
        return saldo;
    }
    
    // Métodos públicos para modificar los atributos (setters)
    public void depositar(double cantidad) {
        if (cantidad > 0) {
            saldo += cantidad;
        }
    }
    
    public boolean retirar(double cantidad) {
        if (cantidad > 0 && saldo >= cantidad) {
            saldo -= cantidad;
            return true;
        }
        return false;
    }
}

Herencia y extensibilidad

La herencia permite crear nuevas clases basadas en clases existentes, heredando sus atributos y métodos. Esto facilita la reutilización de código y la creación de jerarquías de clases que representan relaciones "es un" entre objetos.

// Clase base o superclase
public class Empleado {
    protected String nombre;
    protected double salarioBase;
    
    public Empleado(String nombre, double salarioBase) {
        this.nombre = nombre;
        this.salarioBase = salarioBase;
    }
    
    public double calcularSalario() {
        return salarioBase;
    }
}

// Clase derivada o subclase
public class Gerente extends Empleado {
    private double bono;
    
    public Gerente(String nombre, double salarioBase, double bono) {
        super(nombre, salarioBase); // Llamada al constructor de la superclase
        this.bono = bono;
    }
    
    @Override
    public double calcularSalario() {
        return super.calcularSalario() + bono;
    }
}

Abstracción mediante clases abstractas e interfaces

Java proporciona dos mecanismos principales para implementar la abstracción: clases abstractas e interfaces.

Las clases abstractas permiten definir una base común para un grupo de subclases, pudiendo contener métodos concretos y abstractos:

public abstract class Figura {
    // Método abstracto (sin implementación)
    public abstract double calcularArea();
    
    // Método concreto (con implementación)
    public void mostrarInformacion() {
        System.out.println("Área: " + calcularArea());
    }
}

public class Circulo extends Figura {
    private double radio;
    
    public Circulo(double radio) {
        this.radio = radio;
    }
    
    @Override
    public double calcularArea() {
        return Math.PI * radio * radio;
    }
}

Las interfaces definen contratos que las clases deben cumplir, especificando qué métodos deben implementar sin definir cómo:

public interface Dibujable {
    void dibujar();
    void cambiarColor(String color);
}

public class Rectangulo implements Dibujable {
    private double ancho;
    private double alto;
    
    @Override
    public void dibujar() {
        System.out.println("Dibujando un rectángulo");
    }
    
    @Override
    public void cambiarColor(String color) {
        System.out.println("Cambiando color a: " + color);
    }
}