面向对象-原型链及组合继承

原型链： 当我们访问对象的一个属性和方法时，他会先在对象中寻找，如果有直接使用，如果没有则会去原型对象中寻找，如果找到则直接使用，如果还没有则去原型中寻找，直到找到object对象的原型，object对象的原型没有原型，如果在object原型中依旧没有找到，则返回undefined

原型链继承： 将父类的实例化对象，赋值给子类的原型。
优点: 类似于复制了一个对象，构造函数和原型中所有的数据都可以获取到
缺点:
1.原型类继承自身没有办法传参
2.父类所有的属性方法都可以被子类共享

        //父类 被拿过去的
        function Parent(name,age){
            this.name = name;
            this.age = age;
        }

        Parent.prototype.love = function(){
            console.log("小屁孩")
        }
        
        let par= new Parent("小明","50")
        //子类 谁要用谁就是子类
        function Ding(name,sex,age){

            //构造函数继承  又叫类式继承
            Parent.call(this,name,age)
            this.h = "d";
        }
        Ding.prototype = new Parent();        

类式继承无法获取父类的原型链
原型链继承，无法直接给父类传参
组合继承 ：类式继承 + 原型链继承。结合了两则的优势，弥补了各自的缺点

        let d= new Ding("小明","男","20");
        console.log(d.name);
        d.love();
        
        //定义一个构造函数
        function Parent_One_1(){
            this.name = name;
            this.age  = age;
            this.sex  = sex;
            this.a    = "10";
            this.hoppy=function(){
                console.log("喜欢敲代码")
            }
        }

        Parent.prototype.jida =function(){
            console.log("考不好，吊起来打")
        }

        function Parent_One_2(name,sex,age,score){
            Parent_One_1.call(this,name,sex,age)
            this.score = score;
        }
        //这种写法和类式继承，部分重叠,继承了构造函数两次 导致内存加剧
        // Parent_One_2.prototype = new Parent_One_1();

        //换一种写法 原型链继承 直接继承父类的话，会出现传址的问题
        Parent_One_2.prototype = Parent_One_1.prototype

        let s1 = new Parent_One_2();
        s1.jida();