读设计模式之禅--抽象工厂模式

• 定义：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类，
  如下：A产品包含两个尺寸（10X10 20X20） B产片包含两个尺寸(10X10 20X20) ，现在需要两个尺寸的工厂 工厂A生产10X10产品（包含A和B）B工厂生产20X20产品
  

/**
 * @auther hyh
 * @create 2021-08-10 19:18
 */
public abstract class AbstarctProductA {
    public void commonMethod(){
        System.out.println("A 产品公共方法");
    }

    public abstract void size();
}

/**
 * @auther hyh
 * @create 2021-08-10 19:24
 */
public abstract class AbstarctProductB {
    public void commonMethod(){
        System.out.println("B 产品公共方法");
    }

    public abstract void size();
}

/**
 * @auther hyh
 * @create 2021-08-10 19:21
 */
public class ProductA1 extends AbstarctProductA{
    @Override
    public void size() {
        System.out.println("10X10 尺寸产品");
    }
}

/**
 * @auther hyh
 * @create 2021-08-10 19:22
 */
public class ProductA2 extends AbstarctProductA{
    @Override
    public void size() {
        System.out.println("20X20 尺寸产品");
    }
}

/**
 * @auther hyh
 * @create 2021-08-10 19:25
 */
public class ProductB1 extends AbstarctProductB{
    @Override
    public void size() {
        System.out.println("B 产品 10X10 尺寸");
    }
}

/**
 * @auther hyh
 * @create 2021-08-10 19:25
 */
public class ProductB2 extends AbstarctProductB{
    @Override
    public void size() {
        System.out.println("B 产品 20X20 尺寸");
    }
}

/**
 * @auther hyh
 * @create 2021-08-10 19:27
 */
public abstract class AbstractFactory {

    public abstract AbstarctProductA createProductA();

    public abstract AbstarctProductB createProductB();
}

/**
 * @auther hyh
 * @create 2021-08-10 19:31
 */
public class Factory1 extends AbstractFactory{

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

    @Override
    public AbstarctProductB createProductB() {
        return new ProductB1();
    }
}

/**
 * @auther hyh
 * @create 2021-08-10 19:28
 */
public class Factory2 extends AbstractFactory{

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

    @Override
    public AbstarctProductB createProductB() {
        return new ProductB2();
    }
}
class Penple{

    public static void main(String[] args) {
        AbstractFactory factory2 = new Factory2();
        AbstractFactory factory1 = new Factory1();

        AbstarctProductA productA = factory1.createProductA();
        productA.commonMethod();
        productA.size();
        AbstarctProductB productB = factory1.createProductB();
        productB.commonMethod();
        productB.size();

        AbstarctProductA productA1 = factory2.createProductA();
        productA1.commonMethod();
        productA1.size();
        AbstarctProductB productB1 = factory2.createProductB();
        productB1.commonMethod();
        productB1.size();

    }
}
输出：
A 产品公共方法
10X10 尺寸产品
B 产品公共方法
B 产品 10X10 尺寸
A 产品公共方法
20X20 尺寸产品
B 产品公共方法
B 产品 20X20 尺寸

• 抽象工厂模式的使用场景定义非常简单：一个对象族（或是一组没有任何关系的对象）都有相同的约束，则可以使用抽象工厂模式。