工厂模式
把产品的创建过程封装起来。
一、简单工厂模式
一个工厂可以创建一类产品
由一个工厂对象决定创建出哪一种产品的实例;
// 课程
public interface Course {
public void study();
}
//实现类1:Java课程
public class JavaCourse implements Course{
public void study() {
System.out.println("Java语言课程内容");
}
}
//实现类2:c语言课程
public class CCourse implements Course{
public void study() {
System.out.println("C语言课程内容");
}
}
//实现类3:python
public class PythonCourse implements Course {
public void study() {
System.out.println("Python课程内容");
}
}
没有工厂,如果说创建过程很复杂,参数很多,使用起来会很麻烦;
//用户测试类
public class SimpleFactoryTest {
public static void main(String[] args) {
// 如果想要一个Java课程
Course course = new JavaCourse();
course.study();
}
}
可以把创建过程封在工厂里。
// 课程工厂
public class CourseFactory {
public Course create(Class clzz) {
// 创建出来所需的实际类
// 根据参数 创建合适的类
try {
return (Course) clzz.newInstance();
} catch (Exception e) {
return null;
}
}
}
//用户测试类
public class SimpleFactoryTest {
public static void main(String[] args) {
// 如果想要一个Java课程
CourseFactory factory = new CourseFactory();
Course course = factory.create(JavaCourse.class);
course.study();
}
}
使用场景:产品创建逻辑非常复杂,但是产品比较少,创建逻辑比较稳定(不易修改),客户端可以直接调用工厂创建产品,只需传参,无需关心创建对象的逻辑;
实例1:日期时间的处理
Calender.getInstance();
// 根据时区和语言创建不同的对象
实例2:根据不同的name创建不同的日志对象
loggerFactor.getlogger();
缺点:多个职责放在一个类里,新增产品就要修改逻辑,违背了开闭原则。
不易于扩展过于复杂的产品结构;
工厂方法模式
定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个类,让类的实例化推迟到子类进行。
// 工厂接口类
public Interface CourseFactory{
Course create();
}
//实现类工厂1: Java课程工厂类
public class JavaCourseFactory implements CourseFactory {
public Course create() {
return new JavaCourse();
}
}
// 实现类工厂2:C语言课程工厂类
public class CCourseFactory implements CourseFactory {
public Course create() {
return new CCourse();
}
}
// 实现类工厂3:Python课程工厂类
public class PythonCourseFactory implements CourseFactory {
public Course create() {
return new PythonCourse();
}
}
一个产品对应一个工厂,满足了单一职责,开闭原则;
public class FactoryMethodTest {
public static void main(String[] args) {
CourseFactory factory = new JavaCourseFactory();
Course course = factory.create();
course.study();
}
}
案例:loggerFactory.getlogger()的IloggerFactory等等等
使用场景:
1、创建产品对象需要大量重复代码(可以在抽象类里把公共逻辑放进去处理)
2、客户端不依赖于产品类的实例,而依赖于工厂;
3、符合开闭原则,有新的产品,只需要新增工厂类即可,提高了系统的可维护性。
工厂方法模式的缺点:
类的个数增加,代码结构复杂;
增加了系统的抽象性和理解难度;
抽象工厂模式
提供一个创建一系列相关或相互依赖对象的接口,无需制定他们具体的类。
产品族和产品等级结构;
一个品牌下有多个产品;
一个产品有多个品牌;
// 笔记
public interface Note{
}
//实现类1:Java笔记
public class JavaNote implements Note {
public void write() {
}
}
//实现类2:c笔记
public class CNote implements Note {
public void write() {
}
}
//实现类3:python笔记
public class PythonNote implements Note {
public void write() {
}
}
//
public interface Factory {
// 创建课程
Course createCourse();
// 创建笔记
Note createNote();
}
// java 工厂:可以创建JAVA课程 创建Java笔记
public class JavaFactory implements Factory {
public Course createCourse() {
return new JavaCourse();
}
public Note createNote() {
return new JavaNote();
}
}
//Python 工厂:可以创建Python 课程 创建Python 笔记
public class PythonFactory implements Factory {
public Course createCourse() {
return new PythonCourse();
}
public Note createNote() {
return new PythonNote();
}
}
一个工厂可以创建不同的产品,同一个产品可以被多个工厂创建;
public class Test {
public static void main(String[] args) {
Factory factory = new JavaFactory();
factory.createCourse().study();
factory.createNote();
}
}
适应场景:产品链比较复杂,产品升级较慢
不符合开闭原则,增加一类产品可能会导致要改所有的类;
缺点:不符合开闭原则,增加一类产品可能会导致要改所有的类;
优点:1、客户端(应用层)无需知道产品如何被创建、被实现等细节;
2、强调一系列相关的产品对象在一起使用创建对象时候,需要大量重复的代码;
3、提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不需要依赖于具 体实现,工厂能实现什么样的产品在顶层类里就已经设定好了;
案例:Spring中的AbstractFactory