java软件设计七大原则的定义

本篇内容介绍了"java软件设计七大原则的定义"的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

1、开闭原则

1.1、定义

一个软件实体如类、模块和函数应该`对扩展开放,对修改关闭`。用抽象构建框架,用实现扩展细节。优点：提高软件系统的可复用性以及可维护性

1.2、代码演示

public interface ICourse {    Integer getId();    String getName();    Double getPrice();}

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;    }    public Integer getId() {        return this.Id;    }    public String getName() {        return this.name;    }    public Double getPrice() {        return this.price;    }}

// 如果需要在原有功能基础上添加一个获取打折价格的功能,开闭原则建议不要修改原有接口,这里可以继承原有JavaCourse类,// 在原有功能之上扩展public class JavaDiscountCourse extends JavaCourse {    public JavaDiscountCourse(Integer id, String name, Double price) {        super(id, name, price);    }    public Double getDiscountPrice(){        return super.getPrice()*0.8;    }}

2、依赖倒置原则

2.1、定义

`高层模块不应该依赖低层模块`,二者都应该依赖其抽象。抽象不应该依赖细节，细节应该依赖抽象。针对接口编程，不要针对实现编程。优点：可以减少类之间的耦合性,提高系统的稳定性,提高代码可读性和可维护性,可降低修改程序所造成的风险。

2.2、代码演示

public interface ICourse {    void studyCourse();}public class JavaCourse implements ICourse {    @Override    public void studyCourse() {        System.out.println("Geely在学习Java课程");    }}public class PythonCourse implements ICourse {    @Override    public void studyCourse() {        System.out.println("Geely在学习Python课程");    }}

public class Geely {    public void setiCourse(ICourse iCourse) {        this.iCourse = iCourse;    }    private ICourse iCourse;    public void studyImoocCourse() {        iCourse.studyCourse();    }}

public class Test {    public static void main(String[] args) {        Geely geely = new Geely();        geely.setiCourse(new JavaCourse());        geely.studyImoocCourse();        geely.setiCourse(new FECourse());        geely.studyImoocCourse();    }}

3、单一职责原则

3.1、定义

不要存在多于一个导致类变更的原因。一个类/接口/方法只负责一项职责。优点：降低类的复杂度、提高类的可读性、提高系统的可维护性、降低变更引起的风险。

3.2、代码演示

// 不推荐的写法public class Bird {    public void mainMoveMode(String birdName){                if("鸵鸟".equals(birdName)){            System.out.println(birdName+"用脚走");        }else{            System.out.println(birdName+"用翅膀飞");        }    }}

public class FlyBird {    public void mainMoveMode(String birdName){        System.out.println(birdName+"用翅膀飞");    }}public class WalkBird {    public void mainMoveMode(String birdName){        System.out.println(birdName+"用脚走");    }}

public class Test {    public static void main(String[] args) {        // 不推荐写法        Bird bird = new Bird();        bird.mainMoveMode("大雁");        bird.mainMoveMode("鸵鸟");        // 推荐写法,功能单一        FlyBird flyBird = new FlyBird();        flyBird.mainMoveMode("大雁");        WalkBird walkBird = new WalkBird();        walkBird.mainMoveMode("鸵鸟");    }}

4、接口隔离原则

4.1、定义

用多个专门的接口，而不使用单一的总接口。客户端不应该依赖它不需要的接口。一个类对另一个类的依赖应该建立在最小的接口上。建立单一接口，不要建立庞大臃肿的接口。`尽量细化接口，接口中的方法尽量少`。适度原则，一定要适度。优点：符合我们常说的高内聚低耦合的设计思想,从而使得类具有很好的可读性、可扩展性和可维护性。

4.2、代码演示

public interface IAnimalAction {    void eat();    void fly();    void swim();}// 将一个接口拆分成3个接口public interface IEatAnimalAction {    void eat();}public interface IFlyAnimalAction {    void fly();}public interface ISwimAnimalAction {    void swim();}

public class Dog implements ISwimAnimalAction,IEatAnimalAction {    @Override    public void eat() {    }    @Override    public void swim() {    }}

5、迪米特原则

5.1、定义

一个对象应该对其他对象保持最少的了解,又叫最少知道原则。`尽量降低类与类之间的耦合`。优点:降低类之间的耦合。

5.2、代码演示

public class Boss {    public void commandCheckNumber(TeamLeader teamLeader){        teamLeader.checkNumberOfCourses();    }}public class Course {}public class TeamLeader {    public void checkNumberOfCourses() {        List courseList = new ArrayList();        for (int i = 0; i < 20; i++) {            courseList.add(new Course());        }        System.out.println("在线课程的数量是：" + courseList.size());    }}

public class Test {    public static void main(String[] args) {        Boss boss = new Boss();        TeamLeader teamLeader = new TeamLeader();        boss.commandCheckNumber(teamLeader);    }}

6、里氏替换原则

6.1、定义

所有引用基类(父类)的地方必须能透明地使用其子类的对象。通俗地讲,子类可以扩展父类的功能,但不能改变父类原有的功能。里氏替换原则意思说，在软件中将一个基类对象(父类)替换成它的子类对象，程序将不会产生任何错误和异常,反过来则不成立,如果一个软件实体使用的是一个子类对象的话,那么它不一定能够使用基类对象。里氏代换原则是实现开闭原则的重要方式之一,由于使用基类对象的地方都可以使用子类对象,因此在程序中尽量使用基类类型来对对象进行定义,而在程序运行时再确定其子类类型,用子类对象来替换父类对象。例如：我喜欢动物,那我一定喜欢狗,因为狗是动物的子类。但是我喜欢狗,不能据此断定我喜欢动物,因为我并不喜欢老鼠,虽然它也是动物。

6.2、实现原则

1) `子类可以实现父类的抽象方法,但是不能覆盖/重写父类的非抽象方法`。2) 子类中可以增加自己特有的方法。3) 当子类覆盖或实现父类的方法时,方法的前置条件(即方法的形参)要比父类方法的输入参数更宽松。4) 当子类的方法实现父类的抽象方法时,方法的后置条件(即方法的返回值)要比父类更严格。

参考: Java七大设计原则

7、组合/聚合复用原则

7.1、定义

尽量使用合成和聚合,而不是集成来达到复用的目的。该原则就是在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分,新的对象通过向这些对象的委派达到复用已有功能的目的。

"java软件设计七大原则的定义"的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注网站，小编将为大家输出更多高质量的实用文章！