AbstractFactory--抽象工厂模式java实现

1.原理

    1.1

 抽象工厂：多个抽象产品类，派生出多个具体产品类；一个抽象工厂类，派生出多个具体工厂类；每一个具体工厂类可建立多个具体产品类的实例。即提供一个建立一系列相关或相互依赖对象的接口，而无需指定他们的具体的类。“一对多”的关系

    1.2 UML图

    

2.AbstractFactory 接口，要生产各类产品的工厂在这里

package cn.xiaobo.AbstractFactory;
/**
 * 抽象的工厂
 * @author Administrator
 *
 */
public interface AbstractFactory {

    public ProductA factoryA();
    public ProductB factoryB();
}

3.抽象的A产品,包含了两个方法，方法视具体的业务而定

package cn.xiaobo.AbstractFactory;

/**
 * 抽象的A产品
 * @author Administrator
 *
 */
public interface ProductA {

    public void method1();
    public void method2();
}

4.抽象的B产品,包含了两个方法,方法视具体的业务而定

package cn.xiaobo.AbstractFactory;
/**
 * 抽象的B产品
 * @author Administrator
 *
 */
public interface ProductB {
    public void method1();
    public void method2();
}

5.实现A产品接口的具体的等级为1的A产品

package cn.xiaobo.AbstractFactory;

/**
 * 具体的等级为1的A产品
 * @author Administrator
 *
 */
public class ConcreateProductA1 implements ProductA{

    @Override
    public void method1() {
        System.out.println("生产1等级的A产品method1方法");
        
    }
    @Override
    public void method2() {
        System.out.println("生产1等级的A产品method2方法");
        
    }
}

6.实现A产品接口的具体的等级为2的A产品

package cn.xiaobo.AbstractFactory;

/**
 *  具体的等级为2的A产品
 * @author Administrator
 *
 */
public class ConcreateProductA2 implements ProductA{

    @Override
    public void method1() {
        System.out.println("生产2等级的A产品method1方法");
        
    }
    @Override
    public void method2() {
        System.out.println("生产2等级的A产品method2方法");
        
    }
}

7.实现B产品接口的具体的等级为1的B产品

package cn.xiaobo.AbstractFactory;

/**
 *  具体的等级为1的B产品
 * @author Administrator
 *
 */
public class ConcreateProductB1 implements ProductB{

    @Override
    public void method1() {
        System.out.println("生产1等级的B产品的method1");
        
    }
    @Override
    public void method2() {
        System.out.println("生产1等级的B产品的method2");
        
    }
}

8.实现B产品接口的具体的等级为2的B产品

package cn.xiaobo.AbstractFactory;

/**
 *  具体的等级为2的B产品
 * @author Administrator
 *
 */
public class ConcreateProductB2 implements ProductB{

    @Override
    public void method1() {
        System.out.println("生产2等级的B产品的method1");
        
    }
    @Override
    public void method2() {
        System.out.println("生产2等级的B产品的method2");
        
    }
}

9.实现抽象工厂接口的生产等级为1产品的工厂1

package cn.xiaobo.AbstractFactory;

/**
 * 生产产品等级为1的具体工厂
 * @author Administrator
 *
 */
public class ConcreateFactory1 implements AbstractFactory{

    @Override
    public ProductA factoryA() {
        // TODO Auto-generated method stub
        return  (ProductA) new ConcreateProductA1();
    }
    @Override
    public ProductB factoryB() {
        // TODO Auto-generated method stub
        return (ProductB) new ConcreateProductB1();
    }
}

10 实现抽象工厂接口的生产等级为2产品的工厂2

package cn.xiaobo.AbstractFactory;

/**
 * 生产产品等级为2的具体工厂
 * @author Administrator
 *
 */

public class ConcreateFactory2 implements AbstractFactory{

    @Override
    public ProductA factoryA() {
        // TODO Auto-generated method stub
        return (ProductA) new ConcreateProductA2();
    }
    @Override
    public ProductB factoryB() {
        // TODO Auto-generated method stub
        return (ProductB) new ConcreateProductB2();
    }
}

11.进行测试

package cn.xiaobo.AbstractFactory;

/**
 * 抽象工厂模式相对于工厂方法模式来讲，每一个具体工厂能够生产一族产品（即多种产品）；而工厂方法模式是具体工厂生产相应的具体产品，只能生产一种产品。
 * 当产品族中只有一种产品时抽象工厂模式退化成工厂方法模式。
 * @author Administrator
 *
 */
public class Customer {

    public static void main(String[] args) {
        ConcreateFactory1 concreateFactory1=new ConcreateFactory1();
        ConcreateFactory2 concreateFactory2=new ConcreateFactory2();
        
        concreateFactory1.factoryA().method1();
        concreateFactory1.factoryB().method1();
        
        concreateFactory2.factoryA().method1();
        concreateFactory2.factoryB().method1();
    }
}

12.结果

 生产1等级的A产品method1方法
生产1等级的B产品的method1
生产2等级的A产品method1方法
生产2等级的B产品的method1

13.优点与缺点

优势：

一、抽象工厂模式隔离了具体类的生产，使得客户并不须要知道什么被建立。

二、当一个产品族中的多个对象被设计成一块儿工做时，它能保证客户端始终只使用同一个产品族中的对象。

三、增长新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

缺点：

增长新的产品等级结构很复杂，须要修改抽象工厂和全部的具体工厂类，对“开闭原则”的支持呈现倾斜性。

14.参考博客

https://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html