1.概念

提供一个创建一系列相关或者相互依赖对象的接口，无需指定具体的类

2. 案例（我们这里创建的对象，ProductA1与ProductB1对象是关联的）

1.抽象工厂

package com.yl.design;
// 抽象工厂
public interface AbstractFactory {
    public AbstractProductA createAbstractProductA();
    public AbstractProductB createAbstractProductB();
}

2.产品A的接口以及其实现类

package com.yl.design;
// 抽象产品A的接口
public interface AbstractProductA {
    public void display();
}

package com.yl.design;
//产品A的具体实现
public class ProductA1 implements AbstractProductA {
    @Override
    public void display() {
        System.out.println("display: ProductA1");
    }
}

package com.yl.design;
//产品A的具体实现
public class ProductA2 implements AbstractProductA {
    @Override
    public void display() {
        System.out.println("display: ProductA2");
    }
}

3.产品B的接口以及其实现类

package com.yl.design;
//抽象产品B的接口
public interface AbstractProductB {
    public void display();
}

package com.yl.design;
//产品B的具体实现
public class ProductB1 implements AbstractProductB {
    @Override
    public void display() {
        System.out.println("display: ProductB1");
    }
}

package com.yl.design;
//产品B的具体实现
public class ProductB2 implements AbstractProductB {
    @Override
    public void display() {
        System.out.println("display: ProductB2");
    }
}

4.两个具体的工厂实现类

package com.yl.design;
//具体的工厂实现类
public class ConCreateFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createAbstractProductA() {
        return new ProductA1();
    }
    @Override
    public AbstractProductB createAbstractProductB() {
        return new ProductB1();
    }
}

package com.yl.design;
//具体的工厂实现类
public class ConCreateFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createAbstractProductA() {
        return new ProductA2();
    }
    @Override
    public AbstractProductB createAbstractProductB() {
        return new ProductB2();
    }
}

5.测试

package com.yl.design;
public class Test {
    public static void main(String[] args) {
        //创建抽象工厂对象
        AbstractFactory abstractFactory = new ConCreateFactory1();
        //通过工厂来创建一系列对象
        AbstractProductA productA = abstractFactory.createAbstractProductA();
        AbstractProductB productB = abstractFactory.createAbstractProductB();
        productA.display();
        productB.display();
    }
}