Hva delegering er

Delegering vil si at et objekt får en oppgave, men lar et annet objekt (delegaten) gjøre selve jobben. Objektet som delegerer holder delegaten i et felt og videresender kallet. Feltet deklareres mot et grensesnitt, slik at delegaten kan byttes ut — også mens programmet kjører. Dette er den viktigste alternative teknikken til arv i TDT4100, og den dukker opp i hvert eneste eksamenssett fra 2018 til 2021.

public interface Prisberegner {
    double beregnPris(int antallDoegn, boolean helg);
}

public class Standardpris implements Prisberegner {
    @Override
    public double beregnPris(int antallDoegn, boolean helg) {
        return antallDoegn * (helg ? 1200.0 : 950.0);
    }
}

public class Utleie {
    private Prisberegner prisberegner;          // delegat, deklarert som grensesnitt

    public Utleie(Prisberegner prisberegner) {
        setPrisberegner(prisberegner);
    }

    public void setPrisberegner(Prisberegner prisberegner) {
        if (prisberegner == null) {
            throw new IllegalArgumentException("Prisberegner kan ikke vaere null");
        }
        this.prisberegner = prisberegner;       // kan byttes i kjoeretid
    }

    public double beregnPris(int antallDoegn, boolean helg) {
        return prisberegner.beregnPris(antallDoegn, helg);   // ren videresending
    }
}

Delegering kontra arv

Begge teknikkene lar deg variere oppførselen til en klasse. Forskjellen er når valget tas:

Arv låser oppførselen ved opprettelsen: et PremiumUtleie-objekt er og forblir premium. Du må lage én subklasse per variant, og kombinasjoner (premium + rabatt) krever nye subklasser.
Delegering låser ingenting: samme Utleie-objekt kan få ny prisberegner med et setter-kall. Varianter kan kombineres ved at én delegat pakker inn en annen.

På eksamen kommer spørsmålet nesten alltid i formen «forklar med tekst og kode hvordan du kan bruke arv til dette», etterfulgt av «forklar hvordan delegering løser det samme — hvor fleksibel er denne teknikken sammenlignet med arv?». Svaret du skal lande på: delegering er mer fleksibel fordi bindingen skjer i kjøretid og fordi et objekt kan ha flere uavhengige delegater, mens arv gir én fast superklasse.

Innpakning: delegat som legger noe oppå

En vanlig variant er en klasse som både implementerer grensesnittet og holder en delegat av samme grensesnitt. Da kan den gjøre noe før eller etter at delegaten har gjort jobben, uten at den som bruker objektet merker forskjell.

public class LoggendePrisberegner implements Prisberegner {
    private final Prisberegner delegat;
    private final Logg logg;

    public LoggendePrisberegner(Prisberegner delegat, Logg logg) {
        this.delegat = delegat;
        this.logg = logg;
    }

    @Override
    public double beregnPris(int antallDoegn, boolean helg) {
        double pris = delegat.beregnPris(antallDoegn, helg);   // delegaten gjoer jobben
        logg.skriv("Pris beregnet: " + pris);                  // vi legger paa logging
        return pris;                                           // og returnerer resultatet
    }
}

Legg merke til rekkefølgen: kall delegaten, ta vare på resultatet, gjør tilleggsarbeidet, returner resultatet. En klassisk eksamensfeil er å logge før kallet, slik at man logger noe man ikke har regnet ut ennå, eller å glemme å returnere verdien.

Sammensatte delegater

Fordi delegaten selv kan være en innpakning, kan du bygge kjeder: new LoggendePrisberegner(new Helgerabatt(new Standardpris()), logg). Samme idé brukes når en klasse holder to delegater av samme grensesnitt og kombinerer dem — for eksempel et objekt som først finner alle foreldrene til en person og deretter søstrene til hver av dem, slik at resultatet blir tantene. Da har du bygget en ny relasjon uten å skrive en ny klasse for den.

public class Sammensatt implements Relasjon {
    private final Relasjon foerste, andre;

    public Sammensatt(Relasjon foerste, Relasjon andre) {
        this.foerste = foerste;
        this.andre = andre;
    }

    @Override
    public Collection<Person> finn(Person person) {
        Collection<Person> resultat = new ArrayList<>();
        for (Person mellomledd : foerste.finn(person)) {
            resultat.addAll(andre.finn(mellomledd));
        }
        return resultat;
    }
}

Komposisjon og objektstrukturer

Delegering er et spesialtilfelle av komposisjon («har-en»), som står i motsetning til arv («er-en»). Tommelfingerregelen er: bruk arv bare når subklassen virkelig er en spesialisering og kan brukes overalt der superklassen brukes; ellers hold objektet i et felt.

To komposisjonsmønstre kommer igjen på eksamen:

Videresending gjennom et uforanderlig delobjekt. Hvis en Person har en Adresse som ikke kan endres, må setGatenavn lage et helt nytt Adresse-objekt med det nye gatenavnet og den gamle husnummeret, og legge det i feltet. Get-metodene videresender bare: return adresse.getGatenavn();.
Toveis kobling. Når forelder.leggTilBarn(barn) kalles, skal både forelderens barneliste og barnets forelderpeker settes. Det er én metode som eier begge sidene av koblingen; den andre siden får ingen offentlig setter. Da kan strukturen aldri bli inkonsistent.

public void leggTilBarn(Person barn) {
    if (barn == null || barn == this || barna.contains(barn)) {
        throw new IllegalArgumentException("Ugyldig barn");
    }
    barna.add(barn);
    barn.settForelder(this);     // pakke-privat: bare denne klassen skal kalle den
}

Gjennomregnet eksempel

Anta Standardpris som over, og at Helgerabatt trekker 10 % når helg er true. Kallet new LoggendePrisberegner(new Helgerabatt(new Standardpris()), logg).beregnPris(3, true) gir: Standardpris returnerer \(3 \cdot 1200 = 3600\); Helgerabatt gjør \(3600 \cdot 0{,}9 = 3240\); LoggendePrisberegner logger «Pris beregnet: 3240.0» og returnerer \(3240\). Hvert ledd gjør én ting, og ingen av dem kjenner de andre — de kjenner bare grensesnittet.

Studieguide: Delegering og komposisjon

Studieguide: Delegering og komposisjon