Salesforce: Polymorphism driven by Apex class inheritance

Polywhatsthatnow? Polymorphism ” is the ability of one type, A, to appear as and be used like another type, B.”

It is a facet of OOP and can best be described using the good ol’ example of the ‘Shape’ class problem (thanks Java!). Let’s suppose we’d like to create an application that drew a number of shapes on a page. At the time of analysis we know that we want to immediately support circles, but to future-proof our application we need to support the drawing of any shapes. Being Pretty Darn Good Developers(tm) we realise we should create a Shape class that has a single method used to draw itself, and any specific shapes should be derived from this class, and override that method. Make sense? Didn’t think so.

In our worked example I’ll use colours (Colour = Color my American friends:P) instead of shapes, namely, we have a repeat-tag  that will run over a list of classes. Each of these classes have a getColour() method, but certain classes are expected to return specific colours. That’s right we need a list of classes, so they need to be the same class type, but the same method in each must return different values (let’s assume without the use of conditional logic statements). Enough dilly-dallying, let’s get our code on.

To start with we’ll need an interface that dictates the ‘signature’ required of our classes.

[code language=”java”]
public interface ColourInt {
String getColour();
}
[/code]

We’re also going to need a base colour class that ‘implements’ our interface.. Note the ‘virtual’ keyword, this allows the class to be inherited, and the method to be overridden.

[code language=”java”]
public virtual class ColourClassBase implements ColourInt{

public virtual String getColour(){
return ‘blue’;
}
}
[/code]

Next we’ll code up some extensions of this base class. Note the ‘extends’ and ‘override’ keywords used to inherit the base class, and override it’s method.

[code language=”java”]
public class Green extends ColourClassBase{

public virtual override String getColour(){
return ‘green’;
}
}
[/code]

[code language=”java”]
public class Orange extends ColourClassBase{

public virtual override String getColour(){
return ‘orange’;
}
}
[/code]

So we’ve got our backendish logic, now we need a way to expose it to the world. First up the page-controller,

[code language=”java”]
public class ColoursController {
public List<ColourClassBase> colours{get;set;}

public ColoursController(){
colours = new List<ColourClassBase>();

colours.add(new ColourClassBase());
colours.add(new Orange());
colours.add(new Green());
}
}
[/code]

And then the page that uses it,

[code language=”java”]
<apex:page controller="ColoursController" showheader="false" standardstylesheets="false">

<apex:repeat value="{!colours}" var="c">
outputPanel layout="block" style="font-family: Georgia; font-size: 24px">
outputText value="Aweful Colour Combination" style="color:{!c.colour};"/>
</apex:outputPanel>
</apex:repeat>

</apex:page>
[/code]

This demo’s nothing to write home about, but I thought I’d put it up so that you know I’m not trying to pull a fast one on you. In the real world polymorphism requires a substantial amount of analysis and technical architecturing, but the value becomes apparent when you need to plug another class type (in our case a colour) into your application.  That, and you get to feel real smarts-like.

Merry Christmas everyone, and goodwill to all.