Factory - Creational Design Patterns

//the interface that defines the objects to be created by the factory
public interface IFunctions { }

//ConcreteFunction
public class HSDPAFunction implements IFunctions {}

//ConcreteFunction
public class MusicFunction implements IFunctions {}

//ConcreteFunction
public class GPSFunction implements IFunctions {}

//this is the creator class - there are two common variations on this;
//one is where the creator class offers a default implementation of the
//factory method (e.g. in our case the AddFunctions() method) - in which case
//the class is not abstract
//the second option is, as we have done, that the factory method is completely
//abstract thus forcing the subclasses to implement their own factory methods
public abstract class MobileDevice
{
  private Vector<IFunctions> functions = new Vector<IFunctions>();

  public MobileDevice()
  { this.AddFunctions(); }

  public Vector getFunctions()
  {return functions;}

  public abstract void AddFunctions();
}

//this is a concrete creator - a subclass of MobileDevice. It implements the
//AddFunctions() method as it was declared as abstract, thus the subclasses
//(are forced to) define their own composition
public class SmartPhone extends MobileDevice
{
  public void AddFunctions()
  {
    this.getFunctions().add(new HSDPAFunction());
    this.getFunctions().add(new MusicFunction());
    this.getFunctions().add(new GPSFunction());
  }
}

public class PDA extends MobileDevice
{
  public void AddFunctions()
  { this.getFunctions().add(new GPSFunction()); }
}


//simple Main function
Main()
{
  MobileDevice[] devices =new MobileDevice[2];
  devices[0] = new PDA();
  devices[1] = new SmartPhone(); 

  for(int j=0; j<devices.length; j++)
  {
    System.out.println("--------------------------\n" + devices[j].getClass().getSimpleName());
    for(int i=0; i<devices[j].getFunctions().size(); i++)
    {
      System.out.println(" - " + devices[j].getFunctions().elementAt(i).getClass().getSimpleName());
    }
  }
}