java设计模式七大原则

最新推荐文章于 2023-07-24 20:59:01 发布
最新推荐文章于 2023-07-24 20:59:01 发布
阅读量291 收藏
点赞数
文章标签： java 设计模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YYBDESHIJIE/article/details/111476468
版权

1、设计模式的目的：

  • 编写软件的过程中，我们面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序（软件）具有更好的代码重用性，可读性，可扩展性，可靠性（当我们增加新的功能时，对原来的功能没有影响
    ），使程序呈现高内聚，低耦合的特性。
  • 设计模式包含了面向对象的精髓，“懂了设计模式，你就懂了面向对象分析和设计（OOA/D）的精要”

2、设计模式常用的七大原则：

设计模式的原则，其实就是我们在编程时，应当遵守的原则，也是各种设计模式的基础（即：设计模式为什么这样设计的依据）

2.1、 单一职责原则：

  1. 基本介绍：
    对类来说的，即一个类应该只负责一项职责，如类A负责两个不同职责：职责1，职责2.当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1,A2

  2. 示例：

public class Single {
    public static void main(String[] args) {
        Transportation transportation=new Transportation();
        transportation.run("火车");
        transportation.run("飞机");
    }

    public static class Transportation{
        public void run(String way){
            System.out.println(way+"在地上跑");
        }
    }
}

在这里插入图片描述
可以看到让一个类做两件事儿，上述写法就容易出错，不易维护，接着我们按照单一职责原则改进一下写法。

public class SingleOne {
    public static void main(String[] args) {
        TransportOne transportOne=new TransportOne();
        transportOne.run("火车");
        TransportTwo transportTwo=new TransportTwo();
        transportTwo.run("飞机");
        TransportThree transportThree=new TransportThree();
        transportThree.run("潜艇");
    }
    public static class TransportOne{
        public void run(String way){
            System.out.println(way+"在地上跑");
        }
    }
    public static class TransportTwo{
        public void run(String way){
            System.out.println(way+"在天上飞");
        }
    }

    public static class TransportThree{
        public void run(String way){
            System.out.println(way+"在水里游");
        }
    }
}

在这里插入图片描述
上述写法虽然实现了单一职责原则但开销较大，我们还可以用另一种写法实现。

public class SingleTwo {
    public static void main(String[] args) {
         Transport transport=new Transport();
         transport.runOne("火车");
         transport.runTwo("飞机");
         transport.runThree("潜艇");
    }

    public static class Transport{
        public void runOne(String way){
            System.out.println(way+"在地上跑");
        }

        public void runTwo(String way){
            System.out.println(way+"在天上飞");
        }

        public void runThree(String way){
            System.out.println(way+"在水里游");
        }
    }
}

在这里插入图片描述
可以看到，上述代码虽然实现了我们的目的，但并没有遵守单一职责原则，因为代码逻辑非常简单。
3. 单一职责原则注意事项和细节：
（1）降低类的复杂度，一个类只负责一项职责。
（2）提高类的可读性，可维护性。
（3）降低变更引起的风险。
（4）通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则。

2.2、接口隔离原则（Interface Segregation Princple）:

  1. 基本介绍：
    客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

2.3、依赖倒转原则（Dependence Inversion Priniiple）:

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


}
class Email{
    public String getMessage(){
        return "Email:Hello World";
    }
}

class Person{
    public  Person(Email email){
        System.out.println(email.getMessage());
    }
}

在这里插入图片描述
看到结果，让我们一起想一下这个问题：如果我想换一种方式显示信息呢？比如：WeiXin:Hello World,等其它方式呢？所以让我们换另一种方式去实现
（2）用接口实现：

public class TestTwo {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
        person.receive(new WeiXin());
    }
}
//只需要增加一个接口即可
interface Receive{
    public String getMessage();
}

class Email implements Receive{
    public String getMessage(){
        return "Email:Hello World";
    }
}

class WeiXin implements Receive{

    @Override
    public String getMessage() {
        return "WeiXin:Hello World";
    }
}

class Person{
    public void receive(Receive receive){
        System.out.println(receive.getMessage());
    }
}

在这里插入图片描述

  1. 依赖关系传递的三种方式和应用案例：
    （1）接口传递：
interface IOpenAndClose{
  public void open(ITv tv);//抽象方法，接收接口
}

interface ITV{//ITV接口
   public void play();
}

//实现接口
class OpenAndClose implements IOpenAndClose{
    public void open(ITv tv){
    tv.play();
    }
}

（2）构造方法传递：

interface IOpenAndClose{
  public void open();//抽象方法
}

interface ITV{//ITV接口
   public void play();
}

//实现接口
class OpenAndClose implements IOpenAndClose{
    public ITV tv;//成员
    public class OpenAndClose(ITV tv){//构造器
       this.tv=tv;
    }
    public void open(ITv tv){
    this.tv.play();
    }
}

（3）setter方式传递：

interface IOpenAndClose{
  public void open();//抽象方法
  public void setTv(ITV tv);
}

interface ITV{//ITV接口
   public void play();
}

//实现接口
class OpenAndClose implements IOpenAndClose{
    private ITV tv;//成员
    public class setTv(ITV tv){
       this.tv=tv;
    }
    public void open(ITv tv){
    this.tv.play();
    }
}
  1. 依赖倒转原则的注意事项和细节
    （1）底层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好。
    （2）变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间就存在一个缓冲层，利于程序扩展和优化
    （3）继承时遵循里氏替换原则

2.4、里氏替换原则：

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

public class ReplaceTest {
    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));//本意是求出11-3的结果
        System.out.println("1-8="+b.func1(1,8));//本意是求出1-8的结果
        System.out.println("11+3+9="+b.func2(11,3));
    }
}
class A{
    public int func1(int num1,int num2){
        return num1-num2;
    }
}

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

在这里插入图片描述

（3）问题提出：在编程中，如何正确的使用继承？=》里氏替换原则
2、基本介绍：
（1）里氏替换原则（Liskov Substitution Princple）在1988年，由麻省理工学院的一位姓里的女士提出来的。
（2）所有引用基类的地方必须能透明地使用其子类的对象。
（3）在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法。
（4）里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。
（5）通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系代替。
示例：

public class ReplaceTestTwo {
    public static void main(String[] args) {
        A1 a=new A1();
        System.out.println("11-3="+a.func1(11,3));
        System.out.println("1-8="+a.func1(1,8));

        System.out.println("-------------------------");
        B1 b=new B1();
        //因为B类不在继承A类，因此调用者不会在想到fun1是求减法了
        System.out.println("11+3="+b.func1(11,3));//本意是求出11-3的结果
        System.out.println("1+8="+b.func1(1,8));//本意是求出1-8的结果
        System.out.println("11+3+9="+b.func2(11,3));

        //使用组合任然可以使用到A类相关方法,但A和B的耦合性大大降低了
        System.out.println("11-3="+b.fun3(11,3));
    }
}
//创建一个更加基础的类
class Base{
    //把更加基础的写法和成员写到Base类
}
 class A1 extends Base{
    public int func1(int num1,int num2){
        return num1-num2;
    }
 }

 class B1 extends Base{
    //如果B需要使用A类的方法，使用组合关系
     private A1 a=new A1();
    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 fun3(int a,int b){
        return this.a.func1(a,b);
     }
}

在这里插入图片描述

2.5、开闭原则：

基础版示例：

public class Ocp {
    public static void main(String[] args) {
       GraphicEditor graphicEditor=new GraphicEditor();
       graphicEditor.drawRectangle(new Rectangle());
       graphicEditor.drawCircle(new Circle());
    }
}
//绘图类
class GraphicEditor{
    //接收Shape对象,然后根据type,来绘制不同的图形
    public void drawShape(Shape s){
       if(s.m_type==1) drawRectangle(s);
       if(s.m_type==2) drawCircle(s);
    }

    //绘制矩形
    public void drawRectangle(Shape r){
        System.out.println("绘制矩形！");
    }
    //绘制圆形
    public void drawCircle(Shape r){
        System.out.println("绘制圆形！");
    }
}
//shape类，基类
class Shape{
    int m_type;
}

//矩形
class Rectangle extends Shape{
    Rectangle(){
        super.m_type=1;
    }
}

//圆形
class Circle extends Shape{
    Circle(){
        super.m_type=2;
    }
}

在这里插入图片描述
分析：比较好理解，简单易操作，但违反了开闭原则（即对修改关闭（使用方），对扩展开发（提供方）），即当我们给类增加新功能的时候，尽量不修改代码或尽可能少修改代码。
基础版增加绘制三角形功能示例：

public class Ocp {
    public static void main(String[] args) {
       GraphicEditor graphicEditor=new GraphicEditor();
       graphicEditor.drawRectangle(new Rectangle());
       graphicEditor.drawCircle(new Circle());
       graphicEditor.drawTriangle(new Triangle());
    }
}
//绘图类
class GraphicEditor{
    //接收Shape对象,然后根据type,来绘制不同的图形
    public void drawShape(Shape s){
       if(s.m_type==1) drawRectangle(s);
       if(s.m_type==2) drawCircle(s);
       //改动3
        if(s.m_type==3)drawTriangle(s);
    }

    //绘制矩形
    public void drawRectangle(Shape r){
        System.out.println("绘制矩形！");
    }
    //绘制圆形
    public void drawCircle(Shape r){
        System.out.println("绘制圆形！");
    }

    //改动1：绘制三角形
    public void drawTriangle(Shape r){
        System.out.println("绘制三角形");
    }
}
//shape类，基类
class Shape{
    int m_type;
}

//矩形
class Rectangle extends Shape{
    Rectangle(){
        super.m_type=1;
    }
}

//圆形
class Circle extends Shape{
    Circle(){
        super.m_type=2;
    }

}
//改动2：新增三角形
class Triangle extends Shape{
    Triangle(){
        super.m_type=3;
    }
}

在这里插入图片描述
可以看到至少改动了3处
基于OCP原则进行改进：
改进思路：将Shape类改进为抽象类，并提供一个抽象方法draw方法，让子类去实现即可，这样有新的图形种类时，只需要让新的图形类继承Shape，并实现draw方法即可，使用方的代码就不需要修改，满足开闭原则。

public class Ocp {
    public static void main(String[] args) {
       GraphicEditor graphicEditor=new GraphicEditor();
       graphicEditor.drawShape(new Rectangle());
       graphicEditor.drawShape(new Circle());
    }
}
//绘图类
class GraphicEditor{
    //接收Shape对象,然后根据type,来绘制不同的图形
    public void drawShape(Shape s){
       s.draw();
    }

}
//shape类，基类
abstract class Shape{
    int m_type;
    public abstract void 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("绘制圆形");
    }
}

在这里插入图片描述
新增绘制三角形功能：
在这里插入图片描述
分析：代码满足OCP原则，对修改关闭，对扩展开放

2.6迪米特法则

2.6.1基本介绍：
（1）一个对象应该对其他对象保持最少的了解
（2）类与类关系越密切，耦合度越大
（3）迪米特法则（Demeter Principle）又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的public方法，不对外泄露任何信息。
（4）迪米特法则还有个更简单的定义：只与直接的朋友通信
（5）直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，耦合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

2.6.2应用实例：
（1）有一个学校，下属有各个学院和总部，现要求打印出学校总部员工ID和学院员工的id
(2)编程实现上面的功能，看代码演示：

import java.util.ArrayList;
import java.util.List;

public class Demeter1 {
    public static void main(String[] args) {
       //创建了一个SchoolManager对象
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());
    }
}

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = 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(){
        List<CollegeEmployee> list=new ArrayList<CollegeEmployee>();
        for (int i=0;i<10;i++){
            CollegeEmployee emp=new CollegeEmployee();
            emp.setId("学院员工id= "+i);
            list.add(emp);
        }
        return list;
    }
}

//学校管理类

//分析SchoolManager类的直接朋友类有哪些Employee、CollegeManager
//CollegeEmployee不是直接朋友而是一个陌生类，这样违背了迪米特法则
class SchoolManager{
    //返回学校总部的员工
    public List<Employee> getAllEmployee(){
        ArrayList<Employee> list= new ArrayList<>();

        for (int i=0;i<5;i++){
            Employee employee = new Employee();
            employee.setId("学校总部员工id= "+i);
            list.add(employee);
        }
        return list;
    }

    //输出学校总部和学院员工信息
    void printAllEmployee(CollegeManager sub){
        //分析问题
        //这里的CollegeEmployee 不是SchoolManager的直接朋友
        //CollegeEmployee是以局部变量方式出现在SchoolManager
        //违反了迪米特法则
        List<CollegeEmployee>list1=sub.getAllEmployee();
        System.out.println("---------分公司员工-------------");
        for (CollegeEmployee e:list1){
            System.out.println(e.getId());
        }

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

改进：

import java.util.ArrayList;
import java.util.List;

public class Demeter1 {
    public static void main(String[] args) {
        System.out.println("---------使用迪米特法则进行改进----------");
       //创建了一个SchoolManager对象
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());
    }
}

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = 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(){
        List<CollegeEmployee> list=new ArrayList<CollegeEmployee>();
        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=getAllEmployee();
        System.out.println("---------学院员工-------------");
        for (CollegeEmployee e:list1){
            System.out.println(e.getId());
        }

    }

}

//学校管理类

//分析SchoolManager类的直接朋友类有哪些Employee、CollegeManager
//CollegeEmployee不是直接朋友而是一个陌生类，这样违背了迪米特法则
class SchoolManager{
    //返回学校总部的员工
    public List<Employee> getAllEmployee(){
        ArrayList<Employee> list= new ArrayList<>();

        for (int i=0;i<5;i++){
            Employee employee = new Employee();
            employee.setId("学校总部员工id= "+i);
            list.add(employee);
        }
        return list;
    }

    //输出学校总部和学院员工信息
    void printAllEmployee(CollegeManager sub){
        //分析问题
        //这里的CollegeEmployee 不是SchoolManager的直接朋友
        //CollegeEmployee是以局部变量方式出现在SchoolManager
        //违反了迪米特法则
        //所以将输出学院员工的方法，封装到CollegeManager
        /*List<CollegeEmployee>list1=sub.getAllEmployee();
        System.out.println("---------学院员工-------------");
        for (CollegeEmployee e:list1){
            System.out.println(e.getId());
        }*/
        sub.printEmployee();
        List<Employee>list2=this.getAllEmployee();
        System.out.println("---------学校总部员工-------------");
        for (Employee e:list2){
            System.out.println(e.getId());
        }
    }
}

2.6.3总结：
1、迪米特法则注意事项和细节：
（1）迪米特法则的核心是降低类之间的耦合
（2）但是注意：由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类间（对象间）耦合关系，并不是要求完全没有依赖关系

2.7合成复用原则

2.7.1基本介绍：
原则是尽量使用合成或聚合的方式，而不是使用继承。

3设计原则核心思想

（1）找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
（2）针对接口编程，而不是针对实现编程。
（3）为了交互对象之间的松耦合设计而努力。

阿丩正传
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java设计模式-面向对象七大设计原则
02-06
例如：随着计算机的不断发展，程序学习这门技术也越来越重要，很多人都开启了学习java编程学习，本文就介绍了Java编程学习的七大基本原则。 面向对象设计原则一共有七个：开闭原则、里氏替换原则、依赖倒转原则、...
java设计原则
Temptatn的博客
07-24 584
单一职责原则：对一个类而言，应当只有一个引起它变化的原因，永远不要让一个类存在多个改变的理由。因此，一个类应该只做一个职责相关的业务，不要把过多的职责放在同一个类中完成。
Java设计模式之七大设计原则
热门推荐
qq_49529322的博客
04-28 1万+
Java设计模式之七大设计原则 本文对Java设计模式中的七大设计原则进行汇总介绍，提炼最核心的概念。 设计模式总结笔记 一、设计模式七大原则 设计模式的目的： 代码可重用性：相同功能的代码，不用多次编写。 可读性：编程规范性，便于其他程序员的阅读和理解。 可扩展性：当需要增加新的功能的时候，非常方便，称为可扩展性。 可靠性：当我们新增功能后，对原来的功能没有影响。 使程序呈现高内聚、低耦合特性。 1.1、单一职责原则 不遵守单一职责原则： 对类来说的，就是一个类应该只负责一项职责。 比如：Us
Java 设计原则：七种方法帮助你更好地设计软件
qq_35090943的博客
12-29 1081
总结一下，设计模式中的7大原则是：单一职责原则、开放封闭原则、里氏替换原则、依赖倒转原则、迪维恩原则、合成复用原则和接口隔离原则。这些原则都是在软件设计中常用的原则，它们可以帮助我们在设计软件系统时避免一些常见的问题。
Java 6大设计原则28大设计模式
z3191595的博客
03-24 3657
6大设计原则： 1. 单一职责原则 单一职责原则的英文名称是Single Responsibility Principle，简称是SRP（There should never be more than one reason for a class to change.） 见名知意，充斥着满满的争议，需求的更替，版本的迭代，场景的复杂，种种都能导致这个被破坏，但是把出发点是好的，单一意味着简单，简单意味着易懂，而后易维护、节省人力、成本、增加稳定性；但是场景复杂时就类就多了，em...；仁者见仁智者见
java 7大设计原则
wdquan19851029的专栏
04-23 1136
解释：B无意中重写的父类的func1方法， 原本func1 是 num1 - num2,重写后 变成 相加， 这样 如果是无意识的话，程序员本来要做 func1的相减功能，但是结果却是相加。一个类 对自己依赖的类知道的越少越好。1、父类中凡是已经实现好的方法，虽然他不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。2、如果一个类被其他类所继承，则当这个类需要任意修改，就必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都可能产生故障。
简述Java设计模式PPT
07-20
简单介绍了一下Java23种设计模式的概念，正式学习前可了解一下，还简单提到了面向对象七大设计原则和耦合的概念
java设计模式——单例模式
12-22
前天写的第一篇文章设计模式的七大原则，是我第一次写文章，目前看了浏览量，让我信心大增。文章有什么讲述方式不对的欢迎大家随时给我私信。24小时恭候！！（创作不易，还望各位仁兄看完举起小手点个小赞。） 一、...
图解Java设计模式（一）
06-12
本课程针对上述问题，有针对性的进行了升级 (1) 授课方式采用 图解+框架源码分析的方式，让课程生动有趣好理解 (2) 系统全面的讲解了设计模式,包括 设计模式七大原则、UML类图-类的六大关系、23种设计模式及其分类,...
Java中的设计模式.pptx
08-12
设计模式相关文档，从设计模式的概念、七大设计原则、UML类图以及常用的设计模式进行讲解。
Java程序设计六大原则&设计模式
sziitjin的博客
07-24 944
一个接口或者类只有一个原因引起变化，即一个接口或者类只有一个职责，负责一件事情。（此原则同样适用于方法）好处：1、复杂性降低；2、可读性提高；3、可维护性提高；4、变更风险降低。
设计模式的七大原则
sinat_34863938的博客
01-27 397
设计模式原则，其实就是程序员在编程时，应当遵守的原则， 也是各种设计模式的基础(即： 设计模式为什么这样设计的依据) 一、单一职责原则 对类来说的，即一个类应该只负责一项职责。 单一职责原则注意事项和细节 降低类的复杂度，一个类只负责一项职责。 提高类的可读性，可维护性 降低变更引起的风险 通常情况下， 我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则 二、接口隔离原则 客户端不应该依赖它不需要的接口，即一个类对另一.
Java中的七大设计原则
微笑听雨
05-06 9463
Java中的七大设计原则，也称为SOLID原则，是为了让程序（软件）具有更好的代码重用性，可读性，可扩展性，可靠性，使程序呈现高内聚，低耦合的特性。
Java中的七种设计原则
呜呜老司机的博客家园
05-15 918
简单介绍七种设计原则以及简单的代码例子
Java设计模式——六大设计原则
instancegameto
12-04 3269
1.单一职责原则单一职责原则的定义是类的变更的原因应该只有一个，它提出用“职责”和“变化原因”来衡量接口或类设计得是否优良，但是这两个因素都是因项目而异因环境而异的，并没有一个量化的标准 单一职责原则使类的复杂性降低，实现什么职责都有清晰的定义，复杂性降低后可读性也就提高了，可读性提高也就更容易进行维护了。如果接口的单一职责做的好，一个接口修改只对相应的实现类有影响，对系统的扩展性和可维护性也有很
JAVA的七大设计原则
TDtuohai的博客
07-24 343
定义一个类对自己依赖的类知道的越少越好。实现开闭原则的关键是抽象化，并且从抽象化导出具体化实现，如果说开闭原则是面向对象设计的目标的话，那么依赖倒转原则就是面向对象设计的主要手段。3、方法返回值的类A类中的方法M2的返回值为B->publicBM2(){}A与B是直接朋友。一旦一个接口太大，则需要将它分割成一些更细小的接口，使用该接口的客户端仅需知道与之相关的方法即可。分析接口隔离原则针对的是接口类，与单一职责原则的区别就是单一原则针对的是实现类，两者区分的维度不一样。...
【java】面向对象的七大设计原则
Ez4Sterben的博客
07-10 841
面向对象的七大设计原则
设计模式七大原则
十年一梦的博客
07-19 253
单一职责原则：一个类只负责一项职责，如果类A负责两个不同的职责，职责1与职责2，当职责1需求变更改变A时，可能造成职责2执行错误，所以将A的粒度分解为A1，A2 1) 降低类的复杂度，一个类只负责一项职责。 2) 提高类的可读性，可维护性 3) 降低变更引起的风险 4) 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中 方法数量足够少，...
java 设计模式 七大原则
最新发布
09-14
Java设计模式的七大原则包括： 1) 单一职责原则：一个类应该只有一个引起变化的原因，即一个类应该只有一个职责。 2) 接口隔离原则：客户端不应该依赖它不需要的接口。应该将接口细分为更小的接口，以便于客户端只...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值