抽象工厂

一、模式定义

1、抽象产品类:ProductA,ProductB

 1 public abstract class ProductA {
 2 
 3     /**
 4      * 产品A的公共方法
 5      */
 6     public void shareMethod() {
 7         // 业务逻辑
 8     }
 9 
10     /**
11      * 产品A的抽象方法
12      */
13     public abstract void doSomething();
14 }
public abstract class ProductB {

    /**
     * 产品B的公共方法
     */
    public void shareMethod() {
        // 业务逻辑
    }

    /**
     * 产品B的抽象方法
     */
    public abstract void doSomething();
}

2、具体产品类：产品A的具体产品ProductA1，ProductA2；产品B的具体产品ProductB1，ProductB2

 1 public class ProductA1 extends ProductA {
 2 
 3     /**
 4      * 产品A的抽象方法实现
 5      */
 6     @Override
 7     public void doSomething() {
 8         System.out.println("my name is product_a_1");
 9     }
10 }
 1 public class ProductA2 extends ProductA {
 2 
 3     /**
 4      * 产品A的抽象方法实现
 5      */
 6     @Override
 7     public void doSomething() {
 8         System.out.println("my name is product_a_2");
 9     }
10 }
 1 public class ProductB1 extends ProductB {
 2 
 3     /**
 4      * 产品B的抽象方法实现
 5      */
 6     @Override
 7     public void doSomething() {
 8         System.out.println("my name is product_b_1");
 9     }
10 }
 1 public class ProductB2 extends ProductB {
 2 
 3     /**
 4      * 产品B的抽象方法实现
 5      */
 6     @Override
 7     public void doSomething() {
 8         System.out.println("my name is product_b_2");
 9     }
10 }

3、抽象工厂

 1 public abstract class AbstractFactory {
 2 
 3     /**
 4      * 创建A产品
 5      * @return
 6      */
 7     public abstract ProductA createProductA();
 8 
 9     /**
10      * 创建B产品
11      * @return
12      */
13     public abstract ProductB createProductB();
14 }

4、具体工厂：生产等级为1的AB产品工厂Factory1，等级为2的AB产品工厂Factory2

 1 public class Factory1 extends AbstractFactory {
 2 
 3     /**
 4      * 创建A1产品
 5      *
 6      * @return
 7      */
 8     @Override
 9     public ProductA createProductA() {
10         return new ProductA1();
11     }
12 
13     /**
14      * 创建B1产品
15      *
16      * @return
17      */
18     @Override
19     public ProductB createProductB() {
20         return new ProductB1();
21     }
22 }
 1 public class Factory2 extends AbstractFactory {
 2 
 3     /**
 4      * 创建A2产品
 5      *
 6      * @return
 7      */
 8     @Override
 9     public ProductA createProductA() {
10         return new ProductA2();
11     }
12 
13     /**
14      * 创建B2产品
15      *
16      * @return
17      */
18     @Override
19     public ProductB createProductB() {
20         return new ProductB2();
21     }
22 }

5、测试

 1 public class Main {
 2 
 3     public static void main(String[] args) {
 4         System.out.println("=========== factory_1 ===========");
 5         AbstractFactory factory1 = new Factory1();
 6         factory1.createProductA().doSomething();
 7         factory1.createProductB().doSomething();
 8         System.out.println("=========== factory_2 ===========");
 9         AbstractFactory factory2 = new Factory2();
10         factory2.createProductA().doSomething();
11         factory2.createProductB().doSomething();
12     }
13 }

结果：

=========== factory_1 ===========
my name is product_a_1
my name is product_b_1
=========== factory_2 ===========
my name is product_a_2
my name is product_b_2

 

posted @ 2020-10-13 18:00  西北-孤狼  阅读(80)  评论(0)    收藏  举报