0Pricing
Java Academy · Lekcja

Klasy narzędziowe i statyczne metody fabrykujące

Projektuj klasyniedające się tworzyć za pomocą operatora new i udostępniaj statyczne metody fabrykujące jako alternatywę dla konstruktorów.

Klasy narzędziowe i statyczne metody fabrykujące to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Klasy narzędziowe i statyczne metody fabryczne

Klasy narzędziowe udostępniają statyczne metody pomocnicze i nie mają stanu instancji. Statyczne metody fabryczne są nazwanymi alternatywami dla konstruktorów, zapewniającymi lepszą czytelność, buforowanie i elastyczność.

Klasy narzędziowe

Klasa narzędziowa nie ma stanu instancji — jest kontenerem statycznych metod. Uczyń ją niemożliwą do zainstancjonowania, deklarując prywatny konstruktor.

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

Klasy narzędziowe biblioteki standardowej

Biblioteka standardowa Javy jest pełna klas narzędziowych: 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)

Statyczne metody fabryczne

Statyczna metoda fabryczna to nazwana metoda statyczna, która tworzy i zwraca instancję. Zalety: opisowe nazwy, możliwość zwracania zbuforowanych instancji lub instancji podtypów oraz możliwość zwrócenia 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)

Buforowanie za pomocą statycznej fabryki

Statyczne fabryki mogą zwracać zbuforowane instancje, unikając wielokrotnej alokacji dla często używanych wartości (tak jak robi to Integer.valueOf dla zakresu -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)

Fabryka a konstruktor: nazewnictwo

Typowe konwencje nazewnicze dla statycznych metod fabrycznych:

  • of — fabryka agregująca
  • from — fabryka konwertująca
  • valueOf — fabryka konwertująca (starsze API)
  • getInstance — Singleton
  • create/newInstance — nowy obiekt
  • get — metoda elastyczna
// 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")

Zwracanie podtypów

Metoda fabryczna może zwracać podtyp, mimo że zadeklarowany typ zwracany jest interfejsem. Wywołujący nie jest wtedy zależny od konkretnej implementacji.

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 za pomocą statycznej fabryki

Połącz prywatny konstruktor ze statyczną fabryką i zagnieżdżoną klasą Builder, aby tworzyć złożone obiekty.

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

Walidacja w metodach fabrycznych

Metody fabryczne doskonale nadają się do sprawdzania danych wejściowych przed utworzeniem obiektu — zgłaszaj znaczące wyjątki zawierające odpowiedni kontekst.

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: statyczne fabryki

Java 9+ dodała List.of(), Set.of(), Map.of() — statyczne metody fabryczne tworzące niemodyfikowalne kolekcje.

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

Kiedy preferować metody fabryczne

Preferuj statyczne metody fabryczne zamiast konstruktorów, gdy:

  • Potrzebujesz opisowej nazwy
  • Fabryka może zwrócić zbuforowaną instancję lub instancję podtypu
  • Przed utworzeniem obiektu konieczna jest walidacja
  • Chcesz kontrolować liczbę instancji (Singleton, pula)
// 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

Szybki test

Jaka jest główna zaleta statycznej metody fabrycznej w porównaniu z publicznym konstruktorem?

Podsumowanie: klasy narzędziowe i statyczne metody fabryczne

Najważniejsze informacje:

  • Klasy narzędziowe: klasa final z prywatnym konstruktorem i wyłącznie statycznymi metodami
  • Statyczne metody fabryczne są nazwanymi alternatywami dla konstruktorów
  • Typowe nazwy: of, from, valueOf, getInstance, create, newInstance
  • Fabryki mogą zwracać zbuforowane instancje — zobacz Integer.valueOf(-128..127)
  • Fabryki mogą zwracać podtypy, ukrywając konkretną implementację
  • W przypadku złożonego tworzenia obiektów z wieloma parametrami używaj builderów wewnątrz fabryk

Często zadawane pytania

Czy lekcja „Klasy narzędziowe i statyczne metody fabrykujące” jest bezpłatna?

Tak — pełny tekst „Klasy narzędziowe i statyczne metody fabrykujące” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Klasy narzędziowe i statyczne metody fabrykujące”?

Projektuj klasyniedające się tworzyć za pomocą operatora new i udostępniaj statyczne metody fabrykujące jako alternatywę dla konstruktorów. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Klasy narzędziowe i statyczne metody fabrykujące”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Zasady przeciążania metod
  2. Parametry varargs
  3. Pola statyczne i stałe
  4. Klasy narzędziowe i statyczne metody fabrykujące
← Powrót do Java Academy