设计模式学习（一）工厂模式

目录

1.简单工厂模式（静态工厂方法模式）

2.简单工厂升级版:

3.工厂方法模式

4.抽象工厂模式

---

1.简单工厂模式（静态工厂方法模式）

定义：

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

应用场景：

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

UML类结构图：

代码实现：

ICourse接口

public interface ICourse {
    void study();
}

JavaCourse类

public class JavaCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("学习Java课程");
    }
}

PythonCourse类

public class PythonCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("学习Python 课程");
    }
}

CourseFactory类

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

测试类

public class SimpleFactoryTest {
    public static void main(String[] args) {
        ICourse create = CourseFactory.create("Java");
        create.study();
    }
}

输出结果：

学习Java课程

2.简单工厂升级版:

UML类结构图：

代码实现：

public class CourseFactory {
    public static ICourse create(Class<JavaCourse> clazz) {
        try {
            if (clazz != null) {
                return clazz.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

升级点：

1.如果要新增HtmlCourse需要修改CourseFactory的代码，不符合开闭原则（对扩展开放，对修改关闭）；
2.方法参数是字符串，可控性有待提升；

3.工厂方法模式

定义：

工厂方法模式（Factory Method Pattern）是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。

应用场景：

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

UML类结构图：

代码实现：

ICourse接口

public interface ICourse {
    void study();
}

JavaCourse类

public class JavaCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("学习Java课程");
    }
}

PythonCourse类

public class PythonCourse implements ICourse {
    @Override
    public void study() {
        System.out.println("学习Python课程");
    }
}

ICourseFactory接口

public interface ICourseFactory {
    ICourse create();
}

JavaICourseFactory类

public class JavaICourseFactory implements ICourseFactory {
    @Override
    public ICourse create() {
        return new JavaCourse();
    }
}

PythonICourseFactory类

public class PythonICourseFactory implements ICourseFactory {
    @Override
    public ICourse create() {
        return new PythonCourse();
    }
}

测试代码：

public class FactoryTest {
    public static void main(String[] args) {
        ICourseFactory factory = new JavaICourseFactory();
        ICourse course = factory.create();
        course.study();

        factory = new PythonICourseFactory();
        course = factory.create();
        course.study();
    }
}

输出结果：

学习Java课程
学习Python课程

缺点：

1、类的个数容易过多，增加复杂度；
2、增加了系统的抽象性和理解难度。

4.抽象工厂模式

定义：

抽象工厂模式（Abstract Factory Pattern）是指提供一个创建一系列相关或者相互依赖对象的接口，无须指定他们具体的类。

适用场景：

当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。说的更明白一点，就是一个继承体系中，如果存在着多个等级结构（即存在着多个抽象类），并且分属各个等级结构中的实现类之间存在着一定的关联或者约束，就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束，则使用多个独立的工厂来对产品进行创建，则更合适一点。

缺点：

1、规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂 的接口。 （不符合开闭原则）
2、增加了系统的抽象性和理解难度。

产品族 相当于  品牌（例如：Java，Python）

产品等级  相当于  产品类型（例如：课程视频，课程笔记）

UML类结构图：

代码实现：

INote接口

public interface INote {
    void edit();
}

IVideo接口

public interface IVideo {
    void record();
}

JavaNote类

public class JavaNote implements INote {
    @Override
    public void edit() {
        System.out.println("编写Java笔记");
    }
}

JavaVideo类

public class JavaVideo implements IVideo {
    @Override
    public void record() {
        System.out.println("录制Java视频");
    }
}

PythonNote类

public class PythonNote implements INote {
    @Override
    public void edit() {
        System.out.println("编写Python笔记");
    }
}

PythonVideo类

public class PythonVideo implements IVideo {
    @Override
    public void record() {
        System.out.println("录制Python视频");
    }
}

ICourseFactory接口

public interface ICourseFactory {
    INote createNote();
    IVideo createVideo();
}

JavaCourseFactory类

public class JavaCourseFactory implements ICourseFactory {
    @Override
    public INote createNote() {
        return new JavaNote();
    }

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

PythonCourseFactory类

public class PythonCourseFactory implements ICourseFactory {
    @Override
    public INote createNote() {
        return new PythonNote();
    }

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

测试代码：

public class AbstractFactoryTest {
    public static void main(String[] args) {
        CourseFactory factory = new JavaCourseFactory();
//        CourseFactory factory = new PythonCourseFactory();
        INote note = factory.createNote();
        IVideo video = factory.createVideo();
        note.edit();
        video.record();
    }
}

输出结果：

编写Java笔记
录制Java视频