工厂模式

1. 简单工厂模式

定义：简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例，但它不属于 GOF，23 种设计模式。

场景：简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。

举个例子：


/**
 * 图书的接口类
 */
public interface IBook {
    public void see();
}

public static class BookA implements IBook {

    @Override
    public void see() {
        System.out.println("观看书~~~~ BookA");
    }
}

public static class BookB implements IBook {

    @Override
    public void see() {
        System.out.println("观看书~~~~ BookB");
    }
}

/**
 * 简单工厂
 */
public static class SimpleFactory {
    public static IBook create(String name) {
        switch (name) {
            case "A":
                return new BookA();
            case "B":
                return new BookB();
            default:
                throw new NullPointerException();
        }
    }
}

public static void main(String[] args) {
    // 创建IBook对象解耦--不关注如何创建的
    SimpleFactory.create("A").see();
    SimpleFactory.create("B").see();
}

// 上面的简单工厂在每次新增图书后都需要手动修改代码。不符合开闭原则。
// 我们对上面的代码进行升级，使用className加载

public static IBook create(String className) {
    try {
        return (IBook) Class.forName(className).newInstance();
    } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
        e.printStackTrace();
    }
    throw new NullPointerException();
}

public static void main(String[] args) {
    // 创建IBook对象解耦--不关注如何创建的
    // 我测试的时候使用的是内部类因此为 $
    SimpleFactory.create("com.reape.design.pattern.factory.SimpleFactoryPattern$BookA").see();
    SimpleFactory.create("com.reape.design.pattern.factory.SimpleFactoryPattern$BookB").see();
}

// 使用className加载，传入的字符串很长，且还需要强制转换还可以提升
// 使用 Class 加载

public static IBook create(Class<? extends IBook> clazz) {
    try {
        return clazz.newInstance();
    } catch (InstantiationException | IllegalAccessException e) {
        e.printStackTrace();
    }
    throw new NullPointerException();
}

public static void main(String[] args) {
    // 创建IBook对象解耦--不关注如何创建的
    SimpleFactory.create(BookA.class).see();
    SimpleFactory.create(BookB.class).see();
}

简单工厂的优点：解耦使用者和对个实例对象。

简单工厂的缺点：工厂类的职责相对过重，不易于扩展过于复杂的产品结构。

2. 工厂方法模式

定义：工厂方法模式（Fatory Method Pattern）是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。在工厂方法模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符合开闭原则。

场景：工厂方法适用于以下场景：

创建对象需要大量重复的代码。
客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
一个类通过其子类来指定创建哪个对象。


/**
 * 图书的接口类
 */
public interface IBook {
    public void see();
}

public static class BookA implements IBook {

    @Override
    public void see() {
        System.out.println("观看书~~~~ BookA");
    }
}

public static class BookB implements IBook {

    @Override
    public void see() {
        System.out.println("观看书~~~~ BookB");
    }
}

public interface IFactory {
    public IBook create();
}

/**
 * 简单工厂
 */
public static class AFactory implements IFactory {
    @Override
    public IBook create() {
        return new BookA();
    }
}

public static class BFactory implements IFactory {
    @Override
    public IBook create() {
        return new BookB();
    }
}

public static void main(String[] args) {
    // 创建IBook对象解耦--不关注如何创建的
    new AFactory().create().see();
    new BFactory().create().see();
}

工厂方法的优点：解耦使用者和对个实例对象。

工厂方法的缺点：1、类的个数容易过多，增加复杂度。 2、增加了系统的抽象性和理解难度。

3. 抽象工厂模式

定义：抽象工厂模式（Abstract Factory Pattern）是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类。客户端（应用层）不依赖于产品类实例如何被创建、实现等细节，强调的是一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

场景：抽象工厂模式适用于以下场景：创建对象需要同时创建其他有关的对象。

举个例子：

public interface IBook {
    public void see();
}

public interface INote {
    public void see();
}

public static class ABook implements IBook {

    @Override
    public void see() {
        System.out.println("阅读了 A 书");
    }
}

public static class BBook implements IBook {

    @Override
    public void see() {
        System.out.println("阅读了 B 书");
    }
}

public static class ANote implements INote {

    @Override
    public void see() {
        System.out.println("阅读了 A 笔记");
    }
}

public static class BNote implements INote {

    @Override
    public void see() {
        System.out.println("阅读了 B 笔记");
    }
}


public interface IAbstractFactory {
    IBook createBook();
    INote createNote();
}

public static class AAbstractFactory implements IAbstractFactory {

    @Override
    public IBook createBook() {
        return new ABook();
    }

    @Override
    public INote createNote() {
        return new ANote();
    }
}

public static class BAbstractFactory implements IAbstractFactory {

    @Override
    public IBook createBook() {
        return new BBook();
    }

    @Override
    public INote createNote() {
        return new BNote();
    }
}


public static void main(String[] args) {
    // 创建IBook对象解耦--不关注如何创建的
    IAbstractFactory abstractFactory = new AAbstractFactory();
    abstractFactory.createBook().see();
    abstractFactory.createNote().see();
    abstractFactory = new BAbstractFactory();
    abstractFactory.createBook().see();
    abstractFactory.createNote().see();
}

抽象工厂非常完美清晰地描述这样一层复杂的关系。但是，如果我们再继续扩展产品等级，将练习题 也加入到A课程中，那么我们的代码从抽象工厂，到具体工厂要全部调整，很显然不符合开闭原则。

因此抽象工厂也是有缺点的：

规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口。
增加了系统的抽象性和理解难度。

设计模式 ---> 工厂实战

待续...

RE|GoF的23种设计模式-2

工厂模式

1. 简单工厂模式

2. 工厂方法模式

3. 抽象工厂模式