Page History

...

PlantUML Macro
class CD { int getTrackCount() Track getTrack(int) void addTrack(Track) void removeTrack(Track) } class Track { } CD --> "*" Track: tracks

Code Block

language	java

public class CD {

    private List<Track> tracks = new ArrayList<Track>();
    
    public int getTrackCount() {
        return tracks.size();
    }

    public Track getTrack(int index) {
        return tracks.get(index);
    }
    
    public void addTrack(Track track) {
        if (! tracks.contains(track)) {
	        tracks.add(track);
		}
    }

    public void removeTrack(Track track) {
        tracks.remove(track);
    }
}

Klassediagrammet og koden til venstre viser hvordan tracks-assosiasjonen er realisert. Vi ser at den er kapslet inn med en rekke metoder og at realiseringen bruker en intern ArrayList. Alle innkapslingsmetodene kaller bare tilsvarende metoder i ArrayList-objektet, uten noe særlig mer logikk. Vi sier at CD delegerer til ArrayList. Sekvensdiagrammet til høyre illustrerer hvordan det CD-objektet bruker ArrayList-objektet.

Selv om vi hadde lagt til litt validering og annen logikk, så hadde alt grovarbeidet i praksis blitt utført av ArrayList-klassen, og uten mulighet til å delegere og dermed (gjen)bruke logikken i ArrayList-klassen, så ville CD-klassen blitt mye mer kompleks.

Dette er typisk for delegeringsteknikken:

Den delegerende klassen har et internt objekt av delegat-klassen, altså objektet som det delegeres til, som gjør det meste av grovarbeidet.
Den delegerende klassen har metoder med samme eller lignende navn som som metoder i delegat-klassenklassens.
Disse metodene delegerer mer eller mindre direkte til metoder i delegat-objektet.

Sekvensdiagrammet illustrerer den generelle teknikken godt, bare bytt ut CD med delegerende og ArrayList med delegat.

PlantUML Macro

Hovedprogram --> CD: getTrackCount
CD --> "tracks: ArrayList": size
Hovedprogram --> CD: getTrack
CD --> "tracks: ArrayList": get
Hovedprogram --> CD: addTrack
CD --> "tracks: ArrayList": contains
CD --> "tracks: ArrayList": add
Hovedprogram --> CD: removeTrack
CD --> "tracks: ArrayList": remove

...

PlantUML Macro

class EverySecondIterator {
	Iterator<Object> iteratorDelegate
	EverySecondIterator(Iterator<Object>)
	boolean hasNext()
	Object next()
}
interface "Iterator<Object>" as iterator {
}
iterator <|-- EverySecondIterator
EverySecondIterator --> iterator: iteratorDelegate

Code Block

language	java

public class EverySecondIterator implements Iterator<Object> {
	
	private Iterator<Object> iteratorDelegate;
    
    public EverySecondIterator(Iterator<Object> iterator) {
        this.iteratorDelegate = iterator;
    }
    
    @Override
    public boolean hasNext() {
        return iteratorDelegate.hasNext();
    }

	@Override
    public Object next() {
        Object o = iteratorDelegate.next();
        if (iteratorDelegate.hasNext()) {
            iteratorDelegate.next();
        }
        return o;
    }
}

Vi ser at hvert kall til hasNext() vil resultere i et kall til hasNext() på delegaten (iteratorDelegate). Hvert kall vil next() vil imidlertid gi først et kall til next() på delgaten og så et kall til hasNext() og evt. et nytt kall til next(). Effekten av det andre kallet til next() er å bruke opp / hoppe over annenhvert element: det første elementet brukes, det andre kastes, det tredje brukes og det fjerde kastes osv. hasNext()-kallet er der for å unngå å utløse unntak ved at vi hopper over et element som ikke finnes.

Et viktig poeng her, ut over bruken av delegering, er at konstruktøren tar inn delegaten, slik at den som bruker EverySecondIterator, kan bestemme hvilken iterator det delegeres til, dvs. hvor elementene egentlig kommer fra. I følgende kode-eksempel kommer elementene fra en vanlig liste:

Code Block

language	java

List<Object> list = new ArrayList<Object>(Arrays.asList(1, 2, 3, 4, 5, 6));
// produces every second element in list
Iterator<Object> it2 = new EverySecondIterator(list.iterator());
// prints 1 3 5
 while (it2.hasNext()) {
	System.out.print(it2.next() + " ");
}

En EverySecondIterator-instans kan delegere til en annen EverySecondIterator, for dermed å hoppe over flere elementer:

Code Block

language	java

List<Object> list = new ArrayList<Object>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9));
// produces every fourth element in list
Iterator<Object> it2 =
	new EverySecondIterator(new EverySecondIterator(list.iterator()));
// prints 1 5 9
while (it2.hasNext()) {
	System.out.println(it2.next() + " ");
}

PlantUML Macro

Hovedprogram --> EverySecondIterator: hasNext()
EverySecondIterator --> "iteratorDelegate: Iterator<Object>": hasNext()
Hovedprogram --> EverySecondIterator: next()
EverySecondIterator --> "iteratorDelegate: Iterator<Object>": next()
EverySecondIterator --> "iteratorDelegate: Iterator<Object>": hasNext()
EverySecondIterator --> "iteratorDelegate: Iterator<Object>": next()

...

Page tree

Versions Compared

Old Version 10

New Version Current

Key