0Pricing
Java Academy · Lección

Clases de utilidades y métodos de fábrica estáticos

Diseñe clases de utilidades no instanciables y exponga métodos de fábrica estáticos como alternativa a los constructores.

Clases de utilidades y métodos de fábrica estáticos es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Clases de utilidad y métodos de fábrica estáticos

Las clases de utilidad proporcionan métodos auxiliares estáticos sin estado de instancia. Los métodos de fábrica estáticos son alternativas con nombre a los constructores que ofrecen mayor legibilidad, almacenamiento en caché y flexibilidad.

Clases de utilidad

Una clase de utilidad no tiene estado de instancia: es un contenedor de métodos estáticos. Hágala no instanciable declarando un constructor privado.

final class StringUtils {
    // Private constructor prevents instantiation
    private StringUtils() {
        throw new UnsupportedOperationException("Utility class");
    }

    public static boolean isBlank(String s) {
        return s == null || s.strip().isEmpty();
    }

    public static String capitalize(String s) {
        if (isBlank(s)) return s;
        return Character.toUpperCase(s.charAt(0)) + s.substring(1).toLowerCase();
    }
}

System.out.println(StringUtils.isBlank("  ")); // true
System.out.println(StringUtils.capitalize("hELLO")); // Hello

Clases de utilidad de la biblioteca estándar

La biblioteca estándar de Java está repleta de clases de utilidad: Collections, Arrays, Objects, Files, Paths y Math.

import java.util.*;

List<Integer> nums = new ArrayList<>(Arrays.asList(5, 2, 8, 1, 9, 3));

Collections.sort(nums);
System.out.println(nums); // [1, 2, 3, 5, 8, 9]

System.out.println(Collections.min(nums)); // 1
System.out.println(Collections.max(nums)); // 9

Collections.shuffle(nums); // random order

int[] arr = {3, 1, 4, 1, 5};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 1, 3, 4, 5]
System.out.println(Arrays.binarySearch(arr, 4)); // 3 (index)

Métodos de fábrica estáticos

Un método de fábrica estático es un método estático con nombre que crea y devuelve una instancia. Entre sus ventajas se encuentran los nombres descriptivos, la posibilidad de devolver instancias almacenadas en caché o de subtipos y la posibilidad de devolver null.

class Connection {
    private final String host;
    private final int port;
    private final boolean ssl;

    private Connection(String host, int port, boolean ssl) {
        this.host = host; this.port = port; this.ssl = ssl;
    }

    // Named factory methods — more expressive than constructors
    public static Connection plain(String host) {
        return new Connection(host, 80, false);
    }
    public static Connection secure(String host) {
        return new Connection(host, 443, true);
    }
}
Connection c = Connection.secure("api.example.com");
// Much clearer than: new Connection("api.example.com", 443, true)

Almacenamiento en caché con una fábrica estática

Las fábricas estáticas pueden devolver instancias almacenadas en caché, evitando asignaciones repetidas para valores habituales (como hace Integer.valueOf con -128..127).

class Color {
    private static final Map<String, Color> CACHE = new HashMap<>();

    public final int r, g, b;

    private Color(int r, int g, int b) {
        this.r = r; this.g = g; this.b = b;
    }

    public static Color of(int r, int g, int b) {
        String key = r + "," + g + "," + b;
        return CACHE.computeIfAbsent(key, k -> new Color(r, g, b));
    }

    public static final Color RED   = of(255, 0, 0);
    public static final Color GREEN = of(0, 255, 0);
    public static final Color BLUE  = of(0, 0, 255);
}
System.out.println(Color.of(255,0,0) == Color.RED); // true (cached)

Fábrica frente a constructor: nombres

Convenciones habituales para nombrar métodos de fábrica estáticos:

  • of: fábrica de agregación
  • from: fábrica de conversión
  • valueOf: fábrica de conversión (API antiguas)
  • getInstance: singleton
  • create/newInstance: objeto nuevo
  • get: flexible
// Java API examples:
Optional.of(value)               // of
LocalDate.from(temporal)         // from
Integer.valueOf(42)              // valueOf
Calendar.getInstance()           // getInstance
Array.newInstance(type, length)  // newInstance

// Your own:
HttpRequest.post("https://api.example.com/users")
ApiResponse.error(404, "Not found")
Payment.creditCard("4242...", 9999, "USD")

Devolver subtipos

Un método de fábrica puede devolver un subtipo mientras que el tipo de retorno declarado es la interfaz. El código que realiza la llamada queda desacoplado de la implementación concreta.

interface Validator<T> {
    boolean validate(T value);
    String errorMessage();
}

class EmailValidator implements Validator<String> {
    public boolean validate(String email) { return email.contains("@"); }
    public String errorMessage() { return "Invalid email address"; }
}

class Validators {
    // Returns interface type — hides implementation
    public static Validator<String> email() { return new EmailValidator(); }
    public static Validator<String> notBlank() {
        return new Validator<>() {
            public boolean validate(String s) { return s != null && !s.isBlank(); }
            public String errorMessage() { return "Value required"; }
        };
    }
}

Builder mediante una fábrica estática

Combine un constructor privado con una fábrica estática y un Builder anidado para construir objetos complejos.

class EmailMessage {
    private final String to, subject, body;
    private final boolean html;

    private EmailMessage(Builder b) {
        this.to = b.to; this.subject = b.subject;
        this.body = b.body; this.html = b.html;
    }

    public static Builder builder(String to) { return new Builder(to); }

    public static class Builder {
        private final String to;
        private String subject = "", body = "";
        private boolean html = false;

        Builder(String to) { this.to = to; }
        public Builder subject(String s) { this.subject = s; return this; }
        public Builder body(String b) { this.body = b; return this; }
        public Builder html() { this.html = true; return this; }
        public EmailMessage build() { return new EmailMessage(this); }
    }
}
EmailMessage.builder("alice@co.com").subject("Welcome!").html().build();

Validación en métodos de fábrica

Los métodos de fábrica son ideales para validar la entrada antes de la construcción: lance excepciones significativas con contexto.

class PortNumber {
    private final int value;

    private PortNumber(int value) { this.value = value; }

    public static PortNumber of(int port) {
        if (port < 1 || port > 65535)
            throw new IllegalArgumentException(
                "Port must be 1-65535, got: " + port);
        return new PortNumber(port);
    }

    public static PortNumber http()  { return new PortNumber(80); }
    public static PortNumber https() { return new PortNumber(443); }

    public int value() { return value; }
    public boolean isPrivileged() { return value < 1024; }
}
System.out.println(PortNumber.https().isPrivileged()); // true

API de Collections: fábricas estáticas

Java 9+ añadió List.of(), Set.of() y Map.of(): métodos de fábrica estáticos que crean colecciones inmutables.

import java.util.*;

List<String> fruits = List.of("Apple", "Banana", "Cherry");
Set<Integer> ids    = Set.of(1, 2, 3, 4, 5);
Map<String, Integer> ages = Map.of("Alice", 30, "Bob", 25);

// All are unmodifiable:
try {
    fruits.add("Durian"); // UnsupportedOperationException
} catch (UnsupportedOperationException e) {
    System.out.println("Cannot modify!");
}

// Map.entry and Map.ofEntries for > 10 entries
Map<String, String> config = Map.ofEntries(
    Map.entry("host", "localhost"),
    Map.entry("port", "8080")
);

Cuándo preferir los métodos de fábrica

Prefiera los métodos de fábrica estáticos a los constructores cuando:

  • Quiera un nombre descriptivo
  • La fábrica pueda devolver una instancia almacenada en caché o de un subtipo
  • Sea necesaria la validación antes de la construcción
  • Quiera controlar la cantidad de instancias (Singleton, pool)
// Constructor: hard to know what this means
new Complex(0.5, -1.2);

// Factory: clear meaning
Complex.fromPolar(1.3, Math.PI / 4); // polar form
Complex.rectangular(0.5, -1.2);      // rectangular form

// Constructor: no caching
new Boolean(true); // deprecated — creates new object!

// Factory: returns cached instance (Boolean.TRUE or FALSE)
Boolean.valueOf(true); // returns Boolean.TRUE singleton

Comprobación rápida

¿Cuál es la principal ventaja de un método de fábrica estático frente a un constructor público?

Repaso: clases de utilidad y métodos de fábrica estáticos

Conceptos clave:

  • Clases de utilidad: clase final con constructor privado y todos sus métodos estáticos
  • Los métodos de fábrica estáticos son alternativas con nombre a los constructores
  • Nombres habituales: of, from, valueOf, getInstance, create, newInstance
  • Las fábricas pueden devolver instancias almacenadas en caché; consulte Integer.valueOf(-128..127)
  • Las fábricas pueden devolver subtipos y ocultar la implementación concreta
  • Utilice builders dentro de las fábricas para construcciones complejas con varios parámetros

Preguntas frecuentes

¿La lección «Clases de utilidades y métodos de fábrica estáticos» es gratis?

Sí — el texto completo de «Clases de utilidades y métodos de fábrica estáticos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Clases de utilidades y métodos de fábrica estáticos»?

Diseñe clases de utilidades no instanciables y exponga métodos de fábrica estáticos como alternativa a los constructores. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Clases de utilidades y métodos de fábrica estáticos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Reglas de sobrecarga de métodos
  2. Parámetros varargs
  3. Campos estáticos y constantes
  4. Clases de utilidades y métodos de fábrica estáticos
← Volver a Java Academy