Patron de Diseño Abstract Factory

Provee una interfaz para crear objetos sin especificar sus clases concretas
Este patrón de diseño se utiliza muy frecuentemente

Las clases y/u objetos que participan en este patron son los siguientes:

• AbstractFactory
• Declara una interfaz para operaciones que crean productos abstractos
• ConcreteFactory
• Implementan las operaciones para crear los objetos de productos concretos
• AbstractProduct
• Declara una interfaz para un tipo de objeto producto
• Product
• Define un objeto producto para ser creado por el correspondiente concrete factory
• Implementa la interfaz AbstractProduct
• Client
• Usa la interfaz declara por las clases AbstractFactory y AbstractProduct

Puedes bajar el ejemplo y probarlo en tu pc. Fue desarrollado en Eclipse con Java 1.6SE
[descargar]

Este es el codigo:

public abstract class AbstractFactory{
public abstract AbstractProductA CreateProductA();
public abstract AbstractProductB CreateProductB();

}

public class ConcreteFactory1 extends AbstractFactory
{
public AbstractProductA CreateProductA()
{
return new ProductA1();
}
public AbstractProductB CreateProductB()
{
return new ProductB1();
}
}


class ConcreteFactory2 extends AbstractFactory
{
public AbstractProductA CreateProductA()
{
return new ProductA2();
}
public AbstractProductB CreateProductB()
{
return new ProductB2();
}
}

public abstract class AbstractProductA {

}


abstract class AbstractProductB{
public abstract void Interact(AbstractProductA a);

}

class ProductA1 extends AbstractProductA
{
}

public class ProductB1 extends AbstractProductB
{
public void Interact(AbstractProductA a)
{
System.out.println(this.getClass().toString() + " interactua con " + a.getClass().toString());
}
}

public class ProductA2 extends AbstractProductA
{
}

public class ProductB2 extends AbstractProductB{

@Override
public void Interact(AbstractProductA a) {
System.out.println(this.getClass().toString() + " interactua con " + a.getClass().toString());
}

}

public class Client {


private AbstractProductA abstractProductA;
private AbstractProductB abstractProductB;

// Constructor
public Client(AbstractFactory factory)
{
abstractProductB = factory.CreateProductB();
abstractProductA = factory.CreateProductA();
}

public void Run()
{
abstractProductB.Interact(abstractProductA);
}


}

public class Main {

/**
* @param args
*/
public static void main(String[] args) {
// Abstract factory #1
AbstractFactory factory1 = new ConcreteFactory1();
Client c1 = new Client(factory1);
c1.Run();

// Abstract factory #2
AbstractFactory factory2 = new ConcreteFactory2();
Client c2 = new Client(factory2);
c2.Run();
}

}


Este patrón de diseño es muy usado en aplicaciones web, dando muy buenos resultados cuando se separan sistemas.

Suerte