面向对象设计原则—单一、开闭、里氏替换原则

2024-02-22 17:33:04

昨天公司培训了面向对象设计原则—单一、开闭、里氏替换原则，听过之后感触很多，因为刚进公司，之前的代码毫无原则可言，乱乱糟糟的，之后按照规范重构，

很痛苦，感觉自己的代码就像是一坨翔，赶脚大姨夫捉急的都快提前了，代码规范这四个字真的是给我印象很深刻。

一。单一原则

定义：单一功能原则（Single responsibility principle）规定每个类都应该有一个单一的功能，并且该功能应该由这个类完全封装起来。所有它的（这个类的）服务都应该严密的和该功能平行（功能平行，意味着没有依赖）。（摘自百科全书）

这个我觉得他的字面意思应该是蛮好理解的，而且在前端中的话用的是比较多的，可以说无处不在吧，我的理解的话就是封装

 /**
   * @author 周靖松
   * @description:GET点击修改
   * @param id
   * @return: 
   */
  getUpdate(id) {
    return Vue.http
      .get(path + "/api/list/tabel/get/item/" + id)
  },

职责单一，请求就行

之前的代码我不是这样写的。。。之前什么传参 then（）赋值云云一些全堆一起，想想真觉得脑壳痛

二。开闭原则

定义：开闭原则是面向对象设计中最重要的原则之一，其它很多的设计原则都是实现开闭原则的一种手段。

对于扩展是开放的，对于修改是关闭的，这意味着模块的行为是可以扩展的。当应用的需求改变时，我们可以对模块进行扩展，使其具有满足那些改变的新行为。（百科全书）

//book 类
    class book{
        constructor(e){
            this.name=e.name
            this.money=e.money
        }
        look(){
            console.log(this.name,"这本书",this.money,"元")
        }
    }


    //正常一本书的价格
    js = new book({
        name:"js",
        money:10086
    })
    js.look()


    //比如现在想打折一本jq
    class Discount{//打折
        constructor(name,money){
            this.name=name,
            this.money=money*0.5
            return this.name + this.money 
        }
       
    }
    DiscountJq= new Discount("jq",10010)
    jq =new book (DiscountJq)

    jq.look()

对于扩展是开放的比如打折的话可以写一个打折的功能然后根据需求去使用，如果更改了父类的方法的话就会出现其他子类一起跟着变动

“开放”是为了更好的扩展，适应更多的相应需求。“关闭”是为了降低耦合，降低了维护难度和制作成本。

开闭原则是设计原则的基石，在所有的设计原则里边都能看到开闭原则的影子，比如说下边要说的里氏替换。

三。里氏替换

定义：派生类（子类）对象可以在程式中代替其基类（超类）对象。（百科全书）

说白了里氏替换原则，想表达的就是父类可以使用的方法，子类就一定要可以使用并达到相同的效果，但是反过来不一定

比如说子类可以拥有自己的方法

子类可以实现父类的抽象方法，但是不能覆盖。下边看一下违反了里氏替换会怎么样

  //book 类
    class book{
        constructor(e){
            this.name=e.name
            this.money=e.money
        }
        look(){
            console.log(this.name,"这本书",this.money,"元")
        }
    }


    //子类
    class subBook extends  book{
        look(){
            console.log(this.name,"这本书白送")
        }
    }
    
    

    subBookA =new book({
        name:"js",
        money:10000
    })
    subBookB =new subBook({
        name:"js",
        money:10000
    })


    subBookA.look()
    subBookB.look()

结果就是。。。。白瞎1W块因为在创建实例的时候，原型链是会先从实例上找的找不到的话才会往下找，

subBookB new的子类就等于实现了类似于重写的这么一个过程，他会先找子类的look 找到了就不会取用父类的look了，解决方案晚上回来补充

码农公寓

相关文章