7大设计原则

7大设计原则

单一职责(Signle Responsibility Principle)
  1. 降低类的复杂度,一个类只负责一项职责
  2. 提高类的可读性,可维护性
  3. 降低变更引起的风险
  4. 通常情况下,我们应当遵守单一职责原则,只有逻辑足够简单,才可以在代码级违反单一职责原则,只有类中方法数量足够少,可以在方法级保持单一职责原则
package com.zho.test.single_responsibility;

import java.util.Vector;

public class SingleResponsibility1 {
    public static void main(String[] args) {
        Vehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("摩托车");
        Vehicle airVehicle = new AirVehicle();
        airVehicle.run("飞机");
        Vehicle waterVehicle = new WaterVehicle();
        waterVehicle.run("船");
    }
}

//交通工具类
interface Vehicle {
    public void run(String vehicle);
}

class RoadVehicle implements Vehicle {

    @Override
    public void run(String vehicle) {
        System.out.println(vehicle + "在公路运行");
    }
}

class AirVehicle implements Vehicle {

    @Override
    public void run(String vehicle) {
        System.out.println(vehicle + "在天上飞");
    }
}

class WaterVehicle implements Vehicle {
    @Override
    public void run(String vehicle) {
        System.out.println(vehicle + "在水里跑");
    }
}

接口隔离原则 (Interface Segregation Principle)

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

public class InterfaceSegregation1 {
    public static void main(String[] args) {
        A a = new A();
        //A类通过接口去依赖B类
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());


        C c = new C();
        //C类通过接口去依赖D类
        c.depend1(new D());
        c.depend4(new D());
        c.depend5(new D());
    }
}


//接口1
interface Interface1 {
    void operation1();
}

//接口2
interface Interface2 {
    void operation2();

    void operation3();
}

//接口3
interface Interface3 {
    void operation4();

    void operation5();
}

class B implements Interface1, Interface2 {

    @Override
    public void operation1() {
        System.out.println("B 实现了 operation1");
    }

    @Override
    public void operation2() {
        System.out.println("B 实现了 operation2");
    }

    @Override
    public void operation3() {
        System.out.println("B 实现了 operation3");
    }
}

class D implements Interface1, Interface3 {

    @Override
    public void operation1() {
        System.out.println("D 实现了 operation1");
    }

    @Override
    public void operation4() {
        System.out.println("D 实现了 operation4");
    }

    @Override
    public void operation5() {
        System.out.println("D 实现了 operation5");
    }
}

class A {//A类通过接口Interface1,Interface2 依赖B类,但是只会用到1,2,3 方法

    public void depend1(Interface1 i) {
        i.operation1();
    }

    public void depend2(Interface2 i) {
        i.operation2();
    }

    public void depend3(Interface2 i) {
        i.operation3();
    }
}

class C { //C类通过接口Interface1,Interface3 依赖D类, 但是只会用刮刀1,4,5方法
    public void depend1(Interface1 i) {
        i.operation1();
    }

    public void depend4(Interface3 i) {
        i.operation4();
    }

    public void depend5(Interface3 i) {
        i.operation5();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5DAjKxmM-1600670830917)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\image-20200921084947391.png)]

依赖倒转原则 (Dependence Inversion Principle)
  1. 高层模块不应该依赖底层模块,二者都应该依赖器抽象
  2. 抽象不应该依赖细节,细节应该依赖抽象
  3. 依赖倒转的中心思想是面向接口编程
  4. 依赖倒转原则是基于这样的设计理念: 相对于细节的多变性,抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中,抽象指的是接口或抽象类,细节就是具体的实现类
  5. 使用接口或抽象类的目的是制定好规范,而不涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成
public class DependenceInversion1 {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}

//完成Person接受消息的功能
interface Info {
    String getInfo();
}
class Email implements  Info {

    @Override
    public String getInfo() {
        return "电子邮件信息: hello Email";
    }
}
class Person {
    public void receive(Info info) {
        System.out.println(info.getInfo());
    }
}

//通过构造方法依赖传递
interface IOpenAndClose {
    void open();
}
interface ITV{ // ITV接口
    void play();
}
class OpenAndClose implements IOpenAndClose {
    public ITV itv;

    public OpenAndClose(ITV itv) {
        this.itv = itv;
    }

    @Override
    public void open() {
        this.itv.play();
    }
}
class ChangHong implements ITV {

    @Override
    public void play() {
        System.out.println("长虹电视机打开了");
    }
}
 //通过构造方法依赖传递
 public static void func2() {
     ChangHong changHong = new ChangHong();
     OpenAndClose openAndClose = new OpenAndClose(changHong);
     openAndClose.open();
 }
//通过setter方法传递
interface IOpenAndClose {
    void open();

    void setTv(ITV itv);
}

interface ITV {
    void play();
}

class OpenAndClose implements IOpenAndClose {
    private ITV itv;


    @Override
    public void open() {
        this.itv.play();
    }

    @Override
    public void setTv(ITV itv) {
        this.itv = itv;
    }
}
class ChangHong implements ITV {

    @Override
    public void play() {
        System.out.println("长虹电视机打开了");
    }
}
 //通过setter方法传递
 public static void func3() {
     OpenAndClose openAndClose = new OpenAndClose();
     openAndClose.setTv(new ChangHong());
     openAndClose.open();
 }
里氏替换原则 (Lishov Substitution Principle)

OO总的继承性的思考和说明

  1. 继承包含这样一层含义:父类中凡是已经实现好的方法,实际上是在设定规范和契约,虽然它不强制要求所有子类必须遵守这些契约,但是如果子类对这些已经实现的方法任意修改,就会对整个继承体系造成破坏
  2. 继承在给程序设计带来便利的同时,也带来了弊端,比如使用继承会给程序带来侵入性,程序的可移植性降低,增加对象间的耦合性,如果一个类被其他类所继承,则当这个类需要修改时,必须考虑到所有子类,并且父类修改后,所有涉及到子类的功能都有可能产生故障

里氏替换原则

  1. 如果对每个类型为T1的对象o1,都有类型为T2的对象o2,使得以T1定义的所有程序P在所有的对象o1都替换成o2时,程序P的行为没有发生变化,那么类型T2时类型T1的子类型,换句话说,所有引用基类的地方必须能透明的使用其子类的对象
  2. 在使用继承时,遵循里氏替换原则,在子类中尽量不要重写父类的方法
  3. 里氏替换原则告诉我们,继承实际上让两个类耦合性增强了,在适当的情况下,可以通过聚合,组合,依赖来解决问题
public class LiskovSubstitution1 {
    public static void main(String[] args) {

        A a = new A();
        System.out.println("11 - 3 = " + a.func1(11, 3));
        System.out.println("1 - 8 = " + a.func1(1, 8));
        System.out.println("--------------------");


        B b = new B();
        System.out.println("11 - 3 = " + b.func1(11, 3));
        System.out.println("1 - 8 = " + b.func1(1, 8));
        System.out.println("11 + 3 + 9 = " + b.func2(11, 3));

    }
}

class A {
    public int func1(int a, int b) {
        return a - b;
    }
}

//增加了一个新功能:完成两个类相加,然后和9求和 (本意)
class B extends A {
	//这里重写了A类的方法,可能是无意识的
    public int func1(int a, int b) {
        return a + b;
    }

    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }
}

我们发现原来运行正常的相减功能发生了错误,原因就是类B无意间重写了父类的方法,造成原有功能出现错误,在实际编程中,我们常常会通过重写父类的方法完成新的功能,这样写起来虽然简单,但整个继承体系的复用性就会比较差,特别是运行多态比较频繁的时候

通用的做法是:原来的父类和子类都继承一个更通俗的基类,原有的继承关系去掉,采用依赖,聚合,组合等关系替代

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

        A a = new A();
        System.out.println("11 - 3 = " + a.func1(11, 3));
        System.out.println("1 - 8 = " + a.func1(1, 8));
        System.out.println("--------------------");


        B b = new B();
        //因为B类不再继承A类,因此调用者不再认为func1是求减方法
        System.out.println("11 + 3 = " + b.func1(11, 3));
        System.out.println("1 + 8 = " + b.func1(1, 8));
        System.out.println("11 + 3 + 9 = " + b.func2(11, 3));

        //使用组合仍然可以使用到A类相关方法
        System.out.println("11 - 3 = " + b.func3(11, 3));
    }
}

//创建一个更加基础的基类
class Base {

}

class A extends Base {
    public int func1(int a, int b) {
        return a - b;
    }
}

//增加了一个新功能:完成两个类相加,然后和9求和 (本意)
class B extends Base {
    //如果B需要使用A类的方法,使用组合关系
    private A a = new A();

    //这里重写了A类的方法,可能是无意识
    public int func1(int a, int b) {
        return a + b;
    }

    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }

    //我们仍然想使用A的方法
    public int func3(int a, int b) {
        return this.a.func1(a, b);
    }
}
开闭原则 (Open Closed Principle)
  1. 一个软件实现如类,模块和函数应该对扩展开放,对修改关闭,用抽象构建框架,用实现扩展细节
  2. 当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是铜鼓哦修改已有的代码来实现变化
public class OpenClosed1 {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
        graphicEditor.drawShape(new OtherGraphic());
    }
}

abstract class Shape {
    int m_type;

    public abstract void draw();
}
class GraphicEditor {
    public void drawShape(Shape s) {
        s.draw();
    }
}
class Rectangle extends Shape {

    Rectangle() {
        super.m_type = 1;
    }

    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

class Circle extends Shape {

    Circle() {
        super.m_type = 2;
    }

    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

class Triangle extends Shape {

    Triangle() {
        super.m_type = 3;
    }

    @Override
    public void draw() {
        System.out.println("绘制三角形");
    }
}

//新增一个图形
class OtherGraphic extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制其他图形");
    }
}
迪米特法则 (Demeter Principle)
  1. 一个对象应该对其他对象保持最少的了解
  2. 类与类关系越密切,耦合度越大
  3. 迪米特法则又叫最小知道原则,即一个类对自己依赖的类知道的越少越好,也就是说,对于被依赖的类不管多么复杂,都尽量将逻辑封装在类的内部,对外除了提供的public方法,不对外泄露任何信息
  4. 迪米特法则还有个更简单的定义,只与直接的朋友通信
  5. 直接的朋友:每个对象都会与其他对象有耦合关系,只要两个对象之间有耦合关系,我们就说这两个对象之间是朋友关系,耦合的方式很多,依赖,关联,组合,聚合等,其中,我们中出现成员变量,方法参数,方法返回值中的类为直接的朋友,而出现在局部变量中的类不是直接的朋友,也就是说,陌生的类最好不要以局部变量的形式出现在类的内部
//有一个学校,下属有各个学院和总部,
//现要求打印出学校总部员工id和学院员工的id
public class Demeter1 {
    public static void main(String[] args) {
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());
    }
}

//学校总部员工
class Employee {
    private String id;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

//学院员工
class CollegeEmployee {
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

//管理学院员工的管理类
class CollegeManager {
    public List<CollegeEmployee> getAllEmployee() {
        ArrayList<CollegeEmployee> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id = " + i);
            list.add(emp);
        }
        return list;
    }
}

class SchoolManager {
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Employee emp = new Employee();
            emp.setId("学校总部员工id = " + i);
            list.add(emp);
        }
        return list;
    }

    void printAllEmployee(CollegeManager collegeManager) {

        //1、这里的CollegeEmployee不是SchoolManager的直接朋友
        //2、CollegeEmployee 是以局部变量的方式出现在SchoolManager中

        List<CollegeEmployee> list1 = collegeManager.getAllEmployee();
        System.out.println("------分公司员工--------");
        for (CollegeEmployee collegeEmployee : list1) {
            System.out.println(collegeEmployee.getId());
        }

        List<Employee> list2 = this.getAllEmployee();
        System.out.println("-------学校总部员工--------");
        list2.forEach(c -> {
            System.out.println(c.getId());
        });
    }
}

改进

//有一个学校,下属有各个学院和总部,
//现要求打印出学校总部员工id和学院员工的id
public class Demeter1 {
    public static void main(String[] args) {
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());
    }
}

//学校总部员工
class Employee {
    private String id;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

//学院员工
class CollegeEmployee {
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

//管理学院员工的管理类
class CollegeManager {
    public List<CollegeEmployee> getAllEmployee() {
        ArrayList<CollegeEmployee> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id = " + i);
            list.add(emp);
        }
        return list;
    }
    //输出学院员工的信息
    public void printEmployee() {
        List<CollegeEmployee> list1 = this.getAllEmployee();
        System.out.println("------分公司员工--------");
        for (CollegeEmployee collegeEmployee : list1) {
            System.out.println(collegeEmployee.getId());
        }
    }
}

class SchoolManager {
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Employee emp = new Employee();
            emp.setId("学校总部员工id = " + i);
            list.add(emp);
        }
        return list;
    }

    void printAllEmployee(CollegeManager collegeManager) {

        //1 将输出学院的员工方法,封装到CollegeManager
        collegeManager.printEmployee();


        List<Employee> list2 = this.getAllEmployee();
        System.out.println("-------学校总部员工--------");
        list2.forEach(c -> {
            System.out.println(c.getId());
        });
    }
}
合成复用原则 (Composite Reuse Principle)

原则是尽量使用合成/聚合的方式,而不是使用继承

©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页