软件工程：数据流图，智能汽车代码功能实现(Java)

文章目录

软件工程：数据流图，智能汽车代码功能实现

软件工程

简介

在这里插入图片描述

开闭原则

软件实现应该对扩展开放，对修改关闭，其含义是说一个软件实体应该通过扩展来实现变化，而不是通过修改已有的代码来实现变化的

智能汽车中，确定汽车的加速/减速

在这里插入图片描述

速度接口

//速度接口
public interface MphInter {
    
    
    String getMph(int rpm);
}

速度实现抽象为父类

//1.速度实现类，抽象为父类
public abstract class Mph implements MphInter {
    
    
    //2.将转速转化为速度
    @Override
    public abstract String getMph(int rpm);
}

速度控制，子类ControlRpm继承抽象父类

public class ControlRpm extends Mph {
    
    
    //1.定义速度mph
    private int mph;
	//2.重写父类方法
    @Override
    public String getMph(int rpm) {
    
    
        /*3.通过传入参数rpm，
       经过一系列计算得到了速度mph
       ...
       ...
       */
        //4.比如最后获得到的速度mgh为90迈
        mph = 90;
        //5.这里为了简化逻辑，直接设为加速装填，本来应该和前一个速度相比来判断加速还是减速
        boolean control_speed = true;
        if (control_speed == true) {
    
    
            return "+" + mph;
        } else {
    
    
            return "-" + mph;
        }
    }
    
    public int getMph() {
    
    
        return mph;
    }
}

如果不使用开闭原则，将速度控制方法写于速度实现类中

public class Mph implements MphInter {
    
    
    //1.定义速度mph
    private int mph;

    //2.将转速转化为速度
    @Override
    public int getMph(int rpm) {
    
    
        /*4.通过传入参数rpm，
        经过一系列计算得到了速度mph
        ...
        ...
        */
        //5.比如最后获得到的速度mgh为90迈
        mph = 90;
        return mph;
    }
    public ControlRpm() {
    
    
    }
    public String controlRpm(boolean control_speed){
    
    
        if(control_speed == true){
    
    
            return "+";
        }else{
    
    
            return "-";
        }
    }
    
}

那么后续，如果出现其他需求，比如将速度控制换成 ↑和↓的箭头，或者其他情况

扫描二维码关注公众号，回复： 15021651 查看本文章

修改接口

接口MphInter新增方法后，他的实现类Mph也需要重写接口方法，同时接口应该是比较稳定可靠的，不应该随意修改。
修改实现类

修改Mph类的方法，新增了一个getContrlolRpm的方法，那么将出现两个读取速度的方法，可以实现需求但不是最优解
通过扩展实现变化

我们可以增加一个子类ControlRpm，来继承父类Mph类，覆写getMph方法（为了简化速度控制逻辑，重新写了一个方法controlRpm进行替代）

后续有新的要求后，可以直接新建子类，继承父类
既可以保证新需求可以实现，又可以保证先有功能的稳定

里氏替换原则

在上述开闭原则中，同时也实现类里氏替换原则，将父类Mph设计为抽象类，让子类ControlRpm继承父类并实现在父类中声明的方法getMph(int rpm)
可以很方便地扩展系统的功能，无需修改原有子类的代码，增加新的功能可以通过增加一个新的子类来实现。

单一职责原则

一个对象应该只包含单一的职责，并且该职责被完整地封装在一个类中。

接受传感信号

拆分成了两个类：SpsTranslateRpm类和 FuelConsumption类

sps转化成rpm实现类
public class SpsTranslateRpm implements SpsTranslateRpmInter

油耗量实现对象

public class FuelConsumption implements FuelConsumptionInter
数据转化控制

拆分为两个类：Mile类、 Mph类、ControlRpm类

英里实现类
public class Mile implements MileInter

速度实现类，抽象为父类
public abstract class Mph implements MphInter

//速度控制类，Mph的子类

public class ControlRpm extends Mph

驱动仪表板

拆分为两个类：LedShow类、RingAlarm类

发光二极管显示实现类
public class LedShow implements LedShowInter

响铃接口实现类，实现超速响铃
public class RingAlarm implements RingAlarmInter

提高类的可维护性和可读写性一个类的职责少了，复杂度降低了，代码就少了，可读性也就好了，可维护性自然就高了。

降低变更的风险一个类的职责越多，变更的可能性就越大，变更带来的风险也就越大

接口隔离原则

客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。

在这里插入图片描述

//油耗量接口
public interface FuelConsumptionInter {
    
    
    double getMpg(int gph,int mph);
}

//发光二极管显示接口
public interface LedShowInter {
    
    
    void ledShow(String something);
}

//行使英里接口
public interface MileInter {
    
    
    //得到行使的英里   (rpm转速)
    int getMile(int rpm, int time);
}

//速度接口
public interface MphInter {
    
    
    String getMph(int rpm);
}

//超速响铃接口
public interface RingAlarmInter {
    
    
    void ring(int mph);
}

//将Sps转化成rpm的接口
public interface SpsTranslateRpmInter {
    
    
    int getRpm(int sps);

}

迪米特法则

如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中的一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。

在对其他类的引用上，将引用其他对象的次数降到最低，降低类的耦合

在数字控制面板中，对于对象与对象之间，只能通过get之类的方法来获得其中的对象值，对象并不能直接调用另一个对象的变量。
限制另一个类对本类成员的访问权限

        //1.计算rpm  转速    mph结果为设置的2500
        int rpm = STR.getRpm(125);
        //2.计算英里
        int total_mile = mile.getMile(rpm, 3);
        //3.计算速度     speed为设置的90迈
        String speed = control.getMph(rpm);
        //4.计算油耗量        结果计算为450/90=50
        double fuel_loss = fuelConsumption.getMpg(450, control.getMph());

油耗的计算中也定义了参数mph，避免了直接调用ControlRpm类的成员变量mph

    public double getMpg(int gph, int mph) {
    
    
        mpg = mph*1.0 / gph;
        return mpg;
    }

对于ControlRpm类，也是只能通过getMph()来获取成员变量mph

    public int getMph() {
    
    
        return mph;
    }

完整代码实现

补充：数字仪表盘设置为抽象类，以适应不同类型的车

接口

分别建立接口文件
FuelConsumptionInter
LedShowInter
MileInter
MphInter
RingAlarmInter
SpsTranslateRpmInter

//油耗量接口
public interface FuelConsumptionInter {
    
    
    double getMpg(int gph,int mph);
}

//发光二极管显示接口
public interface LedShowInter {
    
    
    void ledShow(String something);
}

//行使英里接口
public interface MileInter {
    
    
    //得到行使的英里   (rpm转速)
    int getMile(int rpm, int time);
}

//速度接口
public interface MphInter {
    
    
    String getMph(int rpm);
}

//超速响铃接口
public interface RingAlarmInter {
    
    
    void ring(int mph);
}

//将Sps转化成rpm的接口
public interface SpsTranslateRpmInter {
    
    
    int getRpm(int sps);

}

接口实现类

建立文件

FuelConsumption
LedShow
Mile
Mph
RingAlarm
SpsTranslateRpm
ControlRpm

//油耗量实现对象
public class FuelConsumption implements FuelConsumptionInter {
    
    
    //定义mpg为：一加仑能够行驶的英里
    private double mpg;


    //计算mpg的值并返回(gph为油耗量)
    @Override
    public double getMpg(int gph, int mph) {
    
    
        mpg = mph*1.0 / gph;
        return mpg;
    }
}

//发光二极管显示实现类
public class LedShow implements LedShowInter {
    
    
    //传入需要显示的内容
    @Override
    public void ledShow(String something) {
    
    
        System.out.println(something);
    }

}

//英里实现类
public class Mile implements MileInter {
    
    
    private int totalMile;

    //计算总的英里数(rpm转速)
    @Override
    public int getMile(int rpm, int time) {
    
    
        totalMile = rpm * time;
        return totalMile;
    }
}

//速度实现类，抽象为父类
public abstract class Mph implements MphInter {
    
    

    //2.将转速转化为速度
    @Override
    public abstract String getMph(int rpm);
}

//响铃接口实现类，实现超速响铃
public class RingAlarm implements RingAlarmInter{
    
    
    //1.定义常量最高速度   和  响铃
    private static final int SPEED_LIMIT = 80;
    //2.默认不响铃
    private boolean ring_alarm = false;


    @Override
    public void ring(int mph) {
    
    
        if(mph>=80){
    
    
            System.out.println("超速");
            //把响铃设置为true
            ring_alarm = true;
        }
    }

    public boolean isRing_alarm() {
    
    
        return ring_alarm;
    }
}

//sps转化成rpm实现类
public class SpsTranslateRpm implements SpsTranslateRpmInter {
    
    

    @Override
    //通过sps来计算rpm(转速)，并返回
    public int getRpm(int sps) {
    
    
        /*通过一系列计算，
        将sps转换成了rpm
        */
        //假设得到最终转化结果rpm为2500
        int rpm = 2500;

        return rpm;
    }
}

//速度控制类，Mph的子类
public class ControlRpm extends Mph {
    
    
    //1.定义速度mph
    private int mph;
    
    @Override
    public String getMph(int rpm) {
    
    
        /*4.通过传入参数rpm，
       经过一系列计算得到了速度mph
       ...
       ...
       */
        //5.比如最后获得到的速度mgh为90迈
        mph = 90;
        boolean control_speed = true;
        if (control_speed == true) {
    
    
            return "+" + mph;
        } else {
    
    
            return "-" + mph;
        }
    }

    public int getMph() {
    
    
        return mph;
    }
}

仪表盘数字控制类

//数字仪表板控制
public abstract class DigitalDashboardControl {
    
    
    //1.创建油耗量对象
    private FuelConsumption fuelConsumption;
    //2.创建sps转化rpm对象
    private SpsTranslateRpm STR;
    //3.创建速度对象
    private Mph mph;
    //4.创建行使英里对象
    private Mile mile;
    //5.创建发光二极管显示对象
    private LedShow ledShow;
    //6.创建超速警告对象
    private RingAlarm ringAlarm;
    //7.创建速度控制对象
    private ControlRpm control;

    public DigitalDashboardControl() {
    
    
        fuelConsumption = new FuelConsumption();
        STR = new SpsTranslateRpm();
        mile = new Mile();
        ledShow = new LedShow();
        ringAlarm = new RingAlarm();
        control  = new ControlRpm();
    }

    public void control() {
    
    
        //1.计算rpm  转速    mph结果为设置的2500
        int rpm = STR.getRpm(125);
        //2.计算英里
        int total_mile = mile.getMile(rpm, 3);
        //3.计算速度     speed为设置的90迈
        String speed = control.getMph(rpm);
        //4.计算油耗量        结果计算为450/90=50
        double fuel_loss = fuelConsumption.getMpg(450, control.getMph());

        //5.二极管显示油耗量和里程
        ledShow.ledShow("油耗量：" + fuel_loss);
        ledShow.ledShow("里程：" + total_mile);

//        //6.1获取加速或者减速状态 ，flag  为当前加速+  减速- 状态
//        String flag = control.controlRpm(true);
        //6.2二极管显示速度
        ledShow.ledShow("速度："+control.getMph(rpm));

        //7.获取响铃状态如果铃声打开中，则在响铃
        //  当前速度为90，  限制的速度为80
        ringAlarm.ring(control.getMph());
        if(ringAlarm.isRing_alarm()==true){
    
    
            System.out.println("正在响铃");
        }

    }
}

汽车类

Bus

public class Bus extends DigitalDashboardControl{
    
    
    public Bus() {
    
    
    }
}

测试类

Test

public class Test {
    
    
    public static void main(String[] args) {
    
    

        Bus bus = new Bus();
        bus.control();

    }
}

程序运行

在这里插入图片描述