PricingLoginStart free
Java Academy · leksjon

Hjelpeklasser og statiske fabrikkmetoder

Utform klasser som ikke kan instansieres, og tilby statiske fabrikkmetoder som alternativer til konstruktører.

Leksjon 4 av 413 trinn

Hjelpeklasser og statiske fabrikkmetoder er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Verktøyklasser og statiske fabrikkmetoder

Verktøyklasser tilbyr statiske hjelpefunksjoner uten instanstilstand. Statiske fabrikkmetoder er navngitte alternativer til konstruktører som gir bedre lesbarhet, hurtigbufring og fleksibilitet.

Verktøyklasser

En verktøyklasse har ingen instanstilstand – den er en beholder for statiske metoder. Gjør den umulig å instansiere ved å deklarere en privat konstruktør.

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

Verktøyklasser i standardbiblioteket

Javas standardbibliotek er fullt av verktøyklasser: 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)

Statiske fabrikkmetoder

En statisk fabrikkmetode er en navngitt statisk metode som oppretter og returnerer en instans. Fordeler: beskrivende navn, kan returnere cachede instanser eller instanser av undertyper, og kan returnere 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)

Hurtigbufring med statisk fabrikk

Statiske fabrikkmetoder kan returnere cachede instanser, slik at gjentatt allokering av vanlige verdier unngås (slik Integer.valueOf gjør for -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)

Fabrikk kontra konstruktør: navngivning

Vanlige navnekonvensjoner for statiske fabrikkmetoder:

  • of – fabrikk for sammensatte verdier
  • from – konverterende fabrikk
  • valueOf – konverterende fabrikk (eldre API-er)
  • getInstance – singleton
  • create/newInstance – nytt objekt
  • get – fleksibel
// 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")

Returnere undertyper

En fabrikkmetode kan returnere en undertype selv om den deklarerte returtypen er grensesnittet. Kallere kobles dermed fra den konkrete implementasjonen.

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 statisk fabrikk

Kombiner en privat konstruktør med en statisk fabrikk og en nestet Builder for å opprette komplekse objekter.

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

Validering i fabrikkmetoder

Fabrikkmetoder egner seg godt til validering av inndata før oppretting – kast meningsfulle unntak med 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

Collections API: Statiske fabrikker

Java 9+ la til List.of(), Set.of(), Map.of() – statiske fabrikkmetoder som oppretter uforanderlige samlinger.

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

Når bør du foretrekke fabrikkmetoder

Foretrekk statiske fabrikkmetoder fremfor konstruktører når:

  • Du ønsker et beskrivende navn
  • Fabrikken kan returnere en cachet instans eller en instans av en undertype
  • Det er nødvendig med validering før oppretting
  • Du ønsker å kontrollere antallet instanser (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

Hurtigsjekk

Hva er den største fordelen med en statisk fabrikkmetode fremfor en offentlig konstruktør?

Besvar den i den interaktive leksjonen

Oppsummering: Verktøyklasser og statiske fabrikkmetoder

Viktige poenger:

  • Verktøyklasser: final class med privat konstruktør og bare statiske metoder
  • Statiske fabrikkmetoder er navngitte alternativer til konstruktører
  • Vanlige navn: of, from, valueOf, getInstance, create, newInstance
  • Fabrikker kan returnere cachede instanser – se Integer.valueOf(-128..127)
  • Fabrikker kan returnere undertyper samtidig som den konkrete implementasjonen skjules
  • Bruk builders i fabrikker for kompleks oppretting med mange parametere
Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
104
Leksjoner
374
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Hjelpeklasser og statiske fabrikkmetoder» gratis?

Ja – hele teksten i «Hjelpeklasser og statiske fabrikkmetoder» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Hjelpeklasser og statiske fabrikkmetoder»?

Utform klasser som ikke kan instansieres, og tilby statiske fabrikkmetoder som alternativer til konstruktører. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Hjelpeklasser og statiske fabrikkmetoder»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Regler for metodeoverlasting
  2. Varargs-parametere
  3. Statiske felt og konstanter
  4. Hjelpeklasser og statiske fabrikkmetoder
← Tilbake til Java Academy