工厂模式

工厂模式

使用场景

1. 一个基类有很对子类，并且子类对象创建过程复杂，将对象创建的过程放在工厂中，如果使用对象的时候，直接从工厂中获取。
2. 优点：不用管复杂的创建逻辑，同时实现创建和使用的解耦作用。
3. 缺点：一旦基类发生改变，所有子类都需要改变。

简单工厂模式

适用场景

工厂类负责创建的对象较少的场景，并且工厂的创建方法需要传递参数

• 培训机构有很多课程，包括Java课程、Python课程等：
• 课程的标准ICourse接口

public interface ICourse {
    void video();
}

• 创建一个Java课程的实现类

public class JavaCourse implements ICourse {
    @Override
    public void video() {
        System.out.println("Java课程正在播放");
    }
}

• 创建一个Python课程的实现类

public class PythonCourse implements ICourse {
    @Override
    public void video() {
        System.out.println("python视频正在播放");
    }
}

• 创建一个课程工厂

public class SimpleCourseFactory {

//    public ICourse create(String courseName) {
//        if ("java".equals(courseName)) {
//            return new JavaCourse();
//        } else if ("python".equals(courseName)) {
//            return new PythonCourse();
//        } else {
//            return null;
//        }
//    }

//    public ICourse create(String classPath) {
//        try {
//            if (classPath != null && !"".equals(classPath)) {
//                ICourse course = (ICourse) Class.forName(classPath).newInstance();
//                return course;
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return null;
//    }

    public ICourse create(Class<? extends ICourse> clazz) {
        try {
            if (clazz != null) {
                ICourse course = clazz.newInstance();
                return course;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

• 创建一个课程的测试类

public class SimpleFactoryTest {
    public static void main(String[] args) {
        SimpleCourseFactory simpleCourseFactory = new SimpleCourseFactory();

//        ICourse course = simpleCourseFactory.create("java");
//        course.video();

//        ICourse course = simpleCourseFactory.create("com.hh.simplefactory.JavaCourse");
//        course.video();

        ICourse course = simpleCourseFactory.create(JavaCourse.class);
        course.video();

    }
}

工厂模式

使用场景

在工厂方法模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符合开闭原则，并且工厂方法不用传递参数。工厂模式比简单工厂模式的优势：工厂模式更好的扩展，简单工厂模式创建的对象过多，类越来越重，不易于维护，工厂模式 每个工厂只生产一种对象 专人干专事。

• 创建一个工厂的课程基类

public interface ICourseFactory {
    ICourse create();
}

• 创建Java课程工厂

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

• 创建Python课程工厂

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

• 工厂模式的测试类

public class FactoryCourseTest {
    public static void main(String[] args) {
        ICourseFactory courseFactory = new JavaCourseFactory();
        ICourse iCourse = courseFactory.create();
        iCourse.video();

        courseFactory = new PythonCourseFactory();
        iCourse = courseFactory.create();
        iCourse.video();
    }
}

抽象工厂模式

使用场景

当产品不只一种的时候，一个工厂可以生产出几种不同的产品。在工厂模式的基础上，一个工厂生产几种不同的产品 就是抽象工厂

• 视频接口

public interface IVideo {
    void play();
}

• 笔记接口

public interface INote {
    void read();
}

• 抽象工厂接口

public interface ICourseFactory {
    INote createNode();

    IVideo createVideo();
}

• 创建Java课程笔记

public class JavaNote implements INote {
    @Override
    public void read() {
        System.out.println("正在读java笔记");
    }
}

• 创建Java课程视频

public class JavaVideo implements IVideo {
    @Override
    public void play() {
        System.out.println("正在播放java视频");
    }
}

• 创建Java工厂

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

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

• 创建Python课程笔记

public class PythonNote implements INote {
    @Override
    public void read() {
        System.out.println("正在读python笔记");
    }
}

• 创建Python课程视频

public class PythonVideo implements IVideo {
    @Override
    public void play() {
        System.out.println("正在播放Python视频");
    }
}

• 创建Python工厂

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

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

• 抽象工厂的测试类

public class AbstractFactoryTest {
    public static void main(String[] args) {
        JavaCourseFactory javaCourseFactory = new JavaCourseFactory();
        INote node = javaCourseFactory.createNode();
        IVideo video = javaCourseFactory.createVideo();
        node.read();
        video.play();
    }
}