0Pricing
Java Academy · Leçon

Classes utilitaires et méthodes de fabrique statiques

Concevez des classes utilitaires non instanciables et exposez des méthodes de fabrique statiques comme solutions de remplacement aux constructeurs.

Classes utilitaires et méthodes de fabrique statiques est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Classes utilitaires et méthodes de fabrique statiques

Les classes utilitaires fournissent des méthodes auxiliaires statiques sans état d'instance. Les méthodes de fabrique statiques sont des alternatives nommées aux constructeurs qui offrent une meilleure lisibilité, la mise en cache et davantage de flexibilité.

Classes utilitaires

Une classe utilitaire ne possède pas d'état d'instance : c'est un conteneur de méthodes statiques. Rendez-la non instanciable en déclarant un constructeur privé.

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

Classes utilitaires de la bibliothèque standard

La bibliothèque standard de Java regorge de classes utilitaires : Collections, Arrays, Objects, Files, Paths et 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éthodes de fabrique statiques

Une méthode de fabrique statique est une méthode statique nommée qui crée et renvoie une instance. Avantages : noms explicites, possibilité de renvoyer des instances mises en cache ou d'un sous-type, et possibilité de renvoyer 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)

Mise en cache avec une fabrique statique

Les fabriques statiques peuvent renvoyer des instances mises en cache, ce qui évite des allocations répétées pour les valeurs courantes (comme le fait Integer.valueOf pour -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)

Fabrique ou constructeur : conventions de nommage

Conventions de nommage courantes pour les méthodes de fabrique statiques :

  • of — fabrique d'agrégation
  • from — fabrique de conversion
  • valueOf — fabrique de conversion (anciennes API)
  • getInstance — instance unique
  • create/newInstance — nouvel objet
  • get — convention 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")

Renvoyer des sous-types

Une méthode de fabrique peut renvoyer un sous-type alors que le type de retour déclaré est l'interface. Les appelants sont ainsi découplés de l'implémentation concrète.

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 via une fabrique statique

Combinez un constructeur privé avec une fabrique statique et un Builder imbriqué pour construire des objets complexes.

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

Validation dans les méthodes de fabrique

Les méthodes de fabrique sont idéales pour valider les données d'entrée avant la construction : lancez des exceptions explicites avec un contexte pertinent.

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 des collections : fabriques statiques

Java 9+ a ajouté List.of(), Set.of() et Map.of() : des méthodes de fabrique statiques qui créent des collections immuables.

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

Quand préférer les méthodes de fabrique

Préférez les méthodes de fabrique statiques aux constructeurs lorsque :

  • Vous souhaitez un nom explicite
  • La fabrique peut renvoyer une instance mise en cache ou d'un sous-type
  • Une validation avant la construction est nécessaire
  • Vous souhaitez contrôler le nombre d'instances (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

Vérification rapide

Quel est le principal avantage d'une méthode de fabrique statique par rapport à un constructeur public ?

Récapitulatif : classes utilitaires et méthodes de fabrique statiques

Points essentiels :

  • Classes utilitaires : classe finale avec constructeur privé et méthodes toutes statiques
  • Les méthodes de fabrique statiques sont des alternatives nommées aux constructeurs
  • Noms courants : of, from, valueOf, getInstance, create, newInstance
  • Les fabriques peuvent renvoyer des instances mises en cache — voir Integer.valueOf(-128..127)
  • Les fabriques peuvent renvoyer des sous-types tout en masquant l'implémentation concrète
  • Utilisez des builders dans les fabriques pour construire des objets complexes comportant plusieurs paramètres

Questions Fréquemment Posées

La leçon « Classes utilitaires et méthodes de fabrique statiques » est-elle gratuite ?

Oui — le texte complet de « Classes utilitaires et méthodes de fabrique statiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Classes utilitaires et méthodes de fabrique statiques » ?

Concevez des classes utilitaires non instanciables et exposez des méthodes de fabrique statiques comme solutions de remplacement aux constructeurs. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Classes utilitaires et méthodes de fabrique statiques » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Règles de surcharge des méthodes
  2. Paramètres varargs
  3. Champs statiques et constantes
  4. Classes utilitaires et méthodes de fabrique statiques
← Retour à Java Academy