设计模式之工厂模式总结

最新推荐文章于 2022-03-06 20:42:29 发布

原创最新推荐文章于 2022-03-06 20:42:29 发布 · 296 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #java

java设计模式专栏收录该内容

1 篇文章

订阅专栏

设计模式之工厂模式

什么是工厂模式？
工厂模式是一种常见的设计模式，将我们创建对象的行为封装（因为创建对象的行为往往是重复的）然后直接调用工厂所给出的方法创建对象即可。

工厂模式有三种：

	1. 简单工厂模式
	2. 工厂方法模式
	3. 抽象工厂模式

接下来我依次进行说明。

简单工厂模式

简单工厂模式的实现非常简单。

假设我们现在有如下的关系。ICourse接口，JavaCourse是他的一个实现类，如下。

public interface ICourse {
    void begin();
}

public class JavaCourse implements ICourse{
    int id;
    String name;
    public void begin(){
        System.out.println("java开始上课");
    }
    
}

我们可以如下方式创建一个简单工厂：

public class CourseFactory {
    public ICourse create(String name){
        if(name.equals("java"))
            return new JavaCourse();
        return null;
    }
}

使用简单工厂模式时，调用的逻辑如下：

public class TestSimpleFactory {
    public static void main(String[] args) {
        CourseFactory factory=new CourseFactory();
        ICourse javaCourse=factory.create("java");
        javaCourse.begin();
    }

}

这就是完整的一个简单工厂模式的设计逻辑。

简单工厂模式要点：

工厂类负责创建的对象较少。
客户端只需关心工厂类，而不用关心创建对象的逻辑。

工厂方法模式

我们考虑一个问题，当我们要增加一门课程，比如说PythonCourse，这时候我们如果使用简单工厂模式的话就需要对CourseFactory进行修改，非常不利于维护，所以为了解决这个问题我们可以使用工厂方法模式。

现在我们增加一个PythonCourse

public class PythonCourse implements ICourse {

    @Override
    public void begin() {
        System.out.println("Python开始上课");
    }
}

而我们的工厂进行如下的修改

我们首先抽象出一个什么都会加工的工厂

public interface ICourseFactory {
     ICourse create();
}

然后让各个“分厂”实现这个工厂

JavaFactory如下：

public class JavaFactory implements ICourseFactory {

    @Override
    public ICourse create() {
        return new JavaCourse();
    }
}

PythonFactory如下：

public class PythonFactory implements ICourseFactory {

    @Override
    public ICourse create() {
        return new PythonCourse();
    }
}

这时候我们调用的逻辑变成了这样

public class TestFactoryMethod {
    public static void main(String[] args) {
        JavaFactory javaFactory=new JavaFactory();
        PythonFactory pythonFactory=new PythonFactory();
        ICourse java=javaFactory.create();
        ICourse python=pythonFactory.create();
    }
}

这样就完成了工厂方法模式的设计，但是大家可以看出，这种方式有个致命的缺点，就是当课程过多时，会产生类爆炸，非常不利于维护。

抽象工厂模式

上述两种模式是在我们工厂生产的产品单一的情况下可以满足的，而当我们的产品复杂时（可以理解为我们现在不只是要上课，还要记笔记，做作业），这时候我们的工厂要生产的产品增多了，我们如果要用工厂方法模式的话就需要完成记笔记的工厂，做作业的工厂，相当于把上课的工厂再次重复两次，这一定是很不科学的。

考虑增加了产品。

增加记笔记的接口

public interface INote {
    void edit();
}

增加java笔记

public class JavaNote implements INote {

    public void edit() {
        System.out.println("编写Java笔记");
    }
}

增加python笔记

public class PythonNote implements INote {

    public void edit() {
        System.out.println("编写Python笔记");
    }
}

增加作业接口

public interface IHomework {
    void doHomework();
}

增加java作业

public class JavaHomework implements IHomework {
    public void doHomework() {
        System.out.println("做java作业");
    }
}

增加python作业

public class PythonHomework implements IHomework {
    public void doHomework() {
        System.out.println("做python作业");
    }
}

增加工厂接口

public interface CourseFactory {
    INote createNote();
    IHomework createHomework();
}

分别实现java工厂和Python工厂

public class JavaCourseFactory implements CourseFactory {

    public INote createNote() {
        return new JavaNote();
    }

    public IHomework createHomework() {
        return new JavaHomework();
    }
}

这时候我们再调用

public class AbstractFactoryTest {

    public static void main(String[] args) {

        JavaCourseFactory factory0 = new JavaCourseFactory();
        factory0.createNote().edit();
        factory0.createHomework().doHomework();
        PythonCourseFactory factory1 = new PythonCourseFactory();
        factory1.createNote().edit();
        factory1.createHomework().doHomework();
    }
}