里氏替换原则

里氏替换：

　　子类能够替换父类，出现在父类能够出现的任何地方，子类必须完全实现父类的方法。在类中调用其他类时务必要使用父类，如果不能使用父类，则说明类的设计已经违背了原则。覆盖或实现父类的方法时输入参数可以被放大。即子类可以重载父类的方法，但输入参数不比父类方法中的小，这样在子类代替父类的时候，调用的仍然是父类的方法。

　　里氏替换原则是针对继承而言的，如果继承是为了实现代码重用，也就是为了共享方法，那么共享的方法应该保持不变，不被子类重新定义。如果继承是为了多态那么，而多态的前提是子类覆盖父类的方法所以将父类定义为抽象类，抽象类不能够实例化对象也就不存在替换这一说。

　　

 “子类可以扩展父类的功能，但不能改变父类原有的功能！！！！” 

百度百科定义：

里氏替换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为

 LSP所表述的就是在同一个继承体系中的对象应该有共同的行为特征

类“鸟”中有个方法飞，企鹅自然也继承了这个方法，可是企鹅不能飞阿，于是，我们在企鹅的类中覆盖了飞方法，告诉方法的调用者：企鹅是不会飞的。这完全符合常理。但是，这违反了LSP，企鹅是鸟的子类，可是企鹅却不能飞！需要注意的是，此处的“鸟”已经不再是生物学中的鸟了，它是软件中的一个类、一个抽象
继承机制的优点：

代码共享，减少创建类的工作量
提高代码的重用性；
子类可以形似父类，又异于父类；
提高父类的扩展性，实现父类的方法即可随意而为；
继承机制的缺点：

继承是入侵性的（只要继承，就必须拥有父类的所有属性与方法）；
降低了代码的灵活性（子类拥有了父类的属性方法，会增多约束）；
增强了耦合性（当父类的常量、变量、方法被修改时，必需要考虑子类的修改）。

class Shape {
  constructor() {
	this.ant='蚁群'
  }
}

class Rectangle extends Shape {
  constructor() {
	super();
    this.ant='蚁后'
	this.action='啥也不干'
  }

  setactions(dance) {
     this.action=dance
  }

  getArea() {
    return this.ant + this.action;
  }
}

class Square extends Shape {
  constructor() {
	super();
    this.ant='蚁后'
	this.action='啥也不干'
  }

  setaction(high) {
    this.action = high;
  }

  getArea() {
    return this.ant + this.action;
  }
} 

function renderLargeShapes(shapes) {
  shapes.forEach((shape) => {
  console.log(shape)
    switch (shape.constructor.name) {
      case 'Square':
        shape.setaction('跳高');
		break;
      case 'Rectangle':
        shape.setactions('跳舞');
		break;
    }

    let area = shape.getArea();
	console.log(area)
  })
}

let shapes = [new Rectangle(), new Square()];
renderLargeShapes(shapes);