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<Course> courseList = new ArrayList<Course>();
        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软件设计七大原则的定义”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注亿速云网站，小编将为大家输出更多高质量的实用文章！