1. es5中是怎么声明一个类的
   1. es5中是用函数来描写类的，对于一个类来说，肯定要有构造函数，构造函数解决什么问题呢，第一个是传参数，第二个是实例化，也就是
      初始化。
   2. 我们要想区分这个动物是什么类别，不能大家都长的一样吧，小猫小狗都是一个动物类别那肯定不可以的。这个时候要定义一个属性
      
      this.type = type
   3. 那这样一个类的声明基本上就做完了。
   4. 但是，特别要强调的点，这里只有属性，如果我想定义一个方法怎么办，如果你直接向设置属性一样设置一个方法，就会有一个问题，你
      每一个实例它都有这个方法，你可能会问每个对象下面不就应该type属性和eat方法吗，为什么这样是弊端呢。你想想，type也好
      eat也好，它是这个类应该共有的属性吗。就是说小猫小狗这个实例对象上它应该复用一些东西，比如说吃，动物这个类上就应该有这个方
      法，而不是让每个实例上都挂载这样一个方法。
      let Animal = function (type) { this.type = type this.eat = function () {} }
2. es5中生成一个实例对象
   let dog = new Animal('dog') let monkey = new Animal('monkey') console.log(dog) // Animal {type: 'dog', eat: f} console.log(monkey) // Animal {type: 'monkey', eat: f}
   dog实例对象也好monkey实例对象也好，这两个实例对象它有区别，比如说它们的type不一样，但是它们的eat一样吗，对于它俩来说
   是一样的，但是从这两个打印出来的对象来讲，它们各自有各自的eat，这个显然不对。既然它俩都应该继承一个父类，如果这样设计的
   话，那就是每个子类对象上都有父类的所有东西，这个不是很合理，至少eat这种它俩都共同有的东西你不应该再各自生成一份。打个比
   方，它俩eat应该是一样的是吧，因为都继承于父类，如果我把一个eat改掉，另一个的eat改了吗，是没改的，因为它实例化之后这是
   两个对象了，你改任何一个都不会影响另一个，这样的话就违背了继承的原则，什么叫继承，大家都继承于父类的eat，如果父类的eat
   被修改之后，那所有的实例对象都应该跟着改变，这才叫继承，如果做不到那就不对，一百个方法，你会发现每个对象下面都有一堆这玩意
   。显然这是不合理的。
3. 那我们遇到上面的问题应该怎么写呢
   把它们共有的方法写在这个类的原型上去，函数都有一个prototype这个对象，你可以往这个上面去写，也就是类继承的工作原理，它
   会沿着原型链一直往上找。你会发现eat没有了，它就是把eat挂在了这个原型链上去，它不在这个实例本身，而在它的原型链上

  let Animal = function (type) {
    this.type = type
  }
  Animal.prototype.eat = function () {}
  let dog = new Animal('dog')
  let monkey = new Animal('monkey')
  console.log(dog) // Animal {type: 'dog'}
  console.log(monkey) // Animal {type: 'monkey'}

1. 总结
   1. es5中在做类的定义的时候，如果你把所有共用的东西都写在函数体内部，这个是不合理的。正确的做法是，所有实例对象想共有的
      东西你要放在prototype上去。
   2. 为什么这样做还有第二个原因，你要把这个function当成一个构造函数去用，构造函数内部哪些是这个实例对象想自己独一份的
      东西你往里面放，大家通用的东西你放到原型链上去。

1. 定义类
   class Animal {}

2. 类定义完了，接着还是刚才那两个步骤，构造函数初始化传参，在es6中它的构造函数是这样的。
   构造函数就是为了传参的
   class Animal {
   // 构造函数
   constructor (type) {
   this.type = type
   }
   // 公用方法，挂载在原型上的方法
   eat () {

   }
   }
3. class只是es5用原型链声明类的一个语法糖，语法不一样，但最后的本质是一样的，这就是语法糖。

1. 如果你想保存一个私有属性private
2. 如果我想让我这个属性是只读的
   通过这两个点，我们引出es6中的getter和setter，也就是我们属性的读与写的操作，es6是如何做到属性的保护以及只读。

  class Animal {
    constructor (type) { 
      this.type = type
    }
    get age () {
      return 4
    }
    set age (val) {
      this.realAge = val // 这里不能再给age赋值了，不然就变成死循环了
    }
  }
  let dog = new Animal()
  console.log(dog.age) // 4
  dog.age = 5
  console.log(dog.age) // 4
  console.log(dog.realAge) // 5 

1. es5

  let Animal = function (type) {
    this.type = type
    this.eat = function () {}
  }
  Animal.prototype.eat = function () {

  }

1. es6

  class Animal {
    constructor (type) { 
      this.type = type
    }
    // 公用方法，挂载在原型上的实例对象的方法
    eat () { 
      Animal.walk()
    }
    // 定义类的静态方法
    static walk () {

    }
  }

1. es5, es6的静态方法只是在定义上有区别，在引用上大家都是一样的，因为静态方法就是属于类的，你调用的时候要用类去
   引用这个方法。
2. 在现实的业务开发中，什么时候用实例对象的方法，什么时候用类的静态方法。这个是要特别注意的。
   思考方式
   如果说你的这个方法依赖于对象的某些属性或者是方法，那这个方法就必须定义为类的实例对象方法。如果说我这个方法里面
   不会涉及到实例对象的内容，你就要用类的静态方法，类的静态方法拿不到当前的实例对象。如果你把这个方法定义为一个静
   态方法，那这个方法跟这个实例对象都绝缘了。要根据业务场景和代码设计去决定。它们本身之间没有优点和缺点。只是哪个
   更适合，哪个不适合。
   静态方法一般就是当作一个功能函数来用就好了。

1. es5

  let Animal = function (type) {
    this.type = type
  }
  Animal.prototype.eat = function () {

  }

• es5中继承有很多种实现方法

  let Dog = function () {
    Animal.call(this, 'dog')
  }

 Animal是父类，Dog是子类，Dog类要继承Animal类，你要做的第一件事情就是在Dog的构造函数中要执行Animal的构造
 函数，并且把实例对象的指针指向当前的Dog类。
 Dog.prototype = Animal.prototype

1. es6

  // 子类不声明构造函数，此时es6给你写了一个默认的constructor
  class Dog extends Animal {

  }
  // 子类声明构造函数
  class Dog extends Animal {
    constructor (type) {
      // super调用必须放到构造函数第一行，这个super就是父类的构造函数
      super(type)
    }
  }

1. 类的声明
2. 类的属性，getter和setter如何去做类的属性的读和写，功能上比es5强大了很多
3. 方法
4. 继承