[技术笔记] 【广州校区】工厂模式

A. 为什么要从设计模式开始及工厂模式详解软件设计7大原则

开闭原则
- 对扩展开放，对修改关闭
单一职责
- 一个接口，一个方法，只做一件事
依赖倒置原则
- 通过一个抽象接口或者类，实现松耦合
接口隔离原则
- 尽量保证接口的纯洁性
- 客户端不应该依赖不需要的接口
迪米特法则
- 最小知道原则
- 修饰符要控制好
里氏替换原则
- 子类能够扩展父类的功能，但是不能改变其功能
合成复用原则
- 尽量使用对象组合、聚合，而不使用继承关系达到代码复用的目的

B. 工厂模式A. Spring 中用到的设计模式

Spring IOC
- 工厂
- 单例
- 装饰器
Spring AOP
- 代理
- 观察者
Spring MVC
- 委派
- 适配器
Spring JDBC
- 模板方法

B. 简单工厂模式定义

简单工厂模式(Simple Factory Pattern)
- 指由一个工厂对象决定创建出哪一种产品的实例
属于创建型模式，但它不属于 GOF,23种设计模式
- 不属于 23 种设计模式中的一种
简单工厂用于解决创建逻辑非常复杂的对象
- 弊端：
  - 工厂里可能有很多的判断
  - 创建的逻辑不能太复杂，不然不好维护

public interface ICourse {
public 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 ICourse create_v1(String courseName) {
      courseName = courseName.toLowerCase();
      switch (courseName) {
         case "java":
            return new JavaCourse();
         default:
            return null;
      }
}
public ICourse create_v2(String className) {
      if (className == null || className.trim().equals("")) return null;
      try {
         return (ICourse) Class.forName(className).newInstance();
      } catch (Exception e) {
         System.err.println("fail to create object!!");
      }
      return null;
}
public ICourse create_v3(Class<? extends ICourse> clazz) {
      if (clazz == null) throw new NullPointerException();
      try {
         return clazz.newInstance();
      } catch (Exception e) {
         System.err.println("fail to create object!!");
      }
      return null;
}
}public class SimpleFactoryTest {
public static void main(String[] args) {
      System.out.println("普通创建对象方式");
      ICourse course = new JavaCourse();
      course.record();

      System.out.println("通过简单工厂获取对象");
      CourseFactory factory = new CourseFactory();
      ICourse javaCourse_1 = factory.create_v1("Java");
      javaCourse_1.record();

      System.out.println("改进版后的方法");
      ICourse javaCourse_2 = factory.create_v2(JavaCourse.class.getName());
      javaCourse_2.record();

      System.out.println("改进版本 V3");
      ICourse javaCourse_3 = factory.create_v3(JavaCourse.class);
      javaCourse_3.record();
}
}

工厂类负责创建的对象较少
客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心
不易于扩展过于复杂的产品结构

C. 工厂方法模式

工厂方法模式(Factory Method Pattern) 是指定义一个创建对象的接口
- 但让实现这个接口的类来决定实例化哪个类
- 工厂方法让类的实例化推迟到了子类中进行
工厂方法模式属于创建型设计模式

public interface ICourse {
public 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 interface ICourseFactory {
public ICourse create();
}

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

public class PythonCourseFactory implements ICourseFactory {
@Override
public ICourse create() {
      return new PythonCourse();
}
}public class FactoryMethodTest {
public static void main(String[] args) {
      ICourseFactory courseFactory = new PythonCourseFactory();
      ICourse pythonCourse = courseFactory.create();
      pythonCourse.record();
}
}

以后增加对象的时候只需要增加对应的工厂就好，不需要改以前的代码
缺点
- 每增加一个类型，就要写一个工厂
  - 导致类越来越多,增加代码的复杂度

D. 抽象工厂

工厂方法的升级
抽象工厂模式(Abstract Factory Pattern)是指提供一个创建==一系列==相关或者相互依赖对象的接口，无需指定它们的具体类型
属于创建行设计模式

public interface ICourse {}

public interface INote {}

public interface IVideo {}public class JavaCourse implements ICourse {}

public class JavaNote implements INote {}

public class JavaVideo implements IVideo {}public class PythonCourse implements ICourse {}public class PythonNote implements INote{}public class PythonVideo implements IVideo {}public interface ICourseFactory { public ICourse createCourse(); public IVideo createVideo(); public INote createNote();}public class JavaCourseFactory implements ICourseFactory { @Override public ICourse createCourse() { return new JavaCourse(); } @Override public IVideo createVideo() { return new JavaVideo(); } @Override public INote createNote() { return new JavaNote(); }}public class PythonCourseFactory implements ICourseFactory { @Override public ICourse createCourse() { return new PythonCourse(); } @Override public IVideo createVideo() { return new PythonVideo(); } @Override public INote createNote() { return new PythonNote(); }}public class AbstractFactoryTest { public static void main(String[] args) { ICourseFactory javaFactory = new JavaCourseFactory(); javaFactory.createCourse(); javaFactory.createNote(); javaFactory.createVideo(); ICourseFactory pythonFactory = new PythonCourseFactory(); pythonFactory.createCourse(); pythonFactory.createNote(); pythonFactory.createNote(); }}

抽象工厂不符合开闭原则
- 但是已于扩展
- 增加一个产品的时候，如增加 interface ISource
  - 需要修改 interface ICourseFactory
  - 然后修改所有的实现类

帐号		自动登录	找回密码
密码			加入黑马

[技术笔记] 【广州校区】工厂模式

0 个回复