一、简单工厂模式

（一）、简单工厂的概念

​ 简单工厂模式是指由一个工厂对象决定创建出哪一种产品类的实例，但它不属于GOF23种设计模式。简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。

（二）、无使用简单工厂模式的代码案例

​ 1、课本接口：Book

java">public interface Book {
    public void readBook();
}

​ 2、Java书籍类：javaBook

java">public class JavaBook implements Book{
    @Override
    public void readBook() {
        System.out.println("阅读Java类书本");
    }
}

​ 3、调用代码：

java">public class SimpleFactoryTest {
    public static void main(String[] args) {
        Book javaBook = new JavaBook();
        javaBook.readBook();
    }
}

（三）、使用简单工厂模式的代码案例——字符串参数

​ 上述例子中提及的课本类接口、Java书籍类不改变。

​ 1、增加Python类书籍：PythonBook

java">public class PythonBook implements Book{
    @Override
    public void readBook() {
        System.out.println("阅读Python类书籍");
    }
}

​ 2、书籍工厂类：BookFactory

java">class BookFactory {
    // 利用字符串
    Book createBook(String name) {
        if ("Java".equals(name)) {
            return new JavaBook();
        } else if ("Python".equals(name)) {
            return new PythonBook();
        } else {
            return null;
        }
    }
}

​ 3、调用代码：

java">public class SimpleFactoryTest {
    public static void main(String[] args) {
        BookFactory bookFactory = new BookFactory();
        // 使用字符串
        Book book = bookFactory.createBook("Java").showBook();
    }
}

（四）、使用简单工厂模式的代码案例——类名（使用反射）

​ 1、改写书籍工厂：BookFactory

java">class BookFactory {
    // 利用反射——通过类名
    public Book createBook(String className) {
        if (!(null == className || "".equals(className))) {
            try {
                return (Book) Class.forName(className).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

​ 2、调用代码：

java">public class SimpleFactoryTest {
    public static void main(String[] args) {
        BookFactory bookFactory = new BookFactory();
        // 使用反射——类名
        Book book = bookFactory.createBook("com.company.simpleFactory.JavaBook");
    }
}

（五）、使用简单工厂模式的代码案例——类

​ 1、改写书籍工厂：BookFactory

java">class BookFactory {
    // 利用反射——通过类
    public Book createBook(Class<? extends Book> clazz) {
        if (null != clazz) {
            try {
                return clazz.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

​ 2、调用代码：

java">public class SimpleFactoryTest {
    public static void main(String[] args) {
        BookFactory bookFactory = new BookFactory();
        // 使用反射——类
        Book book = bookFactory.createBook(JavaBook.class);
        book.readBook();
    }
}

（六）、类图

二、工厂方法模式

（一）、工厂方法的概念

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

​ 工厂方法模式主要解决产品扩展的问题，在简单工厂中随着产品链的丰富，如果每个课程的创建逻辑有区别的话，工厂的职责会变得越来越多，如同万能工厂，不利于维护。根据单一职责原则可将职能继续拆分，专人干专事。Java类书籍需要由Java工厂创建，Python类书籍需要由Python工厂创建，对工厂本身也需要做一个抽象。

（二）、使用工厂方法模式的代码案例

​ 在简单工厂模式的基础上进行修改与增加

​ 1、修改书籍工厂类为书籍工厂接口：BookFactory

java">public interface BookFactory {
    Book create();
}

​ 2、增加Java类书籍工厂：JavaBookFactory

java">public class JavaBookFactory implements BookFactory{
    @Override
    public Book create() {
        return new JavaBook();
    }
}

​ 3、增加Python类书籍工厂：PythonBookFactory

java">public class PythonBookFactory implements BookFactory {
    @Override
    public Book create() {
        return new PythonBook();
    }
}

​ 4、调用代码：

java">public class FactoryMethodTest {
    public static void main(String[] args) {
        // 分别创建Java类书籍工厂与Python类书籍工厂
        BookFactory javaFactory = new JavaBookFactory();
        BookFactory pythonFactory = new PythonBookFactory();
        // 创建Java书籍类与Python书籍类
        Book javaBook = javaFactory.create();
        Book pythonBook = pythonFactory.create();
        // 调用方法
        javaBook.readBook();
        pythonBook.readBook();
    }
}

（三）、工厂方法模式的适用场景与缺点

1、工厂方法模式的适用场景

（1）、创建对象需要大量重复的代码

（2）、客户端（应用层）不依赖于产品类实例如何被创建、实现等细节

（3）、一个类通过子类来指定创建哪个对象

2、工厂方法模式的缺点

（1）、类的个数过多，增加复杂度

（2）、增加了系统的抽象性和理解难度

（四）、类图

三、抽象工厂模式

（一）、抽象工厂的概念

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

（二）、使用抽象工厂模式的代码案例

​ 1、创建知识工厂：KnowledgeFactory

java">public abstract class KnowledgeFactory {
    void init() {
        System.out.println("初始化数据");
    }

    protected abstract Book createBook();

    protected abstract Video createVideo();
}

​ 2、创建Java类知识工厂：JavaKnowledgeFactory

java">public class JavaKnowledgeFactory extends KnowledgeFactory{
    @Override
    protected Book createBook() {
        super.init();
        return new JavaBook();
    }

    @Override
    protected Video createVideo() {
        super.init();
        return new JavaVideo();
    }
}

​ 3、创建Python类知识工厂：PhthonKnowledgeFactory

java">public class PythonKnowledgeFactory extends KnowledgeFactory{
    @Override
    protected Book createBook() {
        super.init();
        return new PythonBook();
    }

    @Override
    protected Video createVideo() {
        super.init();
        return new PythonVideo();
    }
}

​ 4、创建图书类接口：Book

java">public interface Book {
    void readBook();
}

​ 5、创建视频类接口：Video

java">public interface Video {
    void watchVideo();
}

​ 6、创建Java图书类：JavaBook

java">public class JavaBook implements Book {
    @Override
    public void readBook() {
        System.out.println("阅读Java类书本");
    }
}

​ 7、创建Java视频类：JavaVideo

java">public class JavaVideo implements Video{
    @Override
    public void watchVideo() {
        System.out.println("观看Java类视频");
    }
}

​ 8、创建Python图书类：PythonBook

java">public class PythonBook implements Book {
    @Override
    public void readBook() {
        System.out.println("阅读Python类书籍");
    }
}

​ 9、创建Python视频类：PythonVideo

java">public class PythonVideo implements Video{
    @Override
    public void watchVideo() {
        System.out.println("观看Python类视频");
    }
}

​

​ 10、调用代码：

java">public class AbstractFactoryTest {
    public static void main(String[] args) {
        JavaKnowledgeFactory javaFactory = new JavaKnowledgeFactory();
        javaFactory.createBook().readBook();
        javaFactory.createVideo().watchVideo();

        PythonKnowledgeFactory pythonFactory = new PythonKnowledgeFactory();
        pythonFactory.createBook().readBook();
        pythonFactory.createVideo().watchVideo();
    }
}

（三）、类图

四、设计模式的相关博客文章链接

1、七大设计原则的简单解释（包含合成复用原则），简单理解、快速入门，具备案例代码

链接: 七大设计原则的简单解释（包含合成复用原则），简单理解、快速入门，具备案例代码.

2、工厂模式详解附有代码案例分析（简单工厂，工厂方法，抽象工厂）

链接: 工厂模式详解附有代码案例分析（简单工厂，工厂方法，抽象工厂）.

3、单例模式详解及代码案例与应用场景（饿汉式单例模式、懒汉式单例模式、注册式单例模式）

链接: 单例模式详解及代码案例与应用场景（饿汉式单例模式、懒汉式单例模式、注册式单例模式）.

4、原型模式详解附有代码案例分析（浅克隆和深克隆的相关解析）

链接: 原型模式详解附有代码案例分析（浅克隆和深克隆的相关解析）.

5、建造者模式详解附有代码案例分析（包含建造者模式与工厂模式的区别分析）

链接: 建造者模式详解附有代码案例分析（包含建造者模式与工厂模式的区别分析）.

6、门面模式详解附有代码案例分析

链接: 门面模式详解附有代码案例分析.

7、装饰者模式详解附有代码案例分析

链接: 装饰者模式详解附有代码案例分析.

8、享元模式详解附有代码案例分析（包含享元模式的源码应用分析——String中的享元模式应用、Integer中的享元模式应用）

链接: 享元模式详解附有代码案例分析（包含享元模式的源码应用分析——String中的享元模式应用、Integer中的享元模式应用）.

9、组合模式详解附有代码案例分析（包含透明组合模式、安全组合模式的代码示例）

链接: 组合模式详解附有代码案例分析（包含透明组合模式、安全组合模式的代码示例）.

10、桥接模式详解附有代码案例分析

链接: 桥接模式详解附有代码案例分析.

11、适配器模式详解附有代码案例分析（包含类适配器、对象适配器以及接口适配器的代码示例）

链接: 适配器模式详解附有代码案例分析（包含类适配器、对象适配器以及接口适配器的代码示例）.

12、委派模式详解附有代码案例分析（包含委派模式在JDK中的源码示例解析）

链接: 委派模式详解附有代码案例分析（包含委派模式在JDK中的源码示例解析）.

13、模板方法模式详解附有代码案例分析（包含模板方法模式重构JDBC操作业务代码示例）

链接: 模板方法模式详解附有代码案例分析（包含模板方法模式重构JDBC操作业务代码示例）.

14、策略模式详解附有代码案例分析（包含策略模式在源码中的应用以及代码示例）

链接: 策略模式详解附有代码案例分析（包含策略模式在源码中的应用以及代码示例）.

15、责任链模式详解附有代码案例分析（包含责任链模式与建造者模式的结合代码案例）

链接: 责任链模式详解附有代码案例分析（包含责任链模式与建造者模式的结合代码案例）.

16、迭代器模式详解附有代码案例分析（包含迭代器模式的源码应用分析）

链接: 迭代器模式详解附有代码案例分析（包含迭代器模式的源码应用分析）.

17、命令模式详解附有代码案例分析（包含命令模式的源码应用分析）

链接: 命令模式详解附有代码案例分析（包含命令模式的源码应用分析）.

18、状态模式详解附有代码案例分析（包含状态模式与其他相关设计模式的对比）

链接: 状态模式详解附有代码案例分析（包含状态模式与其他相关设计模式的对比）.

19、备忘录模式详解附有代码案例分析

链接: 备忘录模式详解附有代码案例分析.

20、中介者模式详解附有代码案例分析

链接: 中介者模式详解附有代码案例分析.

21、解释器模式详解附有代码案例分析

链接: 解释器模式详解附有代码案例分析.

22、观察者模式详解附有代码案例分析（包含观察者模式使用JDK方式实现）

链接: 观察者模式详解附有代码案例分析（包含观察者模式使用JDK方式实现）.

23、访问者模式详解附有代码案例分析

链接: 访问者模式详解附有代码案例分析.