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

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

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

一。单一原则

定义：单一功能原则（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了，解决方案晚上回来补充