《Java与模式》学习笔记之五――抽象工厂模式（Abstract Factory Pattern）

问题:
        当系统要创建一组相关或者相互依赖的对象时, 请使用抽象工厂模式.
        抽象工厂模式可以向客户端提供一个接口, 使得客户端可以在不必指定产品的具体类型的情况下, 创建多个产品族中的产品对象. 这就是抽象工厂的用意.
类图:

 

源代码:
package com.designpatterns.AbstractFactory;
/**
 * 抽象工厂
 */
public interface AbstractFactory {
     public AbstractProductA CreateProductA();
     public AbstractProductB CreateProductB();
}

public interface AbstractProductA {
     public void Operation();
}

public interface AbstractProductB {
     public void Operation();
}

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

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

public class ProductA1 implements AbstractProductA {
        public ProductA1()
        {
                  System.out.println("ProductA1...");
        }
 
        public void Operation() {} 
}

public class ProductA2 implements AbstractProductA {
        public ProductA2()
        {
                    System.out.println("ProductA2...");
        }
 
        public void Operation() {} 
}

public class ProductB1 implements AbstractProductB {
        public ProductB1()
        {
                  System.out.println("ProductB1...");
        }
 
        public void Operation() {} 
}

public class ProductB2 implements AbstractProductB {
         public ProductB2()
         {
                System.out.println("ProductB2...");
         }
         public void Operation() {} 
}

/**
 * 客户端类
 */
public class Client {
         public static void main(String[] args) {
                  AbstractFactory af1 = new ConcreteFactory1();
                  af1.CreateProductA();
                  af1.CreateProductB();

                  AbstractFactory af2 = new ConcreteFactory2();
                  af2.CreateProductA();
                  af2.CreateProductB();
 } 
}

讨论:
    AbstractFactory模式是为创建一组(有多类)相关或依赖的对象提供创建接口, 而Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现. AbstractFactory模式通常都是使用Factory模式实现, 如上例所示.