抽象工厂模式

一、定义

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

1. 优点：封装性，每个产品的实现类不是高层模块要关心的，只要知道工厂类是谁，就能创建出一个需要的对象。产品族内的约束为非公开状态。
2. 缺点：产品族扩展非常困难，如果要增加一个产品C，也就是说产品家族由原来的2个增加到3个，抽象类AbstractFactory要增加一个方法createProductC()，然后它的所有实现类都要修改，这严重违反了开闭原则。

二、实现

public class Client {
    public static void main(String[] args) {
        //定义出两个工厂
        AbstractFactory factory1 = new Factory1();
        AbstractFactory factory2 = new Factory2();
        //产生A1对象
        AbstractProductA a1 =  factory1.createProductA();
        //产生A2对象
        AbstractProductA a2 = factory2.createProductA();
        //产生B1对象
        AbstractProductB b1 = factory1.createProductB();
        //产生B2对象
        AbstractProductB b2 = factory2.createProductB();
    }
}

//A类产品
abstract class AbstractProductA {
    //每个产品共有的方法
    public void shareMethod() {
    }

    //每个产品相同方法，不同实现
    public abstract void doSomething();
}

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

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

//B类产品
abstract class AbstractProductB {
    //每个产品共有的方法
    public void shareMethod() {
    }

    //每个产品相同方法，不同实现
    public abstract void doSomething();
}

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

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

abstract class AbstractFactory {
    //创建A产品家族
    public abstract AbstractProductA createProductA();

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

//等级为1的产品工厂
class Factory1 extends AbstractFactory {
    //只生产产品等级为1的A产品
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

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

//等级为2的产品工厂
class Factory2 extends AbstractFactory {
    //只生产产品等级为2的A产品
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

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