AbstractFactory Design Pattern with an Example program

Creational Patterns - Abstract Factory Pattern

Definition:

Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
A hierarchy that encapsulates: many possible “platforms”, and the construction of a suite of “products”.
The new operator considered harmful.

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 classe.
Easily extensible to a system or a family.
Related patterns include.
Factory method, which is often implemented with an abstract factory.

- Singleton, which is often implemented with an abstract factory.
- Prototype, which is often implemented with an abstract factory.
- Facade, which is often used with an abstract factory by providing an interface for creating implementing class.

This pattern is one level of abstraction higher than factory pattern. This means that the abstract factory returns the factory of classes. Like Factory pattern returned one of the several sub-classes, this returns such factory which later will return one of the sub-classes.

Working with Abstract Factory Design Pattern

The classes that participate to the Abstract Factory pattern are:

    AbstractFactory - declares a interface for operations that create abstract products.
    ConcreteFactory - implements operations to create concrete products.
    AbstractProduct - declares an interface for a type of product objects.
    Product - defines a product to be created by the corresponding ConcreteFactory; it implements the         AbstractProduct interface.
    Client - uses the interfaces declared by the AbstractFactory and AbstractProduct classes.

The classic implementation for the Abstract Factory pattern is the following:

package com.kota.java;
 
abstract class AbstractProductA{
 public abstract void operationA1();
 public abstract void operationA2();
}
 
class ProductA1 extends AbstractProductA{
 ProductA1(String arg){
  System.out.println("Hello "+arg);
 } // Implement the code here
 public void operationA1() { };
 public void operationA2() { };
}
 
class ProductA2 extends AbstractProductA{
 ProductA2(String arg){
  System.out.println("Hello "+arg);
 } // Implement the code here
 public void operationA1() { };
 public void operationA2() { };
}
 
abstract class AbstractProductB{
 //public abstract void operationB1();
 //public abstract void operationB2();
}
 
class ProductB1 extends AbstractProductB{
 ProductB1(String arg){
  System.out.println("Hello "+arg);
 } // Implement the code here
}
 
class ProductB2 extends AbstractProductB{
 ProductB2(String arg){
  System.out.println("Hello "+arg);
 } // Implement the code here
}
 
abstract class AbstractFactory{
 abstract AbstractProductA createProductA();
 abstract AbstractProductB createProductB();
}
 
class ConcreteFactory1 extends AbstractFactory{
 AbstractProductA createProductA(){
  return new ProductA1("ProductA1");
 }
 AbstractProductB createProductB(){
  return new ProductB1("ProductB1");
 }
}
 
class ConcreteFactory2 extends AbstractFactory{
 AbstractProductA createProductA(){
  return new ProductA2("ProductA2");
 }
 AbstractProductB createProductB(){
  return new ProductB2("ProductB2");
 }
}
 
//Factory creator - an indirect way of instantiating the factories
class FactoryMaker{
 private static AbstractFactory pf=null;
 static AbstractFactory getFactory(String choice){
  if(choice.equals("a")){
   pf=new ConcreteFactory1();
  }else if(choice.equals("b")){
    pf=new ConcreteFactory2();
   } return pf;
 }
}
 
// Client
public class Client{
 public static void main(String args[]){
  AbstractFactory pf=FactoryMaker.getFactory("a");
  AbstractProductA product=pf.createProductA();
  //more function calls on product
 }
}

Java Tutorials - SUN certifications & Job information

Downloads

Friday, 13 April 2012

AbstractFactory Design Pattern with an Example program

2 comments: