Métodos Estáticos y Lambdas en Java

En Java, los métodos estáticos pertenecen a la clase en lugar de a una instancia, mientras que las expresiones lambda introducidas en Java 8 permiten simplificar la programación funcional. Este artículo cubre estos conceptos y cómo utilizarlos para escribir un código más eficiente y claro.

1. Métodos Estáticos

Un método estático es aquel que se declara con el modificador static. Estos métodos pueden ser llamados directamente desde la clase sin necesidad de crear un objeto.

Características:

  • No pueden acceder a variables de instancia directamente.
  • Se utilizan para operaciones que no dependen del estado de un objeto.

Sintaxis:

public static tipoDeRetorno nombreMetodo(parámetros) {
    // Código del método
}

Ejemplo básico:

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

public class Principal {
    public static void main(String[] args) {
        int resultado = Matematica.sumar(5, 3);
        System.out.println("Resultado: " + resultado);
    }
}

Salida:

Resultado: 8

2. Cuándo usar métodos estáticos

Funciones auxiliares o utilidades:

public class Utilidades {
    public static String convertirMayusculas(String texto) {
        return texto.toUpperCase();
    }
}

Constantes y configuraciones globales:

public class Configuracion {
    public static final String NOMBRE_APP = "MiAplicacion";
}

Métodos main:

public static void main(String[] args) {
    System.out.println("Inicio del programa");
}

3. Introducción a las Expresiones Lambda

Las lambdas permiten escribir código más compacto al representar métodos en línea. Son ideales para implementar interfaces funcionales (interfaces con un solo método abstracto).

Sintaxis básica de una lambda:

(parámetros) -> { cuerpo }

Ejemplo básico:

public class LambdasBasico {
    public static void main(String[] args) {
        // Implementación de una lambda
        Operacion suma = (a, b) -> a + b;

        System.out.println("Suma: " + suma.calcular(5, 3));
    }
}

@FunctionalInterface
interface Operacion {
    int calcular(int a, int b);
}

Salida:

Suma: 8

4. Métodos comunes con Lambdas

forEach con colecciones: Las lambdas son útiles para recorrer listas o colecciones.

import java.util.Arrays;
import java.util.List;

public class RecorridoConLambdas {
    public static void main(String[] args) {
        List<String> nombres = Arrays.asList("Ana", "Luis", "Carlos");
        nombres.forEach(nombre -> System.out.println(nombre));
    }
}

filter con Streams: Filtra elementos de una colección que cumplen una condición.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FiltrarConStreams {
    public static void main(String[] args) {
        List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> pares = numeros.stream()
                                     .filter(n -> n % 2 == 0)
                                     .collect(Collectors.toList());
        System.out.println("Pares: " + pares);
    }
}

Salida:

Pares: [2, 4]

5. Referencias a Métodos

Java permite simplificar lambdas aún más mediante referencias a métodos.

Tipos de referencias:

Referencia a un método estático:

Clase::metodoEstatico

Referencia a un método de instancia:

objeto::metodoInstancia

Referencia a un constructor:

Clase::new

Ejemplo:

import java.util.Arrays;
import java.util.List;

public class ReferenciaMetodo {
    public static void main(String[] args) {
        List<String> nombres = Arrays.asList("Ana", "Luis", "Carlos");

        // Usando una referencia a método estático
        nombres.forEach(System.out::println);
    }
}

6. Errores comunes al usar métodos estáticos y lambdas

Acceso a variables de instancia desde un método estático:

Los métodos estáticos no pueden acceder directamente a variables de instancia.

public class ErrorStatic {
    int valor = 10;

    public static void metodoEstatico() {
        // System.out.println(valor); // Error
    }
}

Uso incorrecto de lambdas con varias líneas:

Si el cuerpo de la lambda tiene múltiples líneas, deben estar entre llaves.

(a, b) -> {
    int suma = a + b;
    return suma;
};

Resumen

  • Los métodos estáticos son ideales para operaciones que no dependen del estado de un objeto.
  • Las expresiones lambda simplifican el código funcional y son esenciales para trabajar con Streams y colecciones.
  • Las referencias a métodos hacen que las lambdas sean aún más compactas y legibles.