1-1-软件架构设计原则:开闭,依赖倒置,单一职责

1.开闭原则

1.对扩展开放,对修改关闭
2.用抽象构建框架,用实现扩展细节
	总之-->尽可能不修改源代码,增加新功能

举例

1.创建课程接口

/**
 * 课程接口
 * @author YuelongZhou
 * @date 2022/4/18
 */
public interface ICourse {

    Integer getId();

    String getName();

    Double getPrice();
}

2.Java课程类

/**
 * java课程类
 * @author YuelongZhou
 * @date 2022/4/18
 */
public class JavaCourse implements ICourse{

    private Integer id;

    private String name;

    private Double price;

    public JavaCourse(Integer id, String name, Double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public Integer getId() {
        return id;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Double getPrice() {
        return price;
    }
}

3.给java课程做活动,价格优惠

—>不修改原代码实现优惠功能

/**
 * 给Java课程做活动,不修改原代码情况下,实现价格优惠
 * @author YuelongZhou
 * @date 2022/4/18
 */
public class JavaDiscountCourse extends JavaCourse{

    public JavaDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }

    /**
     * 获得原始价格
     */
    public Double getOriginPrice(){
        return super.getPrice();
    }

    /**
     * 实现价格优惠
     */
    public Double getDiscountPrice(){
        return super.getPrice()*0.61;
    }
}

2.依赖倒置原则

1.高层模块不依赖低层模块,二者都应该依赖其抽象
2.细节依赖其抽象,解藕

案例

Yuelong类

/**
 * @author YuelongZhou
 * @date 2022/4/18
 */
public class Yuelong {

    public void studyJavaCourse(){
        System.out.println("yuelong在学习Java课程");
    }

    public void studyWebCourse(){
        System.out.println("yuelong在学习web课程");
    }
}

调用层

/**
 * @author YuelongZhou
 * @date 2022/4/18
 */
public class Dependence {
    public static void main(String[] args) {
        Yuelong yuelong=new Yuelong();
        yuelong.studyJavaCourse();
        yuelong.studyWebCourse();
    }
}

问题:

当我还想学习go语言时,需要从低层(Yuelong类)到高层(Dependence)依次修改代码

优化

1.创建课程接口

/**
 * 课程接口
 * @author YuelongZhou
 * @date 2022/4/18
 */
public interface ICourse {
    void study();
}

2.Java课程类

/**
 * Java课程类
 * @author YuelongZhou
 * @date 2022/4/18
 */
public class JavaCourse implements ICourse{

    @Override
    public void study() {
        System.out.println("yuelong在学习Java");
    }
}

3.Web课程类

/**
 * web课程类
 * @author YuelongZhou
 * @date 2022/4/18
 */
public class WebCourse implements ICourse{
    @Override
    public void study() {
        System.out.println("yuelong在学习web课程");
    }
}

4.修改Yuelong类

/**
 * @author YuelongZhou
 * @date 2022/4/18
 */
public class Yuelong {
    public void study(ICourse course){
        course.study();
    }
}

5.高层(调用层)

/**
 * web课程类
 * @author YuelongZhou
 * @date 2022/4/18
 */
public class WebCourse implements ICourse{
    @Override
    public void study() {
        System.out.println("yuelong在学习web课程");
    }
}

6.优点

对于新课程,只需要新建一个类,通过传参方式告诉Yuelong,不需要修改低层代码(依赖注入)

总结

拿到需求之后,要面向接口编程,先顶层再细节设计代码结构

3.单一职责原则

1.不要存在多于一个导致类变更的原因
2.解决-->将2个职责用2个类来实现,解藕

原则:

一个类,接口,方法只负责一项职责

举例

1. 需求

课程有直播课和录播课,直播课不能快进和快退,录播课可以任意反复地观看

2.Course类

/**
 * 课程类
 * 承担2种逻辑:直播课和录播课
 * @author YuelongZhou
 * @date 2022/4/19
 */
public class Course {
    public void study(String courseName){
        if ("直播课".equals(courseName)){
            System.out.println(courseName+"不能快进");
        }else {
            System.out.println(courseName+"可以反复观看");
        }
    }
}

3,调用类

/**
 * @author YuelongZhou
 * @date 2022/4/19
 */
public class Simple {
    public static void main(String[] args) {
        Course course=new Course();
        course.study("直播课");
        course.study("录播课");
    }
}

需求更改

对课程进行加密,直播课和录播课加密逻辑不一样,要修改代码,修改代码的逻辑势必会相互影响---->解藕

解决

一个类实现一种逻辑–>分别创建直播课类和录播课类

直播课类

public class LiveCourse {
    public void study(String courseName){
        System.out.println(courseName+"不能快进看");
    }
}

录播课类

public class ReplayCourse {
    public void study(String courseName){
        System.out.println(courseName+"可以反复看");
    }
}

调用类

/**
 * @author YuelongZhou
 * @date 2022/4/19
 */
public class Simple {
    public static void main(String[] args) {
        LiveCourse liveCourse=new LiveCourse();
        liveCourse.study("直播课");
        ReplayCourse replayCourse=new ReplayCourse();
        replayCourse.study("录播课");
    }
}

需求更改

没有付费学员可以获取课程基本信息,已付费学员可以获取视频流

顶层接口

/**
 * 顶层接口
 *      --展现职责:1,2
 *      --管理职责:3.4
 * ----->拆分
 * @author YuelongZhou
 * @date 2022/4/19
 */
public interface ICourse {
    
    //1.获取基本信息
    String getCourseName();
    //2.获取视频流
    byte[]getCourseVideo();
    
    //3.学习课程
    void studyCourse();
    //4.退款
    void refundCourse();
}

解决:拆分–>展现职责,管理职责

展现职责

/**
 * 展现职责
 * @author YuelongZhou
 * @date 2022/4/19
 */
public interface ICourseInfo {
    String getCourseName();

    byte[] getCourseVideo();
}

管理职责

/**
 * 管理职责
 * @author YuelongZhou
 * @date 2022/4/19
 */
public interface ICourseManager {
    void studyCourse();
    void refundCourse();
}

最后

以上就是虚心帅哥为你收集整理的1-1-软件架构设计原则:开闭,依赖倒置,单一职责的全部内容，希望文章能够帮你解决1-1-软件架构设计原则:开闭,依赖倒置,单一职责所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。