设计模式-工厂方法(创建型)

创建型-工厂方法

简单工厂

  1. 将被创建的对象称为"产品",将生产"产品"对象称为"工厂";
  2. 如果创建的产品不多,且不需要生产新的产品,那么只需要一个工厂就可以,这种模式叫做"简单工厂",它不属于23中设计模式之一;
  3. 简单工厂这种模式不符合对拓展开放,对修改关闭开闭原则,因为这种设计模式,新增产品的时候需要修改工厂类代码;

简单工厂:

java 复制代码
/** 简单工厂,工厂类*/
public class SimpleFactory {
    private static SimpleFactory INSTANCE = new SimpleFactory();

    public static SimpleFactory getInstance(){
        return INSTANCE;
    }
    public Car createCar() {
        return new Car();
    }

    public Plane createPlane() {
        return new Plane();
    }

    public Train creatTrain(){
        return new Train();
    }
}

简单工厂使用:

java 复制代码
public class main {
    public static void main(String[] args) {
        SimpleFactory simpleFactory = SimpleFactory.getInstance();
        Car car = simpleFactory.createCar();
        Plane plane = simpleFactory.createPlane();
        Train train = simpleFactory.creatTrain();
    }
}

这种模式如果产生一个other交通工具,还需要在工厂类中新增creatOther()方法。

工厂方法

角色

  1. 抽象工厂:提供创建产品的接口,调用者通过它访问具体的工厂的工厂方法;
  2. 具体工厂:实现抽象工厂中的抽象方法,完成具体的创建;
  3. 抽象产品:定义产品的规范,描述产品的主要特性;
  4. 具体产品:实现抽象产品角色定义的接口,它与具体工厂一一对应

图解

实现案例

产品抽象类:

java 复制代码
public interface Vehicle {
    void go();
}

产品具体实现类:

java 复制代码
public class Car implements Vehicle{
    @Override
    public void go() {
        System.out.println("汽车在跑!");
    }
}

public class Plane implements Vehicle{
    @Override
    public void go() {
        System.out.println("火车在跑!");
    }
}

public class Train implements Vehicle{
    @Override
    public void go() {
        System.out.println("飞机在飞!");
    }
}

抽象工厂类:

java 复制代码
public interface VehicleFactory {
    Vehicle create();
}

具体工厂类:

java 复制代码
public class CarFactory implements VehicleFactory{
    private static CarFactory INSTANCE = new CarFactory();
    @Override
    public Vehicle create() {
        return new Car();
    }
    public static CarFactory getInstance(){
        return INSTANCE;
    }
}

public class PlaneFactory implements VehicleFactory{
    private static PlaneFactory INSTANCE = new PlaneFactory();
    @Override
    public Vehicle create() {
        return new Plane();
    }
    public static PlaneFactory getInstance(){
        return INSTANCE;
    }
}
public class TrainFactory implements VehicleFactory{
    private static TrainFactory INSTANCE = new TrainFactory();
    @Override
    public Vehicle create() {
        return new Train();
    }
    public static TrainFactory getInstance(){
        return INSTANCE;
    }
}

使用:

java 复制代码
public class main {
    public static void main(String[] args) {
        CarFactory carFactory = CarFactory.getInstance();
        Vehicle vehicle = carFactory.create();
        vehicle.go();
    }
}

总结

  1. 简单工厂不符合开闭原则。
  2. 工厂方法,每次增加一个产品时,都需要增加一个具体类和对应的工厂,使系统中类的数量成倍增加,增加了系统的复杂度和具体类的依赖;
相关推荐
VisuperviReborn2 小时前
打造自己的前端监控---前端流量监控
前端·设计模式·架构
BUG收容所所长3 小时前
发布订阅模式 vs 观察者模式:它们真的是一回事吗?
前端·javascript·设计模式
探索为何3 小时前
Transformer:从神坛到笑坛的华丽转身
设计模式·程序员·代码规范
AlenLi3 小时前
JavaScript - 单例模式的几种简单实现方式
设计模式
心月狐的流火号3 小时前
观察者模式解析与Spring事件机制
spring·设计模式
用户6120414922135 小时前
C语言做的汽车线路模拟查询系统
c语言·后端·设计模式
#六脉神剑14 小时前
接口请求的后台发起确认
低代码·设计模式·产品运营·mybuilder
二闹19 小时前
高效开发秘籍:CRUD增强实战
后端·设计模式·性能优化
aiwery21 小时前
深入理解React hooks:从设计初衷到自定义Hook指南
前端·设计模式
codigger1 天前
集大成者的下一代编程语言?探秘 Object Sense 如何实现分布式、跨平台与多语言无缝集成
设计模式