Abstract Factory Pattern

Definition

Provides one level of interface higher than the factory pattern. It is used to return one of several factories.

Where to use & benefits

  • Creates families of related or dependent objects like Kit.
  • Provides a class library of products, exposing interface not implementation.
  • Needs to isolate concrete classes from their super classes.
  • A system needs independent of how its products are created, composed, and represented.
  • Try to enforce a constraint.
  • An alternative to Facade to hide platform-specific classes
  • Easily extensible to a system or a family

 

Factory of factories. To keep things simple you can understand it like, you have a set of ‘related’ factory method design pattern. Then you will put all those set of simple factories inside a factory pattern. So in turn you need not be aware of the final concrete class that will be instantiated. You can program for the interface using the top factory.

There is also a view that abstract factory is ‘also’ implemented using prototype instead of factory methords pattern. Beginners for now please don’t yourself with that. Just go with factory methods pattern.

As there is a word ‘abstract’ in the pattern name don’t mistake and confuse it with java ‘abstract’ keyword. It is not related to that. This abstract is from object oriented programming paradim.

Sample abstract factory design pattern implementation in Java API

XML API implements abstract factory. There is a class name SchemaFactory. This acts as a factory and supports implemenation of multiple schemas using abstract factory design pattern.

Sample Java Source Code for Factory Method Design Pattern

Following is the interface, that will be returned as the final end product from the factories.


package com.javapapers.sample.designpattern.abstractfactory;

public interface Animal {
 public void breathe();
}

Following is the interface for which the factory implementation should be done. Inturn all abstract factory will return this type.


package com.javapapers.sample.designpattern.abstractfactory;

public interface AnimalFactory {
 public Animal createAnimal();
}

One of the factory from a predefined set which will instantiate the above interface.


package com.javapapers.sample.designpattern.abstractfactory;

public class SeaFactory implements AnimalFactory {

 public Animal createAnimal() {
 return new Shark();
 }

}

Second factory from a predefined set which will instantiate the Animal interface.


package com.javapapers.sample.designpattern.abstractfactory;

public class LandFactory implements AnimalFactory {
 public Animal createAnimal() {
 return new Elephant();
 }
}

Implementation of an Animal. This class is grouped with the first abstract factory.


package com.javapapers.sample.designpattern.abstractfactory;

public class Shark implements Animal {
 public void breathe() {
 System.out.println("I breathe in water! He he!");
 }
}

Implementation of an Animal. This class is grouped with the second abstract factory.


package com.javapapers.sample.designpattern.abstractfactory;

public class Elephant implements Animal {
 public void breathe() {
 System.out.println("I breathe with my lungs. Its easy!");
 }
}

Following class consumes the abstract factory.


package com.javapapers.sample.designpattern.abstractfactory;

public class Wonderland {
 public Wonderland(AnimalFactory factory) {
 Animal animal = factory.createAnimal();
 animal.breathe();
 }
}

Testing the abstract factory design pattern.


package com.javapapers.sample.designpattern.abstractfactory;

public class SampleAbstractFactory {

 public static void main(String args[]){
 new Wonderland(createAnimalFactory("water"));
 }

 public static AnimalFactory createAnimalFactory(String type){
 if("water".equals(type))
 return new SeaFactory();
 else
 return new LandFactory();
 }
}

Output of the above sample program for abstract factory pattern


<code>I breathe in water! He he!</code>

Factory Method Pattern

Definition

Provides an abstraction or an interface and lets subclass or implementing classes decide which class or method should be instantiated or called, based on the conditions or parameters given.

Where to use & benefits

  • Connect parallel class hierarchies.
  • A class wants its subclasses to specify the object.
  • A class cannot anticipate its subclasses, which must be created.
  • A family of objects needs to be separated by using shared interface.
  • The code needs to deal with interface, not implemented classes.
  • Hide concrete classes from the client.
  • Factory methods can be parameterized.
  • The returned object may be either abstract or concrete object.
  • Providing hooks for subclasses is more flexible than creating objects directly.
  • Follow naming conventions to help other developers to recognize the code structure.

 

A factory method pattern is a creational pattern. It is used to instantiate an object from one among a set of classes based on a logic.

Assume that you have a set of classes which extends a common super class or interface. Now you will create a concrete class with a method which accepts one or more arguments. This method is our factory method. What it does is, based on the arguments passed factory method does logical operations and decides on which sub class to instantiate. This factory method will have the super class as its return type. So that, you can program for the interface and not for the implementation. This is all about factory method design pattern.

Sample factory method design pattern implementation in Java API

For a reference of how the factory method design pattern is implemented in Java, you can have a look at SAXParserFactory. It is a factory class which can be used to intantiate SAX based parsers to pares XML. The method newInstance is the factory method which instantiates the sax parsers based on some predefined logic.

Block diagram for The Design Pattern

Sample Java Source Code for Factory Method Design Pattern

Based on comments received from users, I try to keep my sample java source code as simple as possible for a novice to understand.

Base class:


package com.javapapers.sample.designpattern.factorymethod;

//super class that serves as type to be instantiated for factory method pattern
public interface Pet {

 public String speak();

}

First subclass:


package com.javapapers.sample.designpattern.factorymethod;

//sub class 1 that might get instantiated by a factory method pattern
public class Dog implements Pet {

 public String speak() {
 return "Bark bark...";
 }
}

Second subclass:


package com.javapapers.sample.designpattern.factorymethod;

//sub class 2 that might get instantiated by a factory method pattern
public class Duck implements Pet {
 public String speak() {
 return "Quack quack...";
 }
}

Factory class:


package com.javapapers.sample.designpattern.factorymethod;

//Factory method pattern implementation that instantiates objects based on logic
public class PetFactory {

 public Pet getPet(String petType) {
 Pet pet = null;

 // based on logic factory instantiates an object
 if ("bark".equals(petType))
 pet = new Dog();
 else if ("quack".equals(petType))
 pet = new Duck();
 return pet;
 }
}

Using the factory method to instantiate


package com.javapapers.sample.designpattern.factorymethod;

//using the factory method pattern
public class SampleFactoryMethod {

 public static void main(String args[]){

 //creating the factory
 PetFactory petFactory = new PetFactory();

 //factory instantiates an object
 Pet pet = petFactory.getPet("bark");

 //you don't know which object factory created
 System.out.println(pet.speak());
 }

}

Output of the above sample program for Factory Method Pattern


<code>Bark bark</code>