工厂模式

最新推荐文章于 2024-09-10 10:21:38 发布

m0_37944734

最新推荐文章于 2024-09-10 10:21:38 发布

阅读量204

点赞数 1

分类专栏： 23种设计模式文章标签： java 设计模式工厂模式

本文链接：https://blog.csdn.net/m0_37944734/article/details/81560043

版权

23种设计模式专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、简单工厂模式

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。也就是你想获取一个对象的时候，不需要你去new而是告诉工厂你需要的对象，让工厂返回对象给你使用。

例：课程工厂

类图：

课程类：

public interface ICourse {
    void record();
}

java课程类：

public class JavaCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("java课程");
    }
}

python课程类：

public class PythonCourse implements ICourse {

    @Override
    public void record() {
        System.out.println("python课程");
    }
}

课程工厂类：

public class CourseFactory {

    public ICourse createCourse(String course){
        if("java".equals(course)){
            return new JavaCourse();
        }else if("python".equals(course) || "java".equals(course)){
            return new PythonCourse();
        }else {
            return null;
        }
    }
}

客户端调用：

public static void main(String[] args) {
    CourseFactory courseFactory = new CourseFactory();
    ICourse java = courseFactory.createCourse("java");
    java.record();
}

用一个简单工厂就实现了课程创建的功能，方便扩展，当增加另一种课程的时候就可以，添加一个课程类，并且在工厂类中添加相应的case添加即可。不会影响原来代码的功能。

方法工厂

类图：

把上面的工厂类改成方法工厂类：

public class MethodFactory {

    public ICourse getJavaCourse(){
        return new JavaCourse();
    }

    public ICourse getPythonCourse(){
        return new PythonCourse();
    }
}

方法工厂客户端代码：

public class SimpleClient {
    public static void main(String[] args) {
        MethodFactory methodFactory = new MethodFactory();
        ICourse course = methodFactory.getJavaCourse();
        course.record();
    }
}

总结：普通工厂和方法工厂的区别就在于创建工厂时的区别，一个是根据方法创建对象，一个是根据所传参数创建对象。

优点：克服了简单工厂违背开放-封闭原则的缺点，又保留了封装对象创建过程的优点,降低客户端和工厂的耦合性，所以说“工厂模式”是“简单工厂模式”的进一步抽象和推广。

缺点：每增加一个产品，相应的也要增加一个方法子工厂，加大了额外的开发量。

抽象工厂

其实也就是一个产品族和产品等级的关系

栗子：一个产品族=课程，一个产品等级相当于课程下面的笔记、学习视频、学习资料、作业

每个课程都对应笔记、学习视频、学习资料、作业

java笔记 java学习视频 java学习资料

python笔记 python学习视频 python学习资料

横着的就相当于产品族的一员

竖着的就相当于产品等级的一员

类图：

课程抽象接口类：

public interface ICourseFactory {

    ICourse createCourse();

    INote createNote();

    IVideo createVideo();
}

课程接口类：

public interface ICourse {
    void record();
}

笔记接口类：

public interface INote {
    void create();
}

视频接口类：

public interface IVideo {
    void create();
}

java笔记类：

public class JavaNode implements INote{
    @Override
    public void create() {
        System.out.println("Java Node");
    }
}

java视频类：

public class JavaVideo implements IVideo {
    @Override
    public void create() {
        System.out.println("Java Video");
    }
}

java课程工厂类：

public class JavaCourseFactory implements ICourseFactory {
    @Override
    public ICourse createCourse() {
        return new JavaCourse();
    }

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

    @Override
    public IVideo createVideo() {
        return new JavaVideo();
    }
}

如果看不明白，你就把代码复制到idea里看看，然后加个课程（与实现java的一样，你就明白了）

只有实线过后你才会发现抽象工厂和方法工厂类有什么区别。

区别：方法工厂所有的课程的创建都在一个工厂，而抽象工厂是每个课程都有自己的工厂，而这些工厂都实现了同一个抽象接口。

缺点：

不容易纵向扩展，如果抽象工厂增加一个方法，那么所有的课程工厂都要实现这个方法。不符合开闭原则

优点：

利于横向扩展，如果一直增加课程，只要增加其工厂和其实现类，就可以实现。

一般使用与产品等级固定的产品族。