I'm trying to solve a design issue using inheritance based polymorphism and dynamic binding. I have an abstract superclass and two subclasses. The superclass contains common behaviour. SubClassA and SubClassB define some different methods: SubClassA defines a method performTransform(), but SubClassB does not.

So the following example

1 var v:SuperClass;

2 var b:SubClassB = new SubClassB();

3 v = b;

4 v.performTransform();

would cause a compile error on line 4 as performTransform() is not defined in the superclass. We can get it to compile by casting...

(v as SubClassA).performTransform();

however, this will cause a runtime exception to be thrown as v is actually an instance of SubClassB, which also does not define performTransform()

So we can get around that by testing the type of an object before casting it:

if( typeof v == SubClassA)
{
  (cast v to SubClassA).performTransform();
}

That will ensure that we only call performTransform() on v's that are instances of SubClassA. That's a pretty inelegant solution to my eyes, but at least its safe. I have used interface based polymorphism (interface meaning a type that can't be instantiated and defines the API of classes that implement it) in the past, but that also feels clunky. For the above case, if SubClassA and SubClassB implemented ISuperClass that defined performTransform, then they would both have to implement performTransform(). If SubClassB had no real need for a performTransform() you would have to implement an empty function.

There must be a design pattern out there that addresses the issue.