设计模式--抽象工厂模式

抽象工厂模式

Java工程源码

类图

---

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

---

优缺点
- 优点：封装性，每个产品的实现类不是高层模块要关心的，它要关心的是接口或抽象类
- 缺点：产品族扩展非常困难，严重违反开闭原则

---

使用场景
- 一个对象族都有相同的约束

---

注意事项
- 抽象工厂模式，产品族扩展困难，但产品等级扩展却非常容易

---

下面我们新建2种产品AB，每种产品分为等级1和等级2
抽象产品类

public abstract class AbstractProduct {
    /**
     * 每个产品共有的方法
     */
    public void shareMethod() {
        System.out.println("每个产品共有的方法");
    }
}

抽象产品类A

public abstract class AbstractProductA extends AbstractProduct {
    /**
     * 每个产品相同方法，实现不同
     */
    public abstract void doSomething();
}

抽象产品类B

public abstract class AbstractProductB extends AbstractProduct {
    /**
     * 每个产品相同方法，实现不同
     */
    public abstract void doSomething();
}

抽象工厂类

public abstract class AbstractCreator {
    /**
     * 创建A产品家族
     *
     * @return A产品家族
     */
    public abstract AbstractProductA createProductA();

    /**
     * 创建B产品家族
     *
     * @return B产品家族
     */
    public abstract AbstractProductB createProductB();
}

产品A等级1的实现类

public class ProductA1 extends AbstractProductA {
    public void doSomething() {
        System.out.println("产品A1的实现方法");
    }
}

产品A等级2的实现类

public class ProductA2 extends AbstractProductA {
    public void doSomething() {
        System.out.println("产品A2的实现方法");
    }
}

产品B等级1的实现类

public class ProductB1 extends AbstractProductB {
    public void doSomething() {
        System.out.println("产品B1的实现方法");
    }
}

产品B等级2的实现类

public class ProductB2 extends AbstractProductB {
    public void doSomething() {
        System.out.println("产品B2的实现方法");
    }
}

产品等级1的实体工厂类

public class Creator1 extends AbstractCreator {
    public Creator1() {
        System.out.println("工厂1创建");
    }

    // 只生产产品等级为1的A类产品
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    // 只生产产品等级为1的B类产品
    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

产品等级2的实体工厂类

public class Creator2 extends AbstractCreator {
    public Creator2() {
        System.out.println("工厂2创建");
    }

    // 只生产产品等级为2的A类产品
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    // 只生产产品等级为2的B类产品
    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

场景类

public class Client {
    public static void main(String[] args) {
        // 定义两个工厂
        AbstractCreator creator1 = new Creator1();
        AbstractCreator creator2 = new Creator2();
        //工厂生产产品
        AbstractProductA a1 = creator1.createProductA();
        AbstractProductA a2 = creator2.createProductA();
        AbstractProductB b1 = creator1.createProductB();
        AbstractProductB b2 = creator2.createProductB();
        a1.doSomething();
        a2.doSomething();
        b1.doSomething();
        b2.doSomething();

        b1.shareMethod();
    }
}

运行结果

工厂1创建
工厂2创建
产品A1的实现方法
产品A2的实现方法
产品B1的实现方法
产品B2的实现方法
每个产品共有的方法