El paradigma orientado a objetos se alinea con el pensamiento humano, simplificando el desarrollo de software.

1. Objetos

Un objeto es una estructura de datos especializada que alamcena estados y comportamientos. Visualmente, puede representarse como una tabla de datos:

Usuario u = new Usuario();

• Usuario u crea una referencia en la pila
• new Usuario() genera un objeto en el heap con dirección única
• u.nombre = "Ana" modifica el atributo mediante la referencia

2. Clases

Las clases son plantillas que definen la estructura de los objetos, especificando atributos y métodos permitidos.

3. Palabra Clave 'this'

Referencia al objeto actual que ejecuta el método:

public void establecerEdad(int edad) {
    this.edad = edad;
}

4. Constructores

Métodos especiales para inicializar objetos:

class Empleado {
    public Empleado(String nombre) {
        this.nombre = nombre;
    }
}

• Java genera constructor predeterminado si no se define
• Al definir constructor parametrizado, añadir manualmente el vacío

5. Encapsulación

Principio de ocultar datos y exponer comportamientos controlados:

class Cuenta {
    private double saldo;
    
    public void depositar(double monto) {
        if(monto > 0) saldo += monto;
    }
}

6. JavaBeans

Clases que encapsulan datos mediante getters/setters:

class Producto {
    private String id;
    
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
}

7. Variables: Miembro vs Local

Variable Miembro	Variable Local
Declarada en clase	Declarada en métodos
Inicializada por defecto	Requiere inicialización

8. Modificador 'static'

Crea miembros compartidos por todas las instancias:

class Contador {
    static int total;
}

Clases Uitlitarias

class Matematicas {
    private Matematicas() {}
    
    public static int sumar(int a, int b) {
        return a + b;
    }
}

Patrón Singleton

class Configuracion {
    private static Configuracion instancia;
    
    private Configuracion() {}
    
    public static Configuracion obtener() {
        if(instancia == null) {
            instancia = new Configuracion();
        }
        return instancia;
    }
}

9. Bloques de Código

class Ejemplo {
    static { // Bloque estático
        System.out.println("Inicialización clase");
    }
    
    { // Bloque de instancia
        System.out.println("Inicialización objeto");
    }
}

10. Herencia

Mecanismo para reutilizar y extender funcionalidad:

class Vehiculo {}
class Coche extends Vehiculo {}

Sobrescritura de Métodos

class Animal {
    void emitirSonido() {
        System.out.println("Sonido genérico");
    }
}

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

Palabra Clave 'super'

class Subclase extends Superclase {
    Subclase() {
        super("parametro");
    }
}

11. Polimorfismo

Capacidad de objetos para comportarse de múltiples formas:

interface Forma {
    void dibujar();
}

class Circulo implements Forma {
    public void dibujar() {
        System.out.println("Dibujando círculo");
    }
}

12. Modificador 'final'

• Clases: No heredables
• Métodos: No sobrescribibles
• Variables: Valor inmutable

13. Clases Abstractas

abstract class Instrumento {
    abstract void tocar();
}

Patrón Método Plantilla

abstract class Proceso {
    final void ejecutar() {
        iniciar();
        procesar();
        finalizar();
    }
    
    abstract void procesar();
}

14. Interfaces

Contratos que definen comportamientos:

interface Conducible {
    void acelerar();
    default void frenar() {
        System.out.println("Frenando");
    }
}

15. Clases Internas

class Externa {
    class Interna {
        void mostrar() {
            System.out.println("Clase interna");
        }
    }
}

Clases Anónimas

Runnable tarea = new Runnable() {
    public void run() {
        System.out.println("Ejecutando");
    }
};

16. Enumeraciones

enum Estado {
    ACTIVO, INACTIVO, PENDIENTE
}

17. Genéricos

Permiten crear componantes reutilizables con tipos parametrizados:

class Contenedor<T> {
    private T contenido;
    
    public void guardar(T item) {
        contenido = item;
    }
}

Límites de Genéricos

<T extends Number> void procesar(T numero) {
    System.out.println(numero.doubleValue());
}