Lecciones

Guía práctica para construir jerarquías de clases en Java: de la abstracción al detalle. Con ejemplos de figuras, un mini‑editor, pagos y transporte mostramos cómo extraer lo común a una clase base abstract, sobrescribir métodos como area()/ draw(), ampliar el sistema sin reescribir código y evitar la duplicación. Terminaremos con un repaso de errores típicos y consejos de diseño.

Practiquemos la aplicación de abstracciones en escenarios reales: pagos, transporte, editor gráfico. Mostraremos cómo extraer el comportamiento común a una clase base abstract, trabajar mediante un contrato común y sustituir el código « if- else» por polimorfismo. Por el camino veremos cómo invocar de forma uniforme métodos como process(), move(), draw()/ resize() para que el código sea flexible y extensible.

Cómo descomponer aplicaciones complejas en niveles de abstracción (UI, lógica de negocio, acceso a datos) para que el código siga siendo claro y extensible. En la práctica construimos un mini gestor de tareas con las capas Task, TaskRepository, TaskService, mostramos sustituciones de implementaciones y ventajas para el equipo. Veremos las mejores prácticas, errores típicos y un ejemplo con los servicios OrderService/ OrderRepository, así como métodos como saveOrder() y findUserById().

En esta lección aprenderás qué es una interfaz en Java, cómo declararla con la palabra clave interface, cómo las clases implementan el contrato mediante implements, y por qué los métodos se consideran por defecto public abstract. Veremos las diferencias entre interfaz y clase, ejemplos de la JDK ( Comparable, Runnable, Serializable), un esquema visual y errores típicos.

En esta lección compararemos las interfaces y las clases abstractas en Java: cuándo elegir cada una, en qué se diferencian por capacidades y limitaciones, cómo son sus signaturas ( abstract class e interface), qué significan modificadores como public, abstract, static, y también veremos ejemplos del JDK, casos prácticos y errores típicos (herencia, implementación, uso de implements/ extends).

En esta lección analizamos cómo una clase en Java puede implementar varios interfaces a la vez: la sintaxis con la palabra clave implements, la combinación de roles (por ejemplo, Movable, Attackable, Serializable), firmas de métodos coincidentes, la ausencia del «problema del diamante» y qué hacer ante conflictos de métodos default. Se incluyen ejemplos prácticos y un análisis de errores típicos.

En la lección explicamos qué es una interfaz funcional (exactamente un método abstracto), cómo y para qué marcarla con la anotación @FunctionalInterface, con qué se puede complementar la interfaz mediante métodos default y static, y cómo aplicar esas interfaces en la práctica (clases normales y clases anónimas). Los ejemplos con Runnable, Comparator<T> e interfaces de java.util.function se completan con una tabla y un análisis de errores típicos.

Cómo las interfaces convierten el código en una arquitectura flexible: programamos contra abstracciones, inyectamos dependencias mediante DI, sustituimos implementaciones en las pruebas, añadimos nuevos comportamientos sin cambiar el núcleo ( OCP). Vemos cómo las interfaces están en la base de los patrones Observer, Strategy, Command, y mostramos la práctica con ejemplos ( UserRepository, NotificationSender, estrategias de pago).

En esta lección analizaremos las expresiones lambda en Java: qué son y para qué sirven, cómo es su sintaxis y sus atajos, cómo se relacionan las lambdas con las interfaces funcionales ( @FunctionalInterface), en qué se diferencian de las clases anónimas y cómo funciona la captura de variables ( final / effectively final). Con ejemplos prácticos con Runnable, Consumer, Comparator, Function y la Stream API veremos cómo escribir de forma más breve y clara. Terminaremos con la sección «Errores típicos» y consejos sobre cómo evitarlos.

Guía rápida sobre referencias a métodos en Java: dónde y cómo usar method reference en lugar de lambdas. Veremos 4 formas: Clase::método (estático y «en instancia»), objeto::método, Clase::new. Entenderemos la correspondencia de firmas con interfaces funcionales, la compararemos con expresiones lambda, veremos ejemplos prácticos con forEach, sort, map y comentaremos errores típicos (incompatibilidad de firmas, sobrecarga de métodos, etc.).

En la lección analizamos por qué en Java 8 aparecieron los métodos default en las interfaces, cómo permiten evolucionar los API sin romper el código antiguo, su sintaxis (la palabra clave default antes del tipo de retorno) y su comportamiento en las implementaciones. Veremos su uso con ejemplos de la biblioteca estándar ( List: forEach, replaceAll, sort). También hablaremos de las limitaciones: no se pueden sobrescribir los métodos de Object ( equals/ hashCode/ toString), así como de las reglas de resolución de conflictos en implementaciones múltiples y de los errores típicos.

Analizamos cómo y por qué las interfaces en Java obtuvieron static-métodos: sintaxis de declaración, diferencia con los default-métodos, restricciones clave (no se heredan, no se sobrescriben, llamada solo mediante el nombre de la interfaz, acceso únicamente a miembros static, compatibilidad con private static desde Java 9+). En la práctica veremos Movable.resetPosition(), un Logger auxiliar, las fábricas de colecciones List.of()/ Set.of()/ Map.of() y utilidades Comparator.reverseOrder(). Al final — errores típicos y cómo evitarlos.