Re: Call-Super antipattern

On Wed, 7 May 2008, Philipp wrote:


Clearly, what Java needs is a sub keyword. Like super, but it goes the
other way.

Uh, thinking about it, maybe not.

But a language feature which means something like "when you send this
message to an object, invoke all the matching methods in the hierarchy,
not just the most-overriding one" would do it. I'm not aware of any
language having a feature like that; i think you could get the effect in
python using a metaclass, and you could probably do the same in any other
language that supports deep metamagic, like LISP, but nothing lets you do
it directly.

One of my rules of thumb is to look for ways to replace inheritance with
composition. So, how about this, using a pumped-up version of the Type
Object pattern (or is it really Strategy?):

/* our sort-of Type Object */
public abstract class VehicleType {
  public final VehicleType base ; // used to mimic inheritance hierarchy
  protected VehicleType(VehicleType base) {
  this.base = base ;
  }
  // sort-of Template Method pattern here
  public void start() {
  handleStart() ;
  if (base != null) base.start() ;
  }
  public abstract void handleStart() ;
}

/* the instances of the Type Object - which are actually singletons of
different classes, defined as anonymous classes */

public static final VehicleType VEHICLE = new VehicleType (null) {
  public void handleStart() {
  unlockDoors() ;
  }
} ;

public static final VehicleType CAR = new VehicleType (VEHICLE) {
  public void handleStart() {
  startEngine() ;
  }
} ;

public static final VehicleType FORD = new VehicleType (CAR) {
  public void handleStart() {
  switchRadioOn() ;
  }
} ;

/* our vehicle class */
public class Vehicle {
  public final VehicleType type ;
  public Vehicle(VehicleType type) {
  this.type = type ;
  }
  public void start() {
  type.start() ;
  }
}

(note that i haven't tried to compile this, so please excuse any syntax
errors; i hope the intent is clear)

Is this icky?

In reality, you'd want VehicleType.start to take a Vehicle as a
pseudo-this parameter, so it can operate on the vehicle being started.

A problem arises when you want to have more than just start() - maybe
stop(), accelerate(), brake(), etc, since then the template methods in
VehicleType all have to include the boilerplate to walk the type object
hierarchy, which means duplication of code. If we had higher-order
functions, the walking could easily be refactored, but we don't. Thus,
we'd have to use a bit of Visitor pattern:

/* a visitor type, of sorts */
public abstract class VehicleAction
{
  public abstract void apply(VehicleType type) ;
}

/* modified Type Object with a visitation method */
public abstract class VehicleType {
  public final VehicleType base ; // used to mimic inheritance hierarchy
  protected VehicleType(VehicleType base) {
  this.base = base ;
  }
  // sort-of Template Method using the sort-of Visitor
  public void do(VehicleAction action) {
  action.apply(this) ;
  if (base != null) base.do(action) ;
  }
  public abstract void handleStart() ;
  public abstract void handleStop() ;
}

/* concrete visitors, again as singleton instances of anonymous classes */

public static final VehicleAction START = new VehicleAction() {
  public abstract void apply(VehicleType type) {
  type.handleStart() ;
  }
}

public static final VehicleAction STOP = new VehicleAction() {
  public abstract void apply(VehicleType type) {
  type.handleStop() ;
  }
}

/* aaand finally ... */
public class Vehicle {
  public final VehicleType type ;
  public Vehicle(VehicleType type) {
  this.type = type ;
  }
  public void start() {
  type.do(START) ;
  }
  public void stop() {
  type.do(STOP) ;
  }
}

This is the kind of thing that gives OOP a bad name, isn't it?

tom

--
Ensure a star-man is never constructed!