Formación corporativa en Java

Java es un lenguaje de programación fuertemente tipado que requiere una estructura sintáctica específica para funcionar correctamente. La comprensión de su sintaxis fundamental es esencial para escribir código que compile y ejecute sin errores.

Estructura básica de un programa Java

Todo programa Java debe seguir una estructura jerárquica bien definida. El código se organiza en clases, y cada clase puede contener métodos, variables y otros elementos.

public class MiPrimeraClase {
    public static void main(String[] args) {
        System.out.println("Hola, mundo");
    }
}

La palabra clave public indica que la clase es accesible desde cualquier parte del programa. El método main es el punto de entrada de la aplicación, donde comienza la ejecución del programa.

Declaración de variables

Java requiere que todas las variables se declaren con un tipo específico antes de su uso. Esta característica proporciona seguridad de tipos y ayuda a prevenir errores comunes.

int edad = 25;
String nombre = "Ana";
double salario = 2500.50;
boolean activo = true;

Las convenciones de nomenclatura en Java siguen el estilo camelCase para variables y métodos, donde la primera palabra comienza en minúscula y las siguientes palabras comienzan con mayúscula.

Operadores y expresiones

Los operadores en Java permiten realizar operaciones matemáticas, lógicas y de comparación. Su uso correcto es fundamental para manipular datos y controlar el flujo del programa.

Operadores aritméticos básicos:

int a = 10;
int b = 3;
int suma = a + b;        // 13
int resta = a - b;       // 7
int multiplicacion = a * b;  // 30
int division = a / b;    // 3 (división entera)
int modulo = a % b;      // 1 (resto de la división)

Operadores de comparación:

boolean mayor = a > b;      // true
boolean menor = a < b;      // false
boolean igual = a == b;     // false
boolean diferente = a != b; // true

Programación Orientada a Objetos en Java

La programación orientada a objetos (POO) representa un paradigma fundamental que revolucionó el desarrollo de software al permitir modelar problemas del mundo real mediante la creación de entidades que encapsulan datos y comportamientos. Java, desde su concepción, fue diseñado como un lenguaje completamente orientado a objetos, donde prácticamente todo elemento del programa es un objeto o forma parte de una clase.

Este paradigma se basa en cuatro pilares fundamentales: encapsulación, herencia, polimorfismo y abstracción. Estos conceptos no son meramente teóricos, sino herramientas prácticas que permiten crear código más organizado, reutilizable y mantenible.

Clases y objetos: los cimientos de la POO

Una clase actúa como un molde o plantilla que define las características y comportamientos que tendrán los objetos creados a partir de ella. Los objetos, por su parte, son instancias específicas de una clase que existen en memoria durante la ejecución del programa.

public class Vehiculo {
    // Atributos (características)
    private String marca;
    private String modelo;
    private int año;
    
    // Constructor
    public Vehiculo(String marca, String modelo, int año) {
        this.marca = marca;
        this.modelo = modelo;
        this.año = año;
    }
    
    // Métodos (comportamientos)
    public void acelerar() {
        System.out.println("El vehículo está acelerando");
    }
    
    public String obtenerInformacion() {
        return marca + " " + modelo + " (" + año + ")";
    }
}

La instanciación de objetos se realiza mediante el operador new, que reserva memoria y ejecuta el constructor correspondiente:

Vehiculo miCoche = new Vehiculo("Toyota", "Corolla", 2023);
Vehiculo motoMoto = new Vehiculo("Honda", "CBR", 2022);

// Uso de los objetos
miCoche.acelerar();
System.out.println(miCoche.obtenerInformacion());

Encapsulación: protegiendo la integridad de los datos

La encapsulación constituye el mecanismo mediante el cual se ocultan los detalles internos de implementación de una clase, exponiendo únicamente una interfaz controlada para interactuar con los objetos. Este principio se implementa principalmente a través de modificadores de acceso y métodos getter/setter.

Los modificadores de acceso en Java determinan la visibilidad de los miembros de una clase:

• private: accesible únicamente dentro de la misma clase
• protected: accesible dentro del mismo paquete y clases hijas
• public: accesible desde cualquier parte del programa
• package-private (sin modificador): accesible dentro del mismo paquete

public class CuentaBancaria {
    private double saldo;  // Encapsulado - no accesible directamente
    private String numeroCuenta;
    
    public CuentaBancaria(String numeroCuenta, double saldoInicial) {
        this.numeroCuenta = numeroCuenta;
        this.saldo = saldoInicial;
    }
    
    // Método público para acceder al saldo (getter)
    public double getSaldo() {
        return saldo;
    }
    
    // Método público para modificar el saldo de forma controlada
    public boolean depositar(double cantidad) {
        if (cantidad > 0) {
            saldo += cantidad;
            return true;
        }
        return false;
    }
    
    public boolean retirar(double cantidad) {
        if (cantidad > 0 && cantidad <= saldo) {
            saldo -= cantidad;
            return true;
        }
        return false;
    }
}

Framework Collections

El Framework Collections de Java representa uno de los pilares fundamentales para el manejo eficiente de datos en aplicaciones modernas. Esta arquitectura unificada proporciona un conjunto de interfaces y clases que permiten almacenar, manipular y procesar grupos de objetos de manera consistente y optimizada.

Arquitectura del Framework

El diseño del framework se basa en una jerarquía de interfaces que define contratos claros para diferentes tipos de colecciones. En la cúspide encontramos la interfaz Collection, que establece las operaciones básicas comunes a todas las colecciones: agregar, eliminar, buscar y iterar elementos.

Collection<String> nombres = new ArrayList<>();
nombres.add("Ana");
nombres.add("Carlos");
nombres.remove("Ana");
System.out.println(nombres.size()); // 1

Esta arquitectura permite que el código sea polimórfico, trabajando con abstracciones en lugar de implementaciones concretas. Un método puede recibir cualquier tipo de colección y operar sobre ella utilizando la interfaz común.

Tipos Principales de Colecciones

Listas Ordenadas

Las listas mantienen el orden de inserción y permiten elementos duplicados. La interfaz List extiende Collection añadiendo operaciones basadas en índices, lo que permite acceso posicional a los elementos.

List<Integer> numeros = new ArrayList<>();
numeros.add(10);
numeros.add(20);
numeros.add(10); // Duplicado permitido
Integer primero = numeros.get(0); // Acceso por índice

Conjuntos Únicos

Los conjuntos garantizan la unicidad de elementos, eliminando automáticamente duplicados. La interfaz Set define esta característica fundamental, siendo especialmente útil para operaciones matemáticas como unión e intersección.

Set<String> ciudades = new HashSet<>();
ciudades.add("Madrid");
ciudades.add("Barcelona");
ciudades.add("Madrid"); // No se añade, ya existe
System.out.println(ciudades.size()); // 2

Mapas Clave-Valor

Los mapas establecen asociaciones entre claves únicas y valores, implementando la interfaz Map. Aunque no extienden Collection, forman parte integral del framework proporcionando estructuras de datos tipo diccionario.

Map<String, Integer> edades = new HashMap<>();
edades.put("Juan", 25);
edades.put("María", 30);
Integer edadJuan = edades.get("Juan"); // 25

Programación Funcional en Java

La programación funcional representa un paradigma de programación que trata la computación como la evaluación de funciones matemáticas, evitando el cambio de estado y los datos mutables. Java, tradicionalmente orientado a objetos, incorporó características funcionales a partir de Java 8, permitiendo a los desarrolladores combinar ambos paradigmas de manera efectiva.

Fundamentos del paradigma funcional

En la programación funcional, las funciones son ciudadanos de primera clase, lo que significa que pueden ser asignadas a variables, pasadas como argumentos y devueltas como valores de retorno. Este enfoque contrasta con la programación imperativa, donde nos centramos en cómo hacer algo, mientras que la programación funcional se enfoca en qué queremos obtener.

Los principios fundamentales incluyen la inmutabilidad, donde los objetos no cambian después de su creación, y la ausencia de efectos secundarios, donde las funciones no modifican el estado externo. Estos conceptos reducen la complejidad del código y facilitan el razonamiento sobre el comportamiento del programa.

// Enfoque imperativo tradicional
List<String> nombres = Arrays.asList("Ana", "Carlos", "Beatriz");
List<String> resultado = new ArrayList<>();
for (String nombre : nombres) {
    if (nombre.length() > 3) {
        resultado.add(nombre.toUpperCase());
    }
}

// Enfoque funcional
List<String> resultado = nombres.stream()
    .filter(nombre -> nombre.length() > 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

Interfaces funcionales

Las interfaces funcionales constituyen la base de la programación funcional en Java. Una interfaz funcional contiene exactamente un método abstracto y puede ser implementada mediante expresiones lambda o referencias a métodos. Java proporciona varias interfaces funcionales predefinidas en el paquete java.útil.function.

La interfaz Function<T, R> representa una función que acepta un argumento de tipo T y produce un resultado de tipo R:

Function<String, Integer> longitud = texto -> texto.length();
Function<Integer, Integer> cuadrado = numero -> numero * numero;

// Uso de las funciones
int resultado1 = longitud.apply("Hola mundo"); // 10
int resultado2 = cuadrado.apply(5); // 25

La interfaz Predicate<T> define una función que evalúa una condición y devuelve un valor booleano:

Predicate<Integer> esPar = numero -> numero % 2 == 0;
Predicate<String> esVacio = String::isEmpty;

// Evaluación de predicados
boolean resultado1 = esPar.test(4); // true
boolean resultado2 = esVacio.test(""); // true

Entrada y salida IO en Java

La entrada y salida (Input/Output o IO) constituye uno de los pilares fundamentales en cualquier aplicación Java. Permite que nuestros programas interactúen con el mundo exterior, ya sea leyendo datos del usuario, procesando archivos o comunicándose con otros sistemas.

Java proporciona un ecosistema robusto de clases y métodos para manejar operaciones de IO de manera eficiente y segura. Estas herramientas nos permiten crear aplicaciones interactivas que pueden procesar información de múltiples fuentes y generar resultados útiles.

Fundamentos de IO en Java

El paquete java.io contiene las clases principales para realizar operaciones de entrada y salida. Este paquete incluye desde las clases más básicas para leer texto hasta herramientas avanzadas para manipular archivos binarios.

Las operaciones de IO en Java se basan en el concepto de streams (flujos de datos). Un stream es una secuencia de datos que puede leerse o escribirse de forma secuencial. Existen dos tipos principales:

• Streams de entrada: Para leer datos desde una fuente
• Streams de salida: Para escribir datos hacia un destino

Entrada de datos desde consola

La forma más común de obtener entrada del usuario es a través de la consola. Java ofrece varias aproximaciones para esta tarea, siendo Scanner la más utilizada por su simplicidad y versatilidad.

import java.util.Scanner;

Scanner scanner = new Scanner(System.in);
System.out.print("Introduce tu nombre: ");
String nombre = scanner.nextLine();
System.out.println("Hola, " + nombre);

La clase Scanner puede leer diferentes tipos de datos utilizando métodos específicos como nextInt(), nextDouble(), nextBoolean(), cada uno diseñado para procesar el tipo de dato correspondiente.

API java.time

La gestión del tiempo en aplicaciones Java ha experimentado una transformación significativa con la introducción de la API java.time en Java 8. Esta API moderna reemplaza las problemáticas clases Date y Calendar, ofreciendo un enfoque más intuitivo, seguro y funcional para trabajar con fechas, horas y períodos temporales.

Fundamentos de la nueva API temporal

La API java.time se basa en principios de inmutabilidad y claridad semántica. Todas las clases principales son inmutables, lo que significa que cualquier operación que modifique un objeto temporal devuelve una nueva instancia en lugar de alterar la original.

LocalDate fecha = LocalDate.of(2024, 3, 15);
LocalDate nuevaFecha = fecha.plusDays(10); // fecha original no cambia
System.out.println(fecha);      // 2024-03-15
System.out.println(nuevaFecha); // 2024-03-25

Esta característica elimina muchos errores comunes relacionados con la mutabilidad accidental y hace que el código sea más predecible y seguro en entornos concurrentes.

Clases principales para representación temporal

La API se organiza en torno a varias clases especializadas, cada una diseñada para casos de uso específicos:

LocalDate representa fechas sin información de hora ni zona horaria:

LocalDate hoy = LocalDate.now();
LocalDate cumpleanos = LocalDate.of(1990, Month.DECEMBER, 25);
LocalDate proximoLunes = LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.MONDAY));

LocalTime maneja únicamente información horaria:

LocalTime ahora = LocalTime.now();
LocalTime reunion = LocalTime.of(14, 30, 0);
LocalTime mediaHoraAntes = reunion.minusMinutes(30);

LocalDateTime combina fecha y hora sin considerar zonas horarias:

LocalDateTime momento = LocalDateTime.now();
LocalDateTime evento = LocalDateTime.of(2024, 6, 15, 19, 30);
LocalDateTime inicioSemana = momento.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY))
                                   .withHour(0).withMinute(0).withSecond(0);

Concurrencia en Java

La concurrencia representa uno de los paradigmas más importantes en el desarrollo de aplicaciones modernas. En Java, este concepto permite que múltiples hilos de ejecución (threads) trabajen simultáneamente, aprovechando al máximo los recursos del sistema y mejorando significativamente el rendimiento de las aplicaciones.

Fundamentos de la programación concurrente

La programación concurrente surge de la necesidad de ejecutar múltiples tareas de forma simultánea. Mientras que un programa secuencial ejecuta una instrucción tras otra, un programa concurrente puede realizar varias operaciones al mismo tiempo, como procesar datos mientras descarga archivos de internet o actualizar la interfaz gráfica mientras realiza cálculos complejos.

Java incorpora soporte nativo para concurrencia desde sus primeras versiones. El lenguaje proporciona herramientas integradas que permiten crear, gestionar y sincronizar hilos de ejecución de manera eficiente y segura.

Hilos en Java

Un hilo (thread) es la unidad básica de ejecución concurrente en Java. Cada hilo representa un flujo independiente de instrucciones que puede ejecutarse en paralelo con otros hilos dentro del mismo proceso.

La clase Thread constituye el elemento fundamental para trabajar con concurrencia:

public class MiHilo extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Hilo: " + Thread.currentThread().getName() + " - Iteración: " + i);
            try {
                Thread.sleep(1000); // Pausa de 1 segundo
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

Alternativamente, Java ofrece la interfaz Runnable, que proporciona mayor flexibilidad al separar la lógica de ejecución de la gestión del hilo:

public class TareaRunnable implements Runnable {
    private String nombre;
    
    public TareaRunnable(String nombre) {
        this.nombre = nombre;
    }
    
    @Override
    public void run() {
        System.out.println("Ejecutando tarea: " + nombre);
        // Lógica de la tarea
    }
}

// Uso
Thread hilo = new Thread(new TareaRunnable("Procesamiento de datos"));
hilo.start();

Frameworks para Java

Los frameworks representan una de las herramientas más fundamentales en el desarrollo profesional con Java. Un framework es una estructura de software reutilizable que proporciona funcionalidades genéricas que pueden ser modificadas selectivamente mediante código adicional específico del usuario.

En el ecosistema Java, los frameworks han evolucionado para resolver problemas comunes del desarrollo empresarial: gestión de dependencias, configuración de aplicaciones, acceso a datos, seguridad y arquitectura de aplicaciones web. Esta evolución ha permitido que los desarrolladores se concentren en la lógica de negocio específica de sus aplicaciones, delegando las tareas repetitivas y complejas al framework.

Arquitectura y patrones fundamentales

Los frameworks Java modernos se construyen sobre varios patrones de diseño establecidos que facilitan el desarrollo y mantenimiento del código. El patrón de Inversión de Control (IoC) constituye la base conceptual de la mayoría de frameworks actuales.

La Inversión de Control invierte el flujo tradicional de control en una aplicación. En lugar de que los objetos gestionen directamente sus dependencias, el framework se encarga de crearlas e inyectarlas cuando son necesarias. Este enfoque reduce significativamente el acoplamiento entre componentes.

// Sin IoC - gestión manual de dependencias
public class ServicioUsuario {
    private RepositorioUsuario repositorio;
    
    public ServicioUsuario() {
        this.repositorio = new RepositorioUsuarioImpl();
    }
}

// Con IoC - dependencias inyectadas por el framework
public class ServicioUsuario {
    private RepositorioUsuario repositorio;
    
    public ServicioUsuario(RepositorioUsuario repositorio) {
        this.repositorio = repositorio;
    }
}

La Inyección de Dependencias es la implementación práctica de IoC. Los frameworks utilizan diferentes mecanismos para inyectar dependencias: constructor, setter o directamente en campos mediante anotaciones.

Configuración y gestión de componentes

Los frameworks Java han evolucionado desde configuraciones XML extensas hacia enfoques basados en anotaciones y configuración por código. Esta transición ha simplificado significativamente la configuración y ha mejorado la legibilidad del código.

Las anotaciones permiten declarar metadatos directamente en el código fuente, eliminando la necesidad de archivos de configuración externos para muchos casos de uso:

@Component
public class ServicioNotificacion {
    
    @Autowired
    private ServicioEmail servicioEmail;
    
    @Value("${app.notificaciones.habilitadas}")
    private boolean notificacionesHabilitadas;
    
    public void enviarNotificacion(String mensaje) {
        if (notificacionesHabilitadas) {
            servicioEmail.enviar(mensaje);
        }
    }
}

La configuración por código ofrece ventajas adicionales como verificación en tiempo de compilación y mejor soporte de IDEs. Los frameworks modernos permiten definir beans y configuraciones mediante clases Java anotadas:

@Configuration
public class ConfiguracionAplicacion {
    
    @Bean
    public ServicioEmail servicioEmail() {
        return new ServicioEmailImpl();
    }
    
    @Bean
    @Profile("desarrollo")
    public ServicioEmail servicioEmailDesarrollo() {
        return new ServicioEmailMock();
    }
}

Testing en Java

El testing o pruebas de software representa una disciplina fundamental en el desarrollo profesional que garantiza la calidad, fiabilidad y mantenibilidad del código. En Java, el ecosistema de testing ha evolucionado hasta convertirse en un conjunto robusto de herramientas y metodologías que permiten validar el comportamiento de las aplicaciones de manera sistemática.

Fundamentos del testing

Las pruebas automatizadas constituyen el pilar sobre el cual se construye software confiable. A diferencia de las pruebas manuales, que requieren intervención humana constante, las pruebas automatizadas se ejecutan de forma independiente y repetible, proporcionando retroalimentación inmediata sobre el estado del código.

En Java, el testing se estructura tradicionalmente en tres niveles principales. Las pruebas unitarias verifican el comportamiento de componentes individuales, como métodos o clases, de forma aislada. Las pruebas de integración validan la interacción entre diferentes módulos del sistema. Finalmente, las pruebas de sistema evalúan el funcionamiento completo de la aplicación desde la perspectiva del usuario final.

JUnit como framework principal

JUnit se ha establecido como el framework de testing más utilizado en el ecosistema Java. Su diseño basado en anotaciones simplifica la creación y organización de pruebas, mientras que su integración nativa con IDEs y herramientas de construcción facilita su adopción en proyectos de cualquier escala.

La estructura básica de una prueba JUnit utiliza anotaciones para identificar métodos de prueba y configurar su ciclo de vida:

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.junit.jupiter.api.Assertions.*;

class CalculadoraTest {
    
    private Calculadora calculadora;
    
    @BeforeEach
    void setUp() {
        calculadora = new Calculadora();
    }
    
    @Test
    void testSuma() {
        int resultado = calculadora.sumar(5, 3);
        assertEquals(8, resultado);
    }
}