创建一个人的类然后继承学生类，教师类及家长类，分别通过三种不同的继承方式，总结优点缺点

将重复的属性以及方法，单独的放入一个构造函数里，其他的构造函数直接复用       

         function Ren(name,age){
            this.name=name
            this.age=age
        }
        Ren.prototype.move=function(){
            console.log(this.name+'在走路')
        }
        Ren.prototype.fangjia=function(){
            console.log(this.name+'正在放假')
        }

        1.原型继承:

        缺点：所有属性的值，只和创建Ren对象时保持一致

        属性(方法)查找方式：/先找 t1的构造函数内部，是否具有对应的属性，如果有直接输出，如果构造函数没有， 再找原型       

        function Student(name,age){

        }
        Student.prototype=new Ren("继承",21)
        Student.prototype.study=function(){
            console.log(this.name+"正在学习")
        }
        var t1=new Student("李白",18)
        console.log(t1)
        console.log(t1.name)
        console.log(t1)
        t1.study()
        var t2=new Student("杜甫",21)
        console.log(t2)
        var t3=new Student("苏轼",24)

        2.冒充继承：通过改变this的指向性，实现的继承方法

        缺点：无法继承原型，只是调用了一次函数

        this对象指向：指向对象

        函数调用：this指向三种  

            1.由new调用，指向构造函数创建出来的对象

            2.在window下调用，window对象

            3.对象中调用或者事件过程中调用， 指向调用的对象       

        function Teacher(name,age){
            //改变this的指向性
            Ren.call(this,name,age) //this指向  window
        }
        Teacher.prototype.shangke=function(){
            console.log(this.name+"说：开始上课")
        }
        var d1=new Teacher("欧阳修",38)
        console.log(d1) //没有属性、Ren中的this并没有指向 new创建的对象
        // d1.fangjia()//调用原型失败

        3.组合继承       

        function Jiazhang(name,age,a)
        {
           this.a=a
           Ren.call(this,name,age)
        }
        Jiazhang.prototype=new Ren()
        Jiazhang.prototype.zhengqian=function(){
            console.log(this.name+"在赚钱")
        }
        var c1=new Jiazhang("李世民",40)
        console.log(c1)
        c1.fangjia()