UD2 — Programación Orientada a Objetos con la API de Java

Dato	Valor
Módulo	Programación
Ciclo	Técnico Superior en Desarrollo de Aplicaciones Multiplataforma (DAM)
Centro	IES Thiar, Pilar de la Horadada (Alicante)
Curso	2026-2027
Unidad Didáctica	UD2
Resultado de Aprendizaje	RA2
Evaluación	1.ª Evaluación
Duración	26 horas lectivas
Marco normativo	RD 405/2023 (título y RAs/CEs), RD 450/2010 (competencias del ciclo)
Versión de Java	Java 25 LTS
Herramientas	JDK 25 (Adoptium Temurin), IntelliJ IDEA Community, Apache Maven 3.9.x, JUnit 5

1. Introducción

Bienvenido a la Unidad 2 del módulo de Programación. En la Unidad 1 construiste tu primer programa Java, instalaste IntelliJ IDEA con Maven, dominaste los tipos primitivos, jugaste con String y te atreviste con un primer if como aperitivo. Aceptaste la palabra class en la primera línea de tus programas sin entender del todo qué significaba.

Esa palabra va a cobrar vida en esta unidad.

El cambio que vamos a dar marca un antes y un después en cómo piensas cuando programas. Hasta ahora has trabajado con mentalidad procedimental: piensa un paso, escribe una instrucción, ejecútala. Funciona, pero cuando un programa crece esa aproximación se vuelve un infierno de variables sueltas y funciones dispersas. La Programación Orientada a Objetos (POO) propone organizar el código alrededor de "quién lo hace" en lugar de "qué hay que hacer": los protagonistas dejan de ser los verbos y pasan a ser los sustantivos.

Esta unidad te da un doble regalo. Por un lado, los fundamentos conceptuales de la POO: clase, objeto, instancia, memoria, los cuatro pilares (encapsulación, abstracción, herencia y polimorfismo). Por otro, un recorrido por las clases más usadas del API estándar de Java: String, Math, Random, java.time, StringBuilder, wrappers y Objects. Al terminar serás capaz de escribir programas que usen estas clases con soltura, añadir dependencias externas con Maven y escribir tests automáticos con JUnit 5. Es la base sobre la que se construirá el resto del curso.

2. Resultado de Aprendizaje (RA2)

RA2 — Escribe y prueba programas sencillos, reconociendo y aplicando los fundamentos de la programación orientada a objetos.

Este RA está regulado por el RD 405/2023, que establece los resultados de aprendizaje y sus criterios de evaluación para el ciclo DAM. Las competencias generales del ciclo están definidas en el RD 450/2010, modificado a su vez por el RD 405/2023.

Criterios de Evaluación (CE) del RA2

CE	Enunciado
CE 2.1	Se han identificado los fundamentos de la programación orientada a objetos.
CE 2.2	Se han escrito programas simples.
CE 2.3	Se han instanciado objetos a partir de clases predefinidas.
CE 2.4	Se han utilizado métodos y propiedades de los objetos.
CE 2.5	Se han escrito llamadas a métodos estáticos.
CE 2.6	Se han utilizado parámetros en la llamada a métodos.
CE 2.7	Se han incorporado y utilizado librerías de objetos.
CE 2.8	Se han utilizado constructores.
CE 2.9	Se ha utilizado el entorno integrado de desarrollo en la creación y compilación de programas simples.

La superación del RA2 requiere obtener una calificación media igual o superior a 5 puntos sobre 10 en el conjunto de sus CEs. La evaluación combina pruebas objetivas (85% del peso) con ejercicios prácticos en clase y trabajos para casa (15%), según la Programación Didáctica del módulo.

3. Objetivos pedagógicos

Al finalizar esta unidad, el alumno será capaz de:

Distinguir clase de objeto, comprender el papel de new y la diferencia entre pila y montículo.
Reconocer los cuatro pilares de la POO e identificarlos en clases del API de Java.
Leer y entender la documentación Javadoc oficial y la integrada en IntelliJ.
Diferenciar métodos de instancia y estáticos, y llamarlos correctamente.
Trabajar con la clase String: inmutabilidad, búsqueda, transformación, extracción, comparación y formateo.
Usar la clase Math para cálculos numéricos elementales.
Generar números aleatorios con Random y ThreadLocalRandom, entendiendo el papel de la semilla.
Manejar fechas y horas con java.time (LocalDate, LocalTime, LocalDateTime, Period, Duration, DateTimeFormatter).
Construir textos eficientemente con StringBuilder, StringJoiner y String.join.
Comprender el autoboxing/unboxing y los riesgos asociados a los wrappers.
Validar argumentos con Objects.requireNonNull y comparar objetos de forma segura.
Gestionar dependencias externas con Maven y escribir tests con JUnit 5.

4. Ecosistema tecnológico

JDK:       OpenJDK 25 LTS  (Adoptium Temurin 25)
IDE:       IntelliJ IDEA Community Edition
Build:     Apache Maven 3.9.x
Test:      JUnit 5.x  (JUnit Jupiter)
Paquete:   dam.programacion.ud2

5. Mapa mental de la unidad

El siguiente mapa mental muestra la estructura completa de la UD2 y las relaciones entre sus secciones. Cada nodo corresponde a una sección del índice.

Use mouse to pan and zoom

mindmap
  root((UD2 — POO con<br/>la API de Java))
    S1: Pilares de la POO
      Clase vs. Objeto
      new y memoria
      Operador punto
      Encapsulacion
      Abstraccion
      Herencia
      Polimorfismo
    S2: API de Java
      Paquetes
      Javadoc
      Metodos de instancia
      Metodos estaticos
      IntelliJ autocompletado
    S3: String
      Inmutabilidad
      String pool
      Busqueda
      Transformacion
      Extraccion
      Comparacion
      Formateo
    S4: Math
      Constantes PI y E
      abs max min clamp
      Redondeo
      Potencia y raiz
      Trigonometria
      Math.random
    S5: Random
      Pseudoaleatoriedad
      Semilla
      Reproducibilidad
      ThreadLocalRandom
      SecureRandom
    S6: java.time
      LocalDate
      LocalTime
      LocalDateTime
      ZonedDateTime
      Instant
      Period y Duration
      DateTimeFormatter
    S7: StringBuilder
      Mutabilidad
      append insert delete
      StringJoiner
      String.join
      StringBuffer
    S8: Wrappers y Objects
      Integer Double Boolean Character
      Autoboxing y unboxing
      Constantes y parseo
      Objects.requireNonNull
      Objects.equals y toString
    S9: Maven
      pom.xml
      Coordenadas GAV
      Maven Central
      Ciclo de vida
      Estructura de carpetas
      JUnit 5
    S10: Ejercicios
      Strings
      Math
      Random
      java.time
      StringBuilder
      Tests JUnit
      Mini-proyecto
      Preparacion RA2

6. Índice de contenidos

Cada sección enlaza con su fichero Markdown correspondiente. Junto a cada sección se indican los criterios de evaluación principales que cubre.

Sección 1 — Los cuatro pilares de la POO: visión panorámica

CE cubiertos: CE 2.1 (fundamentos de la POO), CE 2.3 (instanciación — nivel conceptual), CE 2.4 (métodos y propiedades — nivel introductorio), CE 2.5 (métodos estáticos — nivel introductorio), CE 2.8 (constructores — nivel conceptual).

Conceptos: clase vs. objeto, new, heap vs. stack, operador punto, encapsulación, abstracción, herencia, polimorfismo.

Acceder a la Sección 1 →

Sección 2 — Clases y objetos en la API de Java

CE cubiertos: CE 2.2 (programas simples), CE 2.3 (instanciación), CE 2.4 (métodos y propiedades), CE 2.5 (métodos estáticos), CE 2.6 (parámetros), CE 2.7 (librerías de objetos).

Conceptos: paquetes (java.lang, java.util, java.time, java.math), Javadoc, métodos de instancia vs. estáticos, atajos de IntelliJ para explorar el API.

Acceder a la Sección 2 →

Sección 3 — La clase `String` en profundidad

CE cubiertos: CE 2.2, CE 2.3, CE 2.4, CE 2.5, CE 2.6, CE 2.8.

Conceptos: inmutabilidad, string interning, métodos de búsqueda (length, contains, indexOf, charAt), transformación (toUpperCase, strip, replace, repeat), extracción (substring, split), comparación (equals, compareTo), String.format y formatted, text blocks.

Acceder a la Sección 3 →

Sección 4 — La clase `Math`

CE cubiertos: CE 2.2, CE 2.4, CE 2.5, CE 2.6.

Conceptos: constantes PI y E, funciones básicas (abs, max, min, clamp), redondeo (round, ceil, floor, rint), potencia y raíz (pow, sqrt, cbrt, exp, log), trigonometría en radianes, Math.random() como adelanto de la Sección 5.

Acceder a la Sección 4 →

Sección 5 — La clase `Random` y `ThreadLocalRandom`

CE cubiertos: CE 2.2, CE 2.3, CE 2.4, CE 2.5, CE 2.6, CE 2.8.

Conceptos: pseudoaleatoriedad, semilla y reproducibilidad, constructores con y sin semilla, nextInt, nextDouble, nextBoolean, nextGaussian, ThreadLocalRandom.current() como mejor práctica moderna, introducción a SecureRandom.

Acceder a la Sección 5 →

Sección 6 — Fechas y tiempos: `java.time`

CE cubiertos: CE 2.2, CE 2.3, CE 2.4, CE 2.5, CE 2.6, CE 2.7, CE 2.8.

Conceptos: por qué java.time reemplaza a Date y Calendar, LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Instant, Period y Duration, DateTimeFormatter con patrones y Locale.

Acceder a la Sección 6 →

Sección 7 — `StringBuilder` y concatenación eficiente

CE cubiertos: CE 2.2, CE 2.3, CE 2.4, CE 2.6, CE 2.8.

Conceptos: el problema de la concatenación con + en bucles, StringBuilder (constructores, append, insert, delete, replace, reverse, encadenamiento), StringJoiner, String.join, StringBuffer como primo thread-safe.

Acceder a la Sección 7 →

Sección 8 — Wrappers y la clase `Objects`

CE cubiertos: CE 2.2, CE 2.3, CE 2.4, CE 2.5, CE 2.6, CE 2.7.

Conceptos: clases wrapper (Integer, Double, Boolean, Character...), autoboxing y unboxing, constantes (MAX_VALUE, MIN_VALUE), parseXxx, toString y conversiones, Integer Cache, Double.isNaN, Objects.requireNonNull, Objects.equals, Objects.toString seguros.

Acceder a la Sección 8 →

Sección 9 — Maven: gestión de dependencias externas

CE cubiertos: CE 2.2, CE 2.7, CE 2.9.

Conceptos: el pom.xml y las coordenadas GAV, el repositorio Maven Central, dependencias transitivas, <scope>, ciclo de vida (compile, test, package, install), estructura de carpetas, primer contacto con JUnit 5.

Acceder a la Sección 9 →

Sección 10 — Ejercicios y actividades

CE cubiertos: CE 2.1 a CE 2.9 (cierre global del RA2).

Contenido: siete ejercicios resueltos paso a paso (Strings, Math, Random, java.time, StringBuilder, integrador y tests JUnit), tres opciones de mini-proyecto integrador, y preparación completa para la prueba objetiva RA2 (formato, temas, consejos, ejemplos).

Acceder a la Sección 10 →

7. Tabla resumen: secciones y CEs cubiertos

Sección	Título	CEs principales	Horas
1	Los cuatro pilares de la POO: visión panorámica	2.1, 2.3, 2.4, 2.5, 2.8	2,5
2	Clases y objetos en la API de Java	2.2, 2.3, 2.4, 2.5, 2.6, 2.7	2,5
3	La clase `String` en profundidad	2.2, 2.3, 2.4, 2.5, 2.6, 2.8	3
4	La clase `Math`	2.2, 2.4, 2.5, 2.6	2
5	La clase `Random` y `ThreadLocalRandom`	2.2, 2.3, 2.4, 2.5, 2.6, 2.8	2
6	Fechas y tiempos: `java.time`	2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8	3
7	`StringBuilder` y concatenación eficiente	2.2, 2.3, 2.4, 2.6, 2.8	2
8	Wrappers y la clase `Objects`	2.2, 2.3, 2.4, 2.5, 2.6, 2.7	2
9	Maven: gestión de dependencias externas	2.2, 2.7, 2.9	2,5
10	Ejercicios y actividades	2.1 a 2.9 (cierre)	3 + autónomo
		Total	~26 h

8. Coherencia con el roadmap del módulo

Esta unidad se enmarca en el roadmap global del módulo de Programación del ciclo DAM. En concreto:

UD1 — Fundamentos de Java (RA1): prerrequisito. Proporciona el entorno (IntelliJ, Maven), la sintaxis básica, los tipos primitivos y un primer contacto con String y operadores.
UD2 — POO con la API de Java (RA2): unidad actual. Establece los fundamentos de POO y el manejo de las clases predefinidas del API.
UD3 — Control de Flujo y Depuración (RA3): unidad siguiente. Profundiza en if, switch, bucles y excepciones. Algunos de estos elementos (if, for) se han usado puntualmente en UD2 como aperitivo, pero su estudio formal llega en UD3.
UD4 — Clases y Objetos Propios (RA4): aquí aprenderás a crear tus propias clases, usar private/public, constructores, herencia básica con extends, records y enums. La UD2 deja apuntados estos conceptos como "se verán en UD4".
UD6 — Tipos Avanzados de Datos (RA6): colecciones (List, Set, Map) y Streams API. La UD2 menciona las colecciones como motivación para los wrappers y los streams como adelanto de Random.ints y String.chars.

El orden del roadmap está diseñado para que cada unidad aproveche lo aprendido en las anteriores sin anticipar contenido. Si detectas alguna contradicción o solapamiento, avísalo a tu profesor.

9. Cómo usar este material

Este material está pensado para usarse con mkdocs y el tema Material for MkDocs. Cada fichero .md es una sección navegable; los enlaces del índice te llevan a cada una. Los diagramas Mermaid se renderizan automáticamente con el plugin mkdocs-mermaid2-material.

Flujo de estudio recomendado

Lee cada sección en orden. Están diseñadas para construir conocimiento de forma progresiva.
Ejecuta los ejemplos en IntelliJ. No te limites a leer: copia el código, ejecútalo, modifícalo y observa el comportamiento.
Resuelve el cuestionario al final de cada sección antes de avanzar a la siguiente. Si no obtienes al menos 10 aciertos sobre 15, repasa la sección.
Intenta los ejercicios de la Sección 10 sin mirar las soluciones. Es ahí donde se consolida el aprendizaje.
Desarrolla uno de los mini-proyectos de la Sección 10 como actividad integradora.
Repasa el cuestionario de cada sección unos días antes del examen.

Recursos adicionales

Javadoc oficial de Java 25: https://docs.oracle.com/en/java/javase/25/docs/api/
MvnRepository (buscador de librerías): https://mvnrepository.com/
Baeldung (tutoriales prácticos): https://www.baeldung.com/
JUnit 5: https://junit.org/junit5/docs/current/user-guide/
Documentación de Maven: https://maven.apache.org/guides/

10. Próximos pasos

Al superar la UD2 estarás listo para afrontar la UD3 — Control de Flujo y Depuración, donde aprenderás a tomar decisiones (if, switch expression), repetir acciones (for, while, do-while) y gestionar errores (try-catch-finally) de forma profesional. También descubrirás el depurador de IntelliJ, una herramienta esencial para resolver bugs complejos.

Hasta entonces, practica los ejercicios de la Sección 10, repasa los cuestionarios y no dudes en consultar al profesor cualquier duda que te surja. La programación se aprende programando: cuanto más código escribas, más natural te resultará.

Nota sobre el marco normativo. Esta unidad didáctica está alineada con el RD 405/2023, de 4 de julio, por el que se establecen las enseñanzas de Formación Profesional del sistema educativo, y con el RD 450/2010, de 30 de abril, por el que se establece el título de Técnico Superior en Desarrollo de Aplicaciones Multiplataforma. Las decisiones sobre evaluación (peso de pruebas objetivas y trabajos, criterios de superación de cada RA) se ajustan a la Programación Didáctica del módulo para el curso 2026-2027.