Ensure method A is called after every call of B (an abstract implemented method)?

Question

Having this tasteful class

     public abstract class CakeSkill 
     {

         //.. 

         boolean cherry=false;

         private void finalMandatoryTouch()
         {        
              cherry=true;
         }                
         abstract public void cook();
     }

A class that extends it would be something like

     class Cheff extends CakeSkill 
     {
         //..

         void cook()
         {
         //..Secret recipe
         }     
     }

But of course this won't work,

finalMandaroryTouch() hasn't been called, then no cake will end with a cherry..

[EDIT]

This one could be a solution

       class MemoriousCheff extends CakeSkill 
       {
           //..

           void cook()
           {
               //..Secret recipe
               finalMandatoryTouch();
           }     
       }

but requires:

• Cheff to have a perfect memory that don't forget to call finalMandatoryTouch()
• Making finalMandatoryTouch() to be protected (at least)

[/EDIT]

It would be great! (but no Java) if something like this could be done

  abstract public void cook()   
  {  
    @implementedMethod

    finalMandatoryTouch();        
  }

How can be implemented this useful functionality?

Thank you very much

Answer 1

Change cook to a protected method cookImpl then have a public final method called cook:

public final void cook()
{
    cookImpl();
    finalMandatoryTouch();
}

protected abstract void cookImpl();

That way the subclass only needs to worry about cookImpl , but callers of cook get the cherry on top. Callers not in the same package or class hierarchy won't even see cookImpl , so won't be able to call it directly.

This is the template method pattern , basically.

Answer 2

It's called the Template method pattern.

final public void cook() {  
    mainCookRecipe();
    finalMandatoryTouch();        
}

abstract public void mainCookRecipe();

Answer 3

public abstract class CakeSkill {

    public void cook() {
        doCook();
        finalMandatoryTouch();
    }

    protected abstract doCook();

    private finalMandatoryTouch() { ... }
}

Etc.

Answer 4

You could change your cook() method to an actual method and then invoke a separate abstract method as well as your finalMandatoryTouch() method.

In your abstract class:

 public void cook() {
     specificCook();
     finalMandatoryTouch();
 }

 abstract void specificCook();

Answer 5

It seems that inheritance is not the right way to model your problem. In Java you can only inherit from one class, and since it's also a very static relationship, it limits your chef in the skills he can perform.

A better way would be to use composition. Cooking skills could be strategies that the chef performs:

interface CookingSkill {
  void cook();
}

class CakeSkill implements CookingSkill {
  private boolean cherry = false;
  private void finalMandatoryTouch() {
    cherry = true;
  }
  public void cook() {
    //...
    finalMandatoryTouch();
  }
}

class Chef {
  private CookingSkill cookingSkill;
  // getters and setters ...
  public void cook() {
    // ...
    cookingSkill.cook();
    // ...
  }
}

Now you can assign different cooking skills to your chef.