Java Academy · Lektion

Fabrikmetodmönstret

Definiera en fabrikmetod i en basklass och låt subklasserna avgöra vilken produkt som ska skapas.

Lektion 2 av 413 steg

Fabrikmetodmönstret är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Factory Method-mönstrets syfte

Factory Method definierar ett gränssnitt för att skapa ett objekt, men låter underklasserna avgöra vilken klass som ska instansieras. Det frikopplar skapandelogiken från klientkoden.

Problemet utan Factory Method

Utan en fabrik är klientkoden full av anrop till new ConcreteClass(). Om en ny variant läggs till måste varje anropsställe ändras — vilket bryter mot Open/Closed Principle.

// Client knows too much:
Shape shape;
if (type.equals("circle")) shape = new Circle(r);
else if (type.equals("rect")) shape = new Rectangle(w, h);
// Every new shape requires editing this code.

Den abstrakta skaparklassen

Definiera en abstrakt skaparklass med en factory-metod, createProduct(). Underklasserna skriver över den för att returnera specifika produkttyper.

public abstract class Dialog {
    public void render() {
        Button btn = createButton(); // factory method
        btn.onClick();
    }
    protected abstract Button createButton();
}

Konkreta skapare

Varje underklass skriver över factory-metoden för att returnera rätt produkt utan att ändra den omgivande algoritmen i basklassen.

public class WindowsDialog extends Dialog {
    @Override
    protected Button createButton() { return new WindowsButton(); }
}
public class WebDialog extends Dialog {
    @Override
    protected Button createButton() { return new HtmlButton(); }
}

Produktgränssnittet

Alla konkreta produkter implementerar ett gemensamt gränssnitt, så att skaparen kan arbeta generiskt med dem.

public interface Button {
    void onClick();
    void render();
}
public class WindowsButton implements Button {
    public void onClick() { System.out.println("Windows click"); }
    public void render() { System.out.println("Render Windows button"); }
}

Statiska factory-metoder jämfört med Factory Method-mönstret

En statisk factory-metod, till exempel LocalDate.of(), är en namnkonvention och inte GoF-mönstret. GoF-mönstret använder arv, medan statiska fabriker använder statiska metoder i en enda klass.

// Static factory (NOT the GoF pattern)
LocalDate d = LocalDate.of(2024, 6, 15);
// GoF Factory Method uses a class hierarchy

Parameteriserad factory-metod

Skicka en parameter till factory-metoden för att välja mellan flera produkter utan att behöva en underklass per produkt.

public class ShapeFactory {
    public static Shape create(String type, double... dims) {
        return switch (type) {
            case "circle"    -> new Circle(dims[0]);
            case "rectangle" -> new Rectangle(dims[0], dims[1]);
            default -> throw new IllegalArgumentException("Unknown: " + type);
        };
    }
}

Factory Method med generics

Använd generics för att göra factory-metoden typsäker och återanvändbar för olika produktfamiljer.

public abstract class Repository<T, ID> {
    public abstract T findById(ID id);
    protected abstract T createEmpty(); // factory method
}

Registrera fabriker med en Map

En registerbaserad fabrik lagrar en mappning från typsträngar till Supplier-lambdor och undviker därmed if-else-kedjor samtidigt som registreringen blir dynamisk.

Map<String, Supplier<Notification>> registry = new HashMap<>();
registry.put("email", EmailNotification::new);
registry.put("sms",   SmsNotification::new);
Notification n = registry.getOrDefault(type, DefaultNotification::new).get();

Factory Method jämfört med Abstract Factory

Factory Method skapar en produkttyp genom arv. Abstract Factory skapar familjer av relaterade produkter genom komposition. Använd Factory Method när en produkt varierar och Abstract Factory när en hel produktserie ska variera tillsammans.

Praktiskt exempel: Logger Factory

SLF4J:s LoggerFactory.getLogger(Class) är en statisk fabrik som returnerar rätt logger-implementation (Logback, Log4j eller JUL) utan att anroparen behöver känna till vilken det är.

Logger log = LoggerFactory.getLogger(MyService.class);
log.info("Service started");

Snabb kontroll

Vilken är den viktigaste egenskapen hos Factory Method-mönstret?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Factory Method frikopplar objektskapandet från klienten genom att placera instansieringsbeslutet i åsidosättbara metoder i underklasser. Använd mönstret när en klass inte kan förutse vilka objekt den behöver skapa.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Fabrikmetodmönstret” gratis?

Ja – hela texten till ”Fabrikmetodmönstret” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Fabrikmetodmönstret”?

Definiera en fabrikmetod i en basklass och låt subklasserna avgöra vilken produkt som ska skapas. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Fabrikmetodmönstret”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy