Classes with template method design

Question

I have made this four classes and I'm wondering if I used the template method design pattern correctly because I'm really struggeling with this subject.

I have used the methods getPrijsBehandeling() and getBeschrijvingBehandeling() as my abstract classes.

Also I'm wondering if I should use the abstract methods in my UML or only in the code.

Since this is the first time I'm using a design pattern I wonder if I’m on the right track.

public abstract class Behandeling {

    private String beschrijving;
    private double prijs;
    private int behandelingsNummer;

    private Wassen wassen;

    public Behandeling(int behandelingsNummber, int keuze) {
        this.behandelingsNummer = behandelingsNummber;

        if(keuze == 3 || keuze == 4) {
            wassen = new Wassen();
        }
    }

    public abstract double getPrijsBehandeling();

    public abstract String getBeschrijvingBehandeling();

    public double getPrijs() {
        prijs = getPrijsBehandeling();

        if(wassen != null) {
            prijs += wassen.getPrijsBehandeling();
        }
        return prijs;
    }

    public String getBeschrijving() {
        beschrijving = getBeschrijvingBehandeling();

        if(wassen != null) {
            beschrijving += wassen.getBeschrijvingBehandeling();
        }
        return beschrijving;
    }

    public int getBehandelingsNummer() {
        return behandelingsNummer;
    }
} 

------------------------------------------

public class Verven extends Behandeling {

    public Verven(int behandelingsNummer, int keuze) {
        super(behandelingsNummer, keuze);
    }

    @Override
    public double getPrijsBehandeling() {
        return 20;
    }

    @Override
    public String getBeschrijvingBehandeling() {
        return "Haren worden geverfd";
    }
}

---------------------------------------------

public class Knippen extends Behandeling{

    public Knippen(int behandelingsNummer, int keuze) {
        super(behandelingsNummer, keuze);
    }

    @Override
    public double getPrijsBehandeling() {
        return 15;
    }

    @Override
    public String getBeschrijvingBehandeling() {
        return "Haren worden geknipt";
    }
}

-----------------------------------------------------

public class Wassen {

    private double prijs;
    private String beschrijving;

    public Wassen() {
        this.prijs = 7.50;
        this.beschrijving = " en haren worden gewassen";
    }

    public double getPrijsBehandeling() {
        return prijs;
    }

    public String getBeschrijvingBehandeling() {
        return beschrijving;
    }
}

Answer 1

The methods (aka “operation”, in UML speak) geefPrijs()and geefBeschrijving() are indeed designed according to the template method pattern: the base class implements the general algorithm, encapsulating the “primitive” parts that may need to be specialized into separate methods that can be overridden (i.e. “specialized”, in UML speak) by class extensions.

If the base class cannot provide its own implementation of a “partial” methods, you would make it abstract. But although this is how the pattern is usually described, in practice this is not an obligation: it is perfectly valid that the base class provides a default behavior that is not always overridden. The UML diagram should reflect your design in this regard, if there are abstract elements.

Some additional hints

In your design getPrijs() (template method) and getPrijsBehandeling() (primitive used in the template method) are both public and have names that create a risk of confusion:

• if the primitive is not intended to be used for other purposes, it is one of the rare situation where making it protected could be a good idea.
• if you prefer to avoid protected, you could use a naming convention. GoF suggests the “do” prefix inspired from a framework that didn’t survive. I prefer “prepare” like preparePrijsBehandeling() and prepareBeschrijvingBheandeling() because it immediately raises the question “prepare for what?” preventing inappropriate use.
• It’s not the case here, but of course, if the primitive is a primitive operation that makes sense outside of the template methods, then there is no issue (example: surface() or perimeter() or barycenter() that are geometric characteristics of a shape that may be relevant for some template methods but make sense on their own).