设计模式之旅-工厂模式(简单工厂、工厂方法、抽象工厂)

简单工厂

是指由一个工厂对象决定创建出哪一种产品类 的实例。
但它不属于 GOF，23 种设计模式

• 优点：传入一个正确参数，就可以获取对象，无需知道创建细节
• 缺点：参数值放在一个方法，导致职责过重

比如我们有一个课程的接口，然后想创建多种课程(java、python…)。

public interface ICourse {
    void record();
}

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

public class PythonCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("录制Python课程");
    }
}

创建简单工厂

public class CourseFactory {
    public static ICourse create(Class<? extends ICourse> clazz) {
        /**
         * 如果扩展多个类，需要修改工厂类不符合开闭原则(对扩展开放，对修改关闭)
         */
        /*if (Objects.equals("java", name)) {
            return new JavaCourse();
        } else if (Objects.equals("python", name)) {
            return new PythonCourse();
        } else {
            return null;
        }*/

		/**
         * 反射技术,传入com.dingzhy.design.factory.JavaCourse字符串，不好
         */
        /*try {
            if (!(null == className || "".equals(className))) {
                return (ICourse) Class.forName(className).newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;*/

        try {
            if (null != clazz) {
                return clazz.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }
}

测试类

public class TestSimpleFactory {
    public static void main(String[] args) {
        /*ICourse javaCourse = new JavaCourse();
        javaCourse.record();*/

        /*CourseFactory factory = new CourseFactory();
        ICourse pythonCourese = factory.create("python");
        pythonCourese.record();*/

        /* 方法变静态
        ICourse javaCourse = CourseFactory.create("java");
        javaCourse.record();*/

        /*ICourse course = CourseFactory.create("com.dingzhy.design.factory.JavaCourse");
        course.record();*/

        ICourse course = CourseFactory.create(PythonCourse.class);
        course.record();
    }
}

工厂方法

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

• 优点：只需要关注工厂，无需关心创建细节。加入新产品符合开闭原则，提高系统可扩展性
• 缺点：类可能越来越多，结构负责

工厂接口：

public interface ICourseFactory {
    /**
     * 创建工厂
     * @return
     */
    ICourse create();
}

工厂实现类

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

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

测试类

public class TestFactoryMethod {

    public static void main(String[] args) {
        /**
         * 如果每个课程的创建逻辑有区别的话，工厂的职责会变得越来越多
         * 单一职责原则:Java 课程由 Java 工厂创建，对工厂本身也做一个抽象。
         */
        ICourseFactory javaFactory = new JavaFactory();
        ICourse javaCourse = javaFactory.create();
        javaCourse.record();

        ICourseFactory pythonFactory = new PythonFactory();
        ICourse pythonCourse = pythonFactory.create();
        pythonCourse.record();

    }
}

抽象工厂

抽象工厂：是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类。

把产品子类进行分组，同组中的不同产品由同一个工厂子类的不同方法负责创建，从而减少工厂子类的数量

比如说课程不仅支持录播，慢慢有笔记，视频等，不同的课程分别有自己的实现

public interface INote {
}

public interface IVideo {
}

public class JavaNote implements INote {
}

public class JavaVideo implements IVideo {
}

抽象工厂

/**
 * 要求所有工厂都实现这个工厂
 *  ===创建一个完整的产品族===
 *      规定每个产品族必须有三个产品
 *      (如果加入一个产品比如说需要一个源码的接口，那么IAbsCourseFactory加上接口，实现的工厂都需要改动，不符合开闭原则)
 */
public interface IAbsCourseFactory {

    /**
     * 创建课程
     * @return
     */
    ICourse createCourse();

    /**
     * 创建笔记
     * @return
     */
    INote createNote();

    /**
     * 创建视频
     * @return
     */
    IVideo createVideo();
}

工厂实现类

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

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

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