黑马程序员技术交流社区

标题: 【广州校区】工厂模式 [打印本页]

---

作者: Mylo    时间: 2019-6-20 14:29
标题: 【广州校区】工厂模式
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
    • 然后修改所有的实现类
      
      
    
    
  
  

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2