精华内容
下载资源
问答
  • java 七大设计原则之迪米特原则,开闭原则,合成复用原则 ---文字代码相结合理解七大设计原则有哪些?为什么要使用七大设计原则?迪米特原则开闭原则合成复用原则**设计原则的核心思想** 七大设计原则有哪些? 单一职责...

    java 七大设计原则之迪米特原则,开闭原则,合成复用原则
    ---文字代码相结合理解

    七大设计原则有哪些?

    • 单一职责原则
    • 接口隔离原则
    • 依赖倒转(倒置)原则
    • 里氏替换原则
    • 开闭原则
    • 迪米特法则
    • 合成复用原则

    通常大家理解的是前六个,并没有合成复用原则

    为什么要使用七大设计原则?

    • 代码重用性(相同的代码不用多次编写);
    • 可读性(编程的规范性,便于其他程序员的阅读和理解);
    • 可拓展性(当需要添加新的功能时,非常的方便也称为可维护性);
    • 可靠性(当我们添加新的功能后对原来的功能没有影响);
    • 使程序呈现高内聚,低耦合等特性

    迪米特原则

    迪米特原则定义:

    • 一个对象应该对其他对象保持最少的了解
    • 类与类的关系越密切,耦合度越大
    • 迪米特法则还有个更简单的定义:只与直接朋友通信

    迪米特法则又叫最少知道原则,即一个类对自己依赖的类知道的越少越好,也就是说,对于被依赖的类不管多复杂,都尽量将逻辑封装在类的内部,对外提供public方法,不对外泄露信息

    什么是直接朋友:

    在一个类中:全局变量,返回值,参数传递就称之为直接朋友,

    局部变量就称之为陌生朋友

    来看一段通俗易懂的代码:

    public class A {}
    public class B {}
    public class C {}
    public class D {}
    public class E {}
    
    public class B {
       public A mA;
    
       public C getC(){
           return null;
       }
    
       public void showD(){
           D d = new D();
       }
    
       public void setA(E e){
    
       }
    }
    

    在B类中:

    • public A mA; 全局变量
    • public C getC(){ 返回值
      return null;
      }
    • public void showD(){ 局部变量(违反迪米特原则)
      D d = new D();
      }
    • public void setA(E e){} 参数传递

    在这里A,C,E就是B的直接朋友,D就是B的陌生朋友

    未遵守迪米特原则代码:

    public class Student{
        String name = "";
        public Student(String name) {
            this.name = name;
        }
    }
    
    public class StudentManager {
        public void getStudentNumber(Student student){
            ArrayList<String> list = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                list.add(student.name+i);
                Log.i("dimiter:","现在是第 "+i+"个学生,名字为: "+list.get(i));
            }
            Log.i("dimiter:","总共有 "+list.size()+"个学生 ");
        }
    }
    
    //使用代码:
    //迪米特原则
    StudentManager studentManager = new StudentManager();
    studentManager.getStudentNumber(new Student("张三"));
    

    分析:

    • 学生类(Student) 有neme参数(学生姓名)
    • 学生管理类(StudentManager)创建10个学生,并输出学生名字

    违反迪米特原则代码:

    代码图(1.1):


    为什么违反迪米特原则:

    迪米特原则又叫做最少知道原则,首先要理解:

    • 何为最少知道原则,意思就是:两个类之间耦合性特别低,耦合性特别低就代表他们之间交互特别少,即一个类对自己依赖的类知道的越少越好,在代码图(1.1)这个例子中可以看出,StudentManager()类对Studnet()类创建了10个学生名字.知道的太多了

    • 不对外泄露信息:代码图(1.1)红框的代码,应该是在Student()内部完成,然后StudentManager()直接调用的

    大白话解释:StudentManager()需要所有学生,正确的应该是Student()吧所有学生直接给StudentManager(),而不是给一个Student()对象,让StudentManager()自己去计算所有学生,在大白话一点就是:我问你要什么你就给我什么,不要让我来计算(一个类对自己依赖的类知道的越少越好),你的东西也别让我知道(不对外泄露信息)

    还是比较绕口,来看看遵守迪米特原则的代码就直接恍然大悟了~

    遵守迪米特原则:

    public class Student{
        String name = "";///学生名字
        
         ///用来存储所有学生名字
        ArrayList<String> mList = new ArrayList<>();
    
        public Student(String name) {
            this.name = name;
        }
    
         /// 遵守迪米特原则 创建10个学生
        public List<String> newStudentName(){
            for (int i = 0; i < 10; i++) {
                mList.add(name+i);
                Log.i("dimiter:","现在是第 "+i+"个学生,名字为: "+mList.get(i));
            }
            return mList;
        }
    }
    
    public class StudentManager {
        public void getStudentNumber(Student student) {
            /// 遵守迪米特原则
            List<String> list = student.newStudentName();
            Log.i("dimiter:", "总共有 " + list.size() + "个学生 ");
        }
    }
    
    //使用代码:
    //迪米特原则
    StudentManager studentManager = new StudentManager();
    studentManager.getStudentNumber(new Student("张三"));
    

    Student()创建10个学生,然后给到StudentManager()遵守了:

    最少知道(迪米特)原则一个类对自己依赖的类知道的越少越好并且不对外泄露信息,

    一个对象应该对其他对象保持最少的了解

    这里的最少了解就是指10个Student()学生

    我只知道你有10个学生,不管你这10个学生是怎么来的

    效果图(2.1):

    开闭原则

    开闭原则定义:

    • 开闭原则是编程中最基础,最重要的设计原则
    • 一个软件实体如类,模块和方法应该对拓展开放(对提供方),对修改关闭(对使用方),用抽象构建框架,用实现拓展细节(细节指实现代码)
    • 当软件需求要变化时,尽量通过拓展软件的实体的行为来实现变化,而不是通过修改已有的代码来实现变化
    • 遵守其他原则,以及使用设计模式的目的就是遵守开闭原则

    未遵守开闭原则代码:

    //形状类型
    public abstract class Shape {
        /**
         * 用来判断类型
         * 1:Circular 圆形
         * 2:Rectangle 矩形
         */
        int type;
    }
    
    //圆形
    public class Circular extends Shape {
        public Circular() {
            type = 1;
        }
    }
    
    //矩形
    public class Rectangle extends Shape {
        public Rectangle() {
            type = 2;
        }
    }
    //开闭原则Manager类 
    public class OpenManager {
        public void showShape(Shape shape){
            if (shape .type == 1) {
                drawCircular(shape);
            }else if (shape.type == 2){
                drawRectangle();
            }
        }
    
        private void drawRectangle() {
            Log.i("Open","创建矩形 ");
        }
        private void drawCircular(Shape shape) {
            Log.i("Open","创建圆形 ");
        }
    }
    
    //使用代码:
     //开闭原则
    OpenManager openManager = new OpenManager();
    openManager.showShape(new Circular());//创建圆
    openManager.showShape(new Rectangle());//创建矩形 
    

    效果图(2.2):

    为什么没有遵守开闭原则:

    开闭原则的最关键的定义是:

    拓展开放(对提供方),对修改关闭(对使用方),用抽象构建框架,用实现拓展细节(细节指实现代码)

    如果说我现在要新加一个三角形我该怎么做呢?

    是这样写?

    public class Triangle  extends Shape{
        public Triangle() {
            type = 3;
        }
    }
    
    public class OpenManager {
        public void showShape(Shape shape){
            if (shape .type == 1) {
                drawCircular();//创建圆
            }else if (shape.type == 2){
                drawRectangle();//创建矩形
            }else if(shape.type == 3){
                drawTriangle();//创建三角形
            }
        }
        private void drawTriangle() {
            Log.i("Open","创建三角形 ");
        }
    }
    //使用代码
    //开闭原则
    OpenManager openManager = new OpenManager();
    openManager.showShape(new Circular());
    openManager.showShape(new Rectangle());
    openManager.showShape(new Triangle());
    

    效果图(2.3):


    这样写不仅在改的过程中容易导致代码的冲突,而且通过if else判断

    如果我有100个图形呢?判断100次吗?

    if lese if lese if lese if lese if lese if lese if lese if lese if lese if lese…?

    这样写出错率太高了,而且没有遵守到拓展开放,修改关闭

    遵守开闭原则代码:

    public abstract class Shape {
        public abstract void showShape();
    }
    
    public class Circular extends Shape {
        @Override
        public void showShape() {
            Log.i("Open","创建圆形 ");
        }
    }
    
    public class Triangle  extends Shape{
        @Override
        public void showShape() {
            Log.i("Open","创建三角形 ");
        }
    }
    
    public class Rectangle extends Shape {
        @Override
        public void showShape() {
            Log.i("Open","创建矩形 ");
        }
    }
    
    public class OpenManager {
        public void showShape(Shape shape){
            //遵守开闭原则
            shape.showShape();
        }
    }
    
    //使用代码:
    //开闭原则
    OpenManager openManager = new OpenManager();
    openManager.showShape(new Circular());
    openManager.showShape(new Rectangle());
    openManager.showShape(new Triangle());
    
    

    分析:

    • 可以看出,即使现在新增加了一个三角形类(Triangle),只要继承自Shape就可以画出来,而且不用if else来判断,代码逻辑非常清晰
    • 这才是真正的对扩展开发,对修改关闭,即使我现在在增加一个椭圆形,我自需要继承自Shape()然后输出一下即可
    public class Ellipse  extends Shape{
        @Override
        public void showShape() {
            Log.i("Open","我是新创建的椭圆形哦");
        }
    }
     //开闭原则
    OpenManager openManager = new OpenManager();
    openManager.showShape(new Circular());
    openManager.showShape(new Rectangle());
    openManager.showShape(new Triangle());
    openManager.showShape(new Ellipse());//创建椭圆形
    

    依赖倒置原则有点类似,只不过依赖倒置原则是通过接口来实现,开闭原则是通过抽象来实现.

    合成复用原则

    合成复用原则定义:

    软件复用时,要尽量先使用组合或者聚合等关联关系来实现,其次才考虑使用继承关系来实现


    通常类的复用分为继承复用和合成复用两种,继承复用虽然有简单和易实现的优点,但它也存在以下缺点

    • 继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类,父类对子类是透明的,所以这种复用又称为“白箱”复用。
    • 子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化,这不利于类的扩展与维护。
    • 它限制了复用的灵活性。从父类继承而来的实现是静态的,在编译时已经定义,所以在运行时不可能发生变化

    大白话翻译:
    尽量不要继承,如果继承的话子类与父类耦合度高,父类对于子类是透明的.不利于维护,如果非要复用的话可以使用组合/聚合的方式.

    不了解组合/聚合没关系,下一章我会详细介绍类与类之间的关系!

    设计原则的核心思想

    • 找出应用中可能需要的变化之处,把他们独立出来,不要和那些不需要变化的代码混在一起。
    • 面向接口编程,而不是针对实现编程。
    • 为了交互对象之间的松耦合设计而努力。
    • 拓展开放(对提供方),对修改关闭(对使用方),用抽象构建框架,用实现拓展细节(细节指实现代码)

    迪米特(最少知道)原则代码

    开闭原则

    设计模式总结:

    • 开闭(OCP)原则: 拓展开放,修改关闭
    • 接口隔离原则:类之间的依赖关系应该建立在最小的接口上
    • 单一职责原则:一个类负责一项职责,而不是一个类负责一个职责
    • 依赖倒置原则:面向接口编程
    • 里氏替换原则:在继承时,在子类中尽量不要去重写父类的方法,如果非要使用,可以使用聚合,组合,依赖来解决问题,不要修改父类的方法!
    • 迪米特(最少知道)原则:只与直接朋友通信,一个类对自己依赖的类知道的越少越好,不对外泄露信息
    • 合成复用原则:要尽量使用组合或聚合的关系来实现,其次在考虑继承

    猜你喜欢:

    去设计模式/设计原则目录页

    原创不易,记得点个赞哦~

    展开全文
  • 浅谈java开闭原则

    2020-12-05 18:52:51
    理解最基础的开闭原则的理念 关键字 开闭原则 一、定义 一个软件的实体如类,模块和函数应该对扩展开放对修改关闭 用抽象构件框架,有实现扩展细节 优点 提高软件系统的可复用性及维护性 二、使用及场景 1 酒店有...

    前言

    点石化为金,人心犹未足


    目标

    理解最基础的开闭原则的理念

    关键字

    开闭原则

    一、定义

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

    二、使用及场景

    1 酒店有时候会对房间进行打折和优惠券活动。需要扩展原有代码,扩展功能
    1.1 创建接口

    /**
     * Created by xiaojinlu1990@163.com on 2020/12/5 0005.
     */
    public interface IHotel {
    
        public String getHotelName();
        public String getHotelRoom();
        public String getDate();
        public float getPrice();
    
    }
    

    1.2 实现接口

    /**
     * Created by xiaojinlu1990@163.com on 2020/12/5 0005.
     */
    public class CtripHotelSon extends CtripHotel {
    
    
        public float getNewPrice() {
            return (float) (super.getPrice()*0.5);
        }
    }
    
    

    1.3 增加优惠券,扩展接口

    
    /**
     * Created by xiaojinlu1990@163.com on 2020/12/5 0005.
     */
    public class CtripHotel implements IHotel {
        @Override
        public String getHotelName() {
            return "肖村大酒店";
        }
    
        @Override
        public String getHotelRoom() {
            return "9527";
        }
    
        @Override
        public String getDate() {
            return "new date()";
        }
    
        @Override
        public float getPrice() {
            return 20;
        }
    }
    

    1.4 实例实现

    
    /**
     * Created by xiaojinlu1990@163.com on 2020/12/5 0005.
     */
    public class Demo
    {
        public static void main(String[] args) {
            IHotel hotel = new CtripHotelSon();
    
            //添加打折行为
            CtripHotelSon hotelSon = (CtripHotelSon) hotel;
    
            System.out.printf("hotelName="+hotel.getHotelName()
                    +",hotelRoom="+hotel.getHotelRoom()
                    +",hotelDate="+hotel.getDate()
                    +",hotelPrice="+hotel.getPrice()
                    +",hotelNewPrice="+hotelSon.getNewPrice());
        }
    
    }
    
    

    UML
    在这里插入图片描述

    总结

    基础原则很重要

    参考

    多留言多点赞你们的只支持是我坚持下去的动力,都支棱起来!!!

    展开全文
  • 一、概念 1、定义: 一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。用抽象构建框架,用实现扩展细节 ...二、开闭原则简单示例 1、示例1 (1)、定义一个课程接口 package com.rf.rules; /** * @D...

    一、概念

    1、定义:

    • 一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。用抽象构建框架,用实现扩展细节

    2、简单理解定义:

    • 当软件需要变化时,尽量通过扩展软件实体的行为类实现变化,而不是通过修改已有代码来实现变化

    3、优点:

    • 提高软件系统的可复用性及维护性

    二、开闭原则简单示例

    1、示例1

    • 不使用开闭原则,j计算出课程的id、名称和价格

    (1)、定义一个课程接口

    package com.rf.rules;
    
    /** 
    * @Description: 定义一个课程接口
    * @Param:  
    * @Author: xz  
    * @return: 
    * @Date: 2020/5/2 17:42  
    */ 
    public interface ICourse {
    
        //获取课程id
        Integer getId();
        //获取课程名称
        String getName();
        //获取课程价格
        Double getPrice();
    
    }
    

    (2)定义一个java课程类实现课程接口,并重写方法

    package com.rf.rules;
    
    /**
     * @description: java课程类实现课程接口,并重写方法
     * @author: xiaozhi
     * @create: 2020-05-02 17:43
     */
    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)定义一个测试类,测试获取课程相关信息

    package com.rf.rules;
    
    /**
     * @description: 测试类
     * @author: xiaozhi
     * @create: 2020-05-02 17:58
     */
    public class Test {
        public static void main(String[] args) {
            ICourse iCourse=new JavaCourse(1,"java课程",300d);
            System.out.println("java课程id:"+iCourse.getId()+" \n"+"java课程名称:"+iCourse.getName()+" \n"+"java课程价格:"+iCourse.getPrice());
    }
    
    

    (4)输出结果如下:
    在这里插入图片描述
    2、示例2:

    • 使用开闭原则,在不改变示例1的代码基础上,计算出打折后的java课程价格

    (1)、定义一个课程接口

    package com.rf.rules;
    
    /** 
    * @Description: 定义一个课程接口
    * @Param:  
    * @Author: xz  
    * @return: 
    * @Date: 2020/5/2 17:42  
    */ 
    public interface ICourse {
    
        //获取课程id
        Integer getId();
        //获取课程名称
        String getName();
        //获取课程价格
        Double getPrice();
    
    }
    
    

    (2)、定义一个java课程类实现课程接口,并重写方法

    package com.rf.rules;
    
    /**
     * @description: java课程类实现课程接口,并重写方法
     * @author: xiaozhi
     * @create: 2020-05-02 17:43
     */
    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的折扣价格课程(在示例1的基础上多了一个java折扣价格类)

    package com.rf.rules;
    
    /**
     * @description: java的扩展类,java的折扣价格课程
     * @author: xiaozhi
     * @create: 2020-05-02 18:02
     */
    public class JavaDiscountCourse extends JavaCourse{
    
        public JavaDiscountCourse(Integer id, String name, Double price) {
            super(id, name, price);
        }
    
        //获取java打8折的折扣价
        @Override
        public Double getPrice(){
            return  super.getPrice()*0.8;
        }
        //获取原价
        public Double getOriginPrice(){
            return super.getPrice();
        }
    }
    
    

    (4)定义一个测试类,测试获取课程相关信息及折扣的价格

    package com.rf.rules;
    
    /**
     * @description: 测试类
     * @author: xiaozhi
     * @create: 2020-05-02 17:58
     */
    public class Test {
        public static void main(String[] args) {
          
            ICourse iCourse=new JavaDiscountCourse(1,"java课程",300d);
            JavaDiscountCourse javaDiscountCourse=(JavaDiscountCourse)iCourse;
            System.out.println("java课程id:" + javaDiscountCourse.getId() + " \n" + "java课程名称:" + javaDiscountCourse.getName() + " \n" + "java课程原价格:" + javaDiscountCourse.getOriginPrice() + " \n" + "java课程折扣价格:" + javaDiscountCourse.getPrice());
        }
    }
    
    

    (5)输出结果如下:
    在这里插入图片描述

    三、类之间关系图如下:

    在这里插入图片描述

    四、理解开闭原则定义

    当我们的java课程类(JavaCourse)增加折扣价格功能的时候,通过创建一个java折扣课程类(JavaDiscountCourse)来扩展java课程类的功能,尽量通过扩展软件实体的行为类实现变化,而不是通过修改已有代码来实现变化。

    展开全文
  • 开闭原则是编程中最基础、最重要的设计原则 一个软件实体,如类,模块和函数应该对扩展开放(对提供方),对修改关闭(对使用方)。用抽象构建框架,用实现扩展细节。 当软件需要变化时,尽量通过扩展软件实体的行为来...

    1、基本介绍

    • 开闭原则是编程中最基础、最重要的设计原则
    • 一个软件实体,如类,模块和函数应该对扩展开放(对提供方),对修改关闭(对使用方)。用抽象构建框架,用实现扩展细节。
    • 当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化
    • 编程中遵循其它原则,以及使用设计模式的目的就是遵循开闭原则。

    2、应用实例

    绘图功能,类图如下:

    在这里插入图片描述

    2.1未遵循开闭原则

    优点是比较好理解,简单操作。

    缺点是违反了设计模式的ocp原则,即对扩展开放(提供方),对修改关闭(使用方)。即当给类增加新功能的时候,尽量不修改代码,或者尽可能少修改代码。

    比如要新增加一个图形种类:三角形时,修改的地方较多

    package com.weirdo.principle.ocp;
    public class Ocp {
        public static void main(String[] args) {
            GraphicEditor graphicEditor = new GraphicEditor();
            graphicEditor.drawShape(new Rectangle());
            graphicEditor.drawShape(new Circle());
            graphicEditor.drawShape(new Triangle());
        }
    }
    //这是一个用于绘图的类[使用方]
    class GraphicEditor {
        //接收Shape对象,然后根据type,来绘制不同的图形
        public void drawShape(Shape s) {
            if (s.m_type == 1) {
                drawRectangle(s);
            } else if (s.m_type == 2) {
                drawCircle(s);
            } else if (s.m_type == 3) {
                drawTriangle(s);
            }
        }
        //绘制矩形
        public void drawRectangle(Shape r){
            System.out.println("绘制矩形");
        }
        //绘制圆形
        public void drawCircle(Shape r){
            System.out.println("绘制圆形");
        }
        //绘制三角形
        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;
        }
    }
    class Triangle extends Shape{
        Triangle(){
            super.m_type=3;
        }
    }
    

    2.2遵循开闭原则

    把创建Shape类做成抽象类,并提供一个抽象的draw方法,让子类去实现即可,这样有新的图形种类时,只需要让新的图形类继承Shape,并实现draw方法即可,使用方的代码就不需要修改(满足了开闭原则)

    package com.weirdo.principle.ocp.improve;
    public class Ocp {
        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 {
        //接收Shape对象,调用draw方法
        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{
        OtherGraphic(){
            super.m_type=4;
        }
        @Override
        public void draw() {
            System.out.println("绘制其它图形");
        }
    }
    
    展开全文
  • 设计原则-开闭原则 (OCP) ????文章示例代码???? 定义 一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。 开闭原则强调的是用抽象构建框架,用实现来扩展细节。 场景示例 笔者这里以超市中的商品做一个...
  • 遵循开闭原则的软件,在保持灵活性时兼备扩展性和延续性。优点包括: 便于测试。每次只需要测试扩展部分即可; 提高代码复用性; 提高代码可维护性。 实现方法 开闭原则是其它原则的基础,核心就是抽象。个人...
  • JAVA代码设计六大原则理解

    千次阅读 2017-10-13 23:54:16
    JAVA代码设计六大原则的理解记得有一次去面试的时候,面试官问了我好几个问题,很尴尬,好几个都没能流利得回答上来。对其中有一个问题比较深刻,他当时是这样问我的:说下代码优化的6大原则...开闭原则 里氏替换原则
  • Java设计模式–开闭原则 说明:软件实体(模块,类,方法等)因该对扩展开放,对修改关闭 (software entities(modules,classes,functions,etc)should be open for extension,but closed for modlification)。通俗的...
  • 浅谈开闭原则

    千次阅读 2020-09-03 19:02:02
    开闭原则java 6大基本原则之一,而6大原则在软件开发中属于内功心法的存在,需要长期进行修炼,才能有所成就。今天就单独谈谈“开闭原则”,它的定义是:对扩展开放、对修改关闭。简单、直白的定义,确很难理解它...
  • java 七大设计原则之依赖倒置,里氏替换原则,文字代码相结合理解七大设计原则有哪些?为什么要使用七大设计原则?...开闭原则 迪米特法则 合成复用原则 通常大家理解的是前六个,并没有合成复用原则 为什么要使用
  • 六大原则单一职责原则里氏替换原则依赖倒置原则接口隔离原则迪米特原则开闭原则单一职责概念:对功能进行分类,代码进行解耦栗子:一个网络请求框架大致分为:请求类,缓存类,配置类;不能把这三个功能混合在一起,...
  • 设计模式目的: 1.重用性 :相同能能的代码,不用多次编写 2.可读性 :编程规范性 3.可扩展性 :当需要增加新的功能时成本低 4.可靠性 :当增加/减少新功能,对原来功能没有影响 ...5.开闭原则 6.迪米特原则 7...
  • 开闭原则 单一职责 概念:对功能进行分类,代码进行解耦 栗子:一个网络请求框架大致分为:请求类,缓存类,配置类;不能把这三个功能混合在一起,必须分成三个类分别去实现不同的功能 里氏替换 ...
  • 开闭原则 单一职责 概念:对功能进行分类,代码进行解耦 栗子:一个网络请求框架大致分为:请求类,缓存类,配置类;不能把这三个功能混合在一起,必须分成三个类分别去实现不同的功能 里氏替换 概念:在...
  • 七大软件设计原则七大软件设计原则一、Open-Closed Principle开闭原则1、开闭原则定义2、开闭原则优点3、案例代码(1)、书籍接口代码(2)、Java类书籍(3)、Java类折扣书籍(4)、增加JavaDiscountPrice类的前后...
  • 开闭原则-ocp (工厂模式用到了这个) 迪米特法则 合成复用原则 1.1单一职责原则 概念:对类来说:一个类应该只负责一个职责。 如果A负责两个职责,A1.A2,为了避免职责A1发生变更后,影响职责A2的执行,需要把A...
  • java oo原则_OO原则

    2021-02-28 07:10:06
    OCP(开闭原则,Open-ClosedPrinciple):一个软件的实体应当对扩展开放,对修改关闭。我的理解是,对于一个已有的软件,如果需要扩展,应当在不需修改已有代码的基础上进行。DIP(依赖倒转原则,...
  • (1)开闭原则 说起开闭原则,大家基本都听说过,开指的是对扩展是开放的,闭指的是对修改是关闭的。 言下之意就是对于某个代码块或者功能方法,在原有的基础上进行扩展(个人理解可以为继承并在子类中新增方法,...
  • java 七大设计原则之迪米特原则,开闭原则,合成复用原则(文字代码相结合理解) Android studio UML建模 java 类与类之间的关系 设计模式 java 设计模式之 建造型:单例模式(一) java 设计模式之 建造型:工厂方法/抽象...
  • 文章目录Java面向对象程序设计的六大基本原则一、开闭原则定义:二、里氏代换原则1.定义2、理解三、依赖倒置原则定义理解四、接口隔离原则定义理解接口隔离原则跟单一职责原则区别。五、迪米特法则定义理解六、单一...
  • java软件设计模式原则

    2020-08-03 17:37:31
    开闭原则 由 勃兰特·梅耶提出:软件实体应当对扩展开放,对修改关闭。 简单理解:当应用的需求改变时,在不修改软件实体的源代码或者二进制代码的前提下,可以扩展模块的功能,使其满足新的需求。 实现方法:通过...
  • 封装性:把具体实现的方法封闭起来,把方法的使用开放出去,开闭原则,把可修改的部分私有,把可扩展的部分开放出去,意义就是应该通过扩展来实现代码的变化,而不是修改源代码,这样提高稳定性以及灵活性,(例子:...
  • 前言软件设计原则是Java开发中的内功心法,在日常开发中或许并不是随时可用,但用心观察,在一个好的框架中,它一定占有极大的位置,掌握好软件的设计原则,能够使我们写出更优质的代码一、开闭原则定义一个软件实体...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 128
精华内容 51
关键字:

java开闭原则代码理解

java 订阅