设计模式学习笔记（二、创建型-工厂模式）

目录：

• 什么是工厂模式
• 为什么要有工厂模式
• 如何实现一个工厂模式

什么是工厂模式

工厂模式实际上就是封装了创建对象细节，将创建对象的细节与实际业务分离，达到解耦的目的。

为什么要有工厂模式

1、封装变化：创建逻辑有可能变化，封装成工厂类之后，创建逻辑的变更对调用者透明。

2、代码复用：创建代码抽离到独立的工厂类之后可以复用。

3、隔离复杂性：封装复杂的创建逻辑，调用者无需了解如何创建对象。

4、控制复杂度：将创建代码抽离出来，让原本的函数或类职责更单一，代码更简洁。

如何实现一个工厂模式

工厂模式有两类，工厂方法和抽象工厂。

1、工厂模式-简单工厂：

public interface IFruit {

    /**
     * 获取自身颜色
     *
     * @return 颜色
     */
    String getColor();
}

public class Apple implements IFruit {

    @Override
    public String getColor() {
        return "red";
    }
}

public class Banana implements IFruit {

    @Override
    public String getColor() {
        return "yellow";
    }
}

public class FruitFactory {

    public static IFruit createFruit(String category) {
        if ("apple".equals(category)) {
            return new Apple();
        } else if ("banana".equals(category)) {
            return new Banana();
        }

        throw new RuntimeException("exception");
    }
}

public class Demo1Test {

    public static void main(String[] args) {
        IFruit apple = FruitFactory.createFruit("apple");
        System.err.println(apple.getColor());

        IFruit banana = FruitFactory.createFruit("banana");
        System.err.println(banana.getColor());
    }
}

2、工厂模式-工厂方法：

简单工厂模式在每次新增一个水果时都需要改动工厂类，这有违反开闭原则；而工厂方法则是在不违反开闭原则的情况下创建对象。

public interface IFruitFactory {

    /**
     * 创建水果
     *
     * @return 水果
     */
    IFruit createFruit();
}

public class AppleFactory implements IFruitFactory {

    @Override
    public IFruit createFruit() {
        return new Apple();
    }
}

public class BananaFactory implements IFruitFactory {

    @Override
    public IFruit createFruit() {
        return new Banana();
    }
}

public class FruitFactoryMap {

    /**
     * 利用map优化createFruitFactory函数
     */
    private static final Map<String, IFruitFactory> FRUIT_MAP = new HashMap<>();

    static {
        FRUIT_MAP.put("apple", new AppleFactory());
        FRUIT_MAP.put("banana", new BananaFactory());
    }

    public static IFruitFactory createFruitFactory(String category) {
        if (category == null || category.isEmpty()) {
            throw new RuntimeException("exception");
        }

        return FRUIT_MAP.get(category);
    }
}

public class Demo2Test {

    public static void main(String[] args) {
        IFruitFactory appleFactory = FruitFactoryMap.createFruitFactory("apple");
        IFruit apple = appleFactory.createFruit();
        System.err.println(apple.getColor());

        IFruitFactory bananaFactory = FruitFactoryMap.createFruitFactory("banana");
        IFruit banana = bananaFactory.createFruit();
        System.err.println(banana.getColor());
    }
}

你可能会说这步更麻烦了嘛，的确在创建对象的逻辑仅仅只是new的话使用工厂方法确实麻烦了些。

正因这样才有了简单工厂存在的意义，简单工厂主要应用创建对象时过程简单，无复杂逻辑时使用。

而工厂方法则适用于创建对象时需要有特殊处理，或者说需要依赖其他外部信息。

3、抽象工厂：抽象工厂和工厂方法一样，只不过它拥有了创建多个工厂的能力，这里就不再赘述。