设计模式4 - 工厂模式

工厂即把创建对象的逻辑封装起来供其他地方直接调用。
按不同的实现方式，工厂模式又分为简单工厂、工厂模式、抽象工厂模式3种。
我们这里把创建的对象暂且叫作产品。

简单工厂

定义：
只有一个工厂，一个产品接口/抽象类，工厂类创建所有产品。

组成：
SimpleFactory：唯一的一个工厂类，创建所有产品
AbstractProductor：抽象产品类（1个）
ConcreteProductor：具体产品类（多个），实现抽象产品类

示例：

(Fridge.java)
public abstract class Fridge {

    public abstract void desc();
}

(HaierFridge.java)
public class HaierFridge extends Fridge{
    @Override
    public void desc() {
        System.out.println("海尔冰箱");
    }
}

(SiemensFridge.java)
public class SiemensFridge extends Fridge{
    @Override
    public void desc() {
        System.out.println("西门子冰箱");
    }
}

(FridgeSimpleFactory.java)
public class FridgeSimpleFactory {
    public Fridge createFridge(String type) {
        Fridge fridge = null;
        if ("haier".equals(type)) {
            fridge = new HaierFridge();
        } else if ("sie".equals(type)) {
            fridge = new SiemensFridge();
        } else {
            throw new RuntimeException("invalid type: " + type);
        }
        return fridge;
    }
}

(Test.java)
public class Test {
    public static void main(String[] args) {
        // simple factory
        FridgeSimpleFactory simpleFactory = new FridgeSimpleFactory();
        simpleFactory.createFridge("haier").desc();
        simpleFactory.createFridge("sie").desc();
    }
}

工厂模式

定义：
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

组成：
AbstractFactory：抽象工厂类（1个），定义一个创建对象的方法
ConcreteFactory：具体工厂类（多个），实现抽象工厂类，和抽象产品类一一对应，生产某种产品
AbstractProductor：抽象产品类（1个）
ConcreteProductor：具体产品类（多个），实现抽象产品类
一个产品接口/抽象类，根据继承抽象工厂中的方法来多态创建具体产品对象。适用于一个类型的多个产品。

类图：

 

示例：

(Fridge.java)
public abstract class Fridge {

    public abstract void desc();
}

(HaierFridge.java)
public class HaierFridge extends Fridge{
    @Override
    public void desc() {
        System.out.println("海尔冰箱");
    }
}

(SiemensFridge.java)
public class SiemensFridge extends Fridge{
    @Override
    public void desc() {
        System.out.println("西门子冰箱");
    }
}

(FridgeFactory.java)
public interface FridgeFactory {
    Fridge createFridge();
}

(HaierFridgeFactory.java)
public class HaierFridgeFactory implements FridgeFactory{
    @Override
    public Fridge createFridge() {
        return new HaierFridge();
    }
}

(SiemensFridgeFactory.java)
public class SiemensFridgeFactory implements FridgeFactory{
    @Override
    public Fridge createFridge() {
        return new SiemensFridge();
    }
}

(Test.java)
public class Test {
    public static void main(String[] args) {
        // factory
        FridgeFactory factory1 = new HaierFridgeFactory();
        factory1.createFridge().desc();
        FridgeFactory factory2 = new SiemensFridgeFactory();
        factory2.createFridge().desc();
    }
}

抽象工厂模式

定义：
抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
也就是说，抽象工厂的任务是定义一个负责创建一组产品（一个家族）的接口，这个接口内的每个方法都负责创建一个具体的产品，同时我们利用实现抽象工厂的子类来提供这些具体的做法。
其实抽象工厂是为了减少工厂方法中的工厂类数量，基于此提出的设计模式（因为当产品种类一多，就会导致有非常多的工厂类，这时如果能将产品划分成产品族，每个工厂都能产生所有类型的产品，但属于同一个族，则可以大大减少工厂类数目，举个例子：你的工厂提供的能力非常多，可以生产冰箱、电视、空调、洗衣机、电脑以及桌子等等，这样你就会产生很多的工厂，每个工厂产生一种产品。抽象工厂的作用就是在一定前提下，帮你分类这些工厂，比如按品牌分类，每个品牌工厂可以产生上面的所有产品，这样会大大缩减系统中的工厂数量。）。
但是扩展就非常麻烦了，假如增加一个产品，则所有工厂类都要受影响。相比工厂模式，这是提供了一个超级大的接口。

组成：
AbstractFactory：抽象工厂类（1个），定义一组创建对象的方法，每个方法都创建一种不同类型的对象，不同类型的对象形成一个对象家族。
ConcreteFactory：具体工厂类（多个），实现抽象工厂类的所有方法
AbstractProductor：抽象产品类（多个），不同类型的产品有不同的抽象产品类
ConcreteProductor：具体产品类（多个），实现某种抽象产品类
多个产品接口/抽象类，对产品子类进行分组，根据继承抽象工厂中的方法多态创建同组的不同具体产品对象。适用于多个类型的多个产品

类图：

 即假设有Product1和Product2两种产品类型，被划分为家族A和B，A和B都能生产产品1和2。

示例：

// 产品有冰箱和空调，按品牌划分为家族：海尔和西门子
(Fridge.java)
public abstract class Fridge {

    public abstract void desc();
}

(HaierFridge.java)
public class HaierFridge extends Fridge{
    @Override
    public void desc() {
        System.out.println("海尔冰箱");
    }
}

(SiemensFridge.java)
public class SiemensFridge extends Fridge{
    @Override
    public void desc() {
        System.out.println("西门子冰箱");
    }
}

(AirConditioner.java)
public abstract class AirConditioner {
    public abstract void desc();
}

(HaierAC.java)
public class HaierAC extends AirConditioner{
    @Override
    public void desc() {
        System.out.println("海尔空调");
    }
}

(SiemensAC.java)
public class SiemensAC extends AirConditioner{
    @Override
    public void desc() {
        System.out.println("西门子空调");
    }
}

public interface AbstractHomeAppliancesFactory {
    Fridge createFridge();
    AirConditioner createAC();
}

public class HaierHomeAppliancesFactory implements AbstractHomeAppliancesFactory{
    @Override
    public Fridge createFridge() {
        return new HaierFridge();
    }

    @Override
    public AirConditioner createAC() {
        return new HaierAC();
    }
}

public class SiemensHomeAppliancesFactory implements AbstractHomeAppliancesFactory{
    @Override
    public Fridge createFridge() {
        return new SiemensFridge();
    }

    @Override
    public AirConditioner createAC() {
        return new SiemensAC();
    }
}

(Test.java)
public class Test {
    public static void main(String[] args) {
        //abstract factory
        AbstractHomeAppliancesFactory abfactory1 = new HaierHomeAppliancesFactory();
        abfactory1.createFridge().desc();
        abfactory1.createAC().desc();
        AbstractHomeAppliancesFactory abfactory2 = new SiemensHomeAppliancesFactory();
        abfactory2.createFridge().desc();
        abfactory2.createAC().desc();
    }
}