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

工厂模式详解附有代码案例分析

一、简单工厂模式

（一）、简单工厂的概念

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

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

1、课本接口：Book

public interface Book {
    
    
    public void readBook();
}

2、Java书籍类：javaBook

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

3、调用代码：

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

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

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

1、增加Python类书籍：PythonBook

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

2、书籍工厂类：BookFactory

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、调用代码：

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

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

1、改写书籍工厂：BookFactory

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、调用代码：

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

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

1、改写书籍工厂：BookFactory

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

2、调用代码：

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

（六）、类图

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bF6Draxm-1599657330614)(C:\Users\huang\AppData\Roaming\Typora\typora-user-images\image-20200909211301696.png)]$

二、工厂方法模式

（一）、工厂方法的概念

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

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

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

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

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

public interface BookFactory {
    
    
    Book create();
}

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

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

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

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

4、调用代码：

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）、增加了系统的抽象性和理解难度

（四）、类图

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ah4tdAOB-1599657330622)(C:\Users\huang\AppData\Roaming\Typora\typora-user-images\image-20200909211405534.png)]$

三、抽象工厂模式

（一）、抽象工厂的概念

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

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

1、创建知识工厂：KnowledgeFactory

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

    protected abstract Book createBook();

    protected abstract Video createVideo();
}

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

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

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

public interface Book {
    
    
    void readBook();
}

5、创建视频类接口：Video

public interface Video {
    
    
    void watchVideo();
}

6、创建Java图书类：JavaBook

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

7、创建Java视频类：JavaVideo

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

8、创建Python图书类：PythonBook

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

9、创建Python视频类：PythonVideo

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

10、调用代码：

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();
    }
}

（三）、类图

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qz9O4CE3-1599657330626)(C:\Users\huang\AppData\Roaming\Typora\typora-user-images\image-20200909211447562.png)]$

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