设计模式-抽象工厂模式

  • 定义

    为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类

    我们知道工厂常常会生产多个产品，而这些产品又有一定的关联性和相互的影响，比如杯子 和杯盖 组成了一个杯子，杯子和杯盖又有不同的颜色，这时候就可以使用抽象工厂方式

  • 代码

    定义抽象产品A和抽象产品B

    1
    2
    3
    4
    5
    public abstract class AbstractProductA {

        public abstract void  say();

    }
    1
    2
    3
    4
    5
    public abstract class AbstractProductB {

        public abstract void say();

    }

    抽象产品A 和抽象产品B 的实现类，产品A和B 分别有对应的两个系列

    1
    2
    3
    4
    5
    6
    public class ProductA1 extends AbstractProductA {
        @Override
        public void say() {
            System.out.println("product A1");
        }
    }
    1
    2
    3
    4
    5
    6
    public class ProductA2 extends AbstractProductA {
        @Override
        public void say() {
            System.out.println("product A2");
        }
    }
    1
    2
    3
    4
    5
    6
    7
    public class ProductB1 extends AbstractProductB {

        @Override
        public void say() {
            System.out.println("product B1");
        }
    }
    1
    2
    3
    4
    5
    6
    public class ProductB2 extends AbstractProductB {
        @Override
        public void say() {
            System.out.println("product B2");
        }
    }

    定义一个抽象的工厂，生产A和B

    1
    2
    3
    4
    public abstract class AbstractProductFactory {
        public abstract AbstractProductA createProductA();
        public abstract AbstractProductB createProductB();
    }

    产品系列的工厂实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class Product1Factory extends AbstractProductFactory {

        @Override
        public AbstractProductA createProductA() {
            return new ProductA1();
        }

        @Override
        public AbstractProductB createProductB() {
            return new ProductB1();
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class Product2Factory extends AbstractProductFactory {

        @Override
        public AbstractProductA createProductA() {
            return new ProductA2();
        }

        @Override
        public AbstractProductB createProductB() {
            return new ProductB2();
        }
    }

    产品1和产品2工厂都生产产品A和B，但是生产的该系列的产品

    下面测试:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @Test
       public void testAbstractFactory(){
           AbstractProductFactory f1 = new Product1Factory();
           AbstractProductFactory f2 = new Product2Factory();
           AbstractProductA a1 =  f1.createProductA();
           AbstractProductB b1 =  f1.createProductB();
           AbstractProductA a2 =  f2.createProductA();
           AbstractProductB b2 =  f2.createProductB();
           a1.say();
           a2.say();
           b1.say();
           b2.say();
       }

输出：

product A1
product A2
product B1
product B2

从测试可以看出，在生产产品的时候并没有用到具体的产品实现类，只要知道改系列的工厂就能生产不同的系列的产品，并不关心具体的实现类