0Pricing
Java Academy · Lezione

Classi di utilità e metodi factory statici

Progetti classi di utilità non istanziabili ed esponga metodi factory statici come alternativa ai costruttori.

Classi di utilità e metodi factory statici è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Classi di utilità e metodi factory statici

Le classi di utilità forniscono metodi helper statici senza stato di istanza. I metodi factory statici sono alternative denominate ai costruttori che offrono maggiore leggibilità, caching e flessibilità.

Classi di utilità

Una classe di utilità non ha stato di istanza: è un contenitore di metodi statici. La renda non istanziabile dichiarando un costruttore privato.

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

Classi di utilità della libreria standard

La libreria standard di Java è ricca di classi di utilità: Collections, Arrays, Objects, Files, Paths, 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)

Metodi factory statici

Un metodo factory statico è un metodo statico con un nome che crea e restituisce un'istanza. Vantaggi: nomi descrittivi, possibilità di restituire istanze memorizzate nella cache o di un sottotipo e possibilità di restituire 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)

Caching con una factory statica

Le factory statiche possono restituire istanze memorizzate nella cache, evitando allocazioni ripetute per i valori comuni (come fa Integer.valueOf per -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)

Factory e costruttore: denominazione

Convenzioni comuni per denominare i metodi factory statici:

  • of — factory aggregatrice
  • from — factory di conversione
  • valueOf — factory di conversione (API precedenti)
  • getInstance — singleton
  • create/newInstance — nuovo oggetto
  • get — flessibile
// 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")

Restituzione di sottotipi

Un metodo factory può restituire un sottotipo mentre il tipo restituito dichiarato è l'interfaccia. I chiamanti non dipendono dall'implementazione 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 tramite factory statica

Combini un costruttore privato con una factory statica e un Builder annidato per costruire oggetti complessi.

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();

Validazione nei metodi factory

I metodi factory sono ideali per convalidare gli input prima della costruzione: generi eccezioni significative con informazioni contestuali.

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 Collections: factory statiche

Java 9+ ha aggiunto List.of(), Set.of(), Map.of(): metodi factory statici che creano raccolte immutabili.

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")
);

Quando preferire i metodi factory

Preferisca i metodi factory statici ai costruttori quando:

  • Desidera un nome descrittivo
  • La factory potrebbe restituire un'istanza memorizzata nella cache o di un sottotipo
  • È necessaria la validazione prima della costruzione
  • Desidera controllare il numero di istanze (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

Verifica rapida

Qual è il principale vantaggio di un metodo factory statico rispetto a un costruttore pubblico?

Riepilogo: classi di utilità e metodi factory statici

Punti chiave:

  • Classi di utilità: classe final con costruttore privato e metodi tutti statici
  • I metodi factory statici sono alternative denominate ai costruttori
  • Nomi comuni: of, from, valueOf, getInstance, create, newInstance
  • Le factory possono restituire istanze memorizzate nella cache: vedere Integer.valueOf(-128..127)
  • Le factory possono restituire sottotipi nascondendo l'implementazione concreta
  • Utilizzi i builder all'interno delle factory per costruzioni complesse con molti parametri

Domande Frequenti

La lezione «Classi di utilità e metodi factory statici» è gratuita?

Sì — il testo completo di «Classi di utilità e metodi factory statici» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Classi di utilità e metodi factory statici»?

Progetti classi di utilità non istanziabili ed esponga metodi factory statici come alternativa ai costruttori. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Classi di utilità e metodi factory statici»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Regole dell'overloading dei metodi
  2. Parametri varargs
  3. Campi statici e costanti
  4. Classi di utilità e metodi factory statici
← Torna a Java Academy