Hva er designmønstre?

Designmønstre er velprøvde løsninger på gjentakende designproblemer. De gir et felles vokabular for programmerere og hjelper med å lage kode som er fleksibel, gjenbrukbar og vedlikeholdbar.

De viktigste designmønstrene i TDT4100:

Observer: Subjekt varsler lyttere om tilstandsendringer

Strategy: Kapsler algoritmer i objekter for utskiftbarhet

Factory Method: Delegerer objektopprettelse til subklasser

Iterator: Sekvensiell tilgang til elementer i en samling

Decorator: Dynamisk tilleggsfunksjonalitet via wrapping

Singleton: Nøyaktig én instans av en klasse

Eksempel: Observer-mønsteret

import java.util.ArrayList;
import java.util.List;

// Observer-grensesnitt
public interface StockObserver {
    void onPriceChange(String stock, double newPrice);
}

// Subject (observerbart objekt)
public class StockMarket {
    private final List<StockObserver> observers = new ArrayList<>();
    private double price;

    public void addObserver(StockObserver obs) {
        observers.add(obs);
    }

    public void removeObserver(StockObserver obs) {
        observers.remove(obs);
    }

    public void setPrice(double newPrice) {
        this.price = newPrice;
        // Varsle alle observatører
        for (StockObserver obs : observers) {
            obs.onPriceChange("NTNU", newPrice);
        }
    }
}

// Konkret observer
public class PhoneAlert implements StockObserver {
    @Override
    public void onPriceChange(String stock, double newPrice) {
        System.out.println("Varsling: " + stock + " er nå " + newPrice);
    }
}

SOLID-prinsippene

Fem retningslinjer for god objektorientert design:

Single Responsibility: Én klasse, ett ansvarsområde
Open/Closed: Åpen for utvidelse, lukket for modifikasjon
Liskov Substitution: Subklasser kan erstatte superklasser
Interface Segregation: Små, spesifikke grensesnitt
Dependency Inversion: Avhengigheter mot abstraksjoner

Eksempel: Strategy-mønsteret

// Strategy-grensesnitt
public interface SortStrategy<T> {
    void sort(List<T> list);
}

// Konkrete strategier
public class BubbleSort<T extends Comparable<T>> implements SortStrategy<T> {
    public void sort(List<T> list) { /* bubblesort */ }
}

public class QuickSort<T extends Comparable<T>> implements SortStrategy<T> {
    public void sort(List<T> list) { /* quicksort */ }
}

// Kontekst
public class Sorter<T extends Comparable<T>> {
    private SortStrategy<T> strategy;

    public void setStrategy(SortStrategy<T> strategy) {
        this.strategy = strategy;
    }

    public void sort(List<T> list) {
        strategy.sort(list);  // Delegerer til valgt strategi
    }
}

Strategien kan byttes ved kjøretid uten å endre Sorter-klassen — Open/Closed Principle i praksis.

Studieguide: Designmønstre

Studieguide: Designmønstre