考察方式：

07-面向对象 - 图1

类的声明：

  1. 通过构造函数声明
  2. ES6 class关键字声明
    1. //构造函数声明-this
    2. function Animal(){
    3. this.name='name'
    4. }
    5. //class关键字声明
    6. class Animal2{
    7. constructor(){
    8.  this.name="name1"
    9. }
    10. }

类的实例化：

  1. 用new关键字实例化
    1. new 类名（参数）

类的继承：

避免直接操作proto

  1. 借助构造函数实现继承:子类不能继承父类的原型对象上的方法
  2. 借助原型链实现继承：因为引用了同一个对象，导致继承自同一父类的两个子类之间 不能相互隔离
  3. 组合方式实现继承：父类的构造函数会执行两遍
  4. 组合方式优化1：不能判断是由子类实例化还是父类实例化
  5. 组合方式优化2：
  6. es6关键字实现继承：
  1. // 借助构造函数实现继承
  2. function Parent1(){
  3.   this.name="parent"
  4. }
  5. Parent1.prototype.say=function(){console.log(hello)}
  6. function Child1(){
  7.   //apply也可以，改变函数运行上下文
  8.   Parent1.call(this)
  9.   this.type="child1"
  10. }
  11. console.log(new Child1().say())//报错
  12. //借助原型链实现继承
  13. function Parent2(){
  14.   this.name="andy"
  15. }
  16. function Child2() {
  17.   this.type="整数"
  18. }
  19. Child2.prototype=new Parent1()
  20. //组合方式实现继承
  21. function Parent3() {
  22.   this.name="bob"
  23.   this.play=[1,2,3]
  24. }
  25. function Child3() {
  26.   Parent3.call(this)
  27.   this.type="浮点数"
  28. }
  29. Child3.prototype=new Parent3()
  30. var s1=new Child3()
  31. var s2=new Child3()
  32. //组合继承的优化1
  33. function Parent4() {
  34.   this.name="bob"
  35.   this.play=[1,2,3]
  36. }
  37. function Child4() {
  38.   Parent3.call(this)
  39.   this.type="浮点数"
  40. }
  41. Child4.prototype=Parent4.prototype
  42. //组合继承的优化
  43. function Parent5() {
  44.   this.name="bob"
  45.   this.play=[1,2,3]
  46. }
  47. function Child5() {
  48.   Parent5.call(this)
  49.   this.type="浮点数"
  50. }
  51. Child5.prototype=Object.create(Parent5.prototype)
  52. Child5.prototype.constructor=Child5
  1. //ES6实现
  2. class ColorPoint extends Point {
  3.   constructor(x, y, color) {
  4.     super(x, y); // 调用父类的constructor(x, y)
  5.     this.color = color;
  6.   }
  8.   toString() {
  9.     return this.color + ' ' + super.toString(); // 调用父类的toString()
  10.   }
  11. }