2022-01-14

           构造函数绑定实现继承

  // function Person(){

        //     this.foot = 2

        // }

        // function Student(color,price){

        //     Person.call(this)

        // }

        // console.log( new Student('白色','100w') );

        /*

            父类 Car lunzi 4个

            子类 name price 是通过传参获得实际的值

            方法 打印出  例如 : 奔驰 100w 有 4 个轮子(从父类继承)

            使用call 来实现继承

        */

       /* 父类 gang (几缸 例如:3缸 4缸 gang需要传参)

       bsx(变速箱 例如:at变速箱 cvt变速箱 双离合变速箱 bsx需要传参) */

       /* 在子类print中 打印出 汽车名--价格--几个轮子--几缸发动机--什么变速箱 */

       /* 两种方式 分别使用call 和 apply */

       function Car(gang,bsx){

           this.lunzi = 4;

           this.gang = gang;

           this.bsx = bsx;

       }

       function Bc(name,price,gang,bsx){

           /* 把子类的this传给父类

           使用call来改变this指向,把父类中的this指向子类 */

        //    Car.call(this,gang,bsx);

           Car.apply(this,[gang,bsx])

           this.name = name;

           this.price = price;

           this.print = function (){

                document.write(`

                    ${this.name}--${this.price}--${this.lunzi}个轮子--${this.gang}--${this.bsx}

                `);

           }

       }

       let bc1 = new Bc('奔驰E300','55W','4缸','9AT变速箱');

       bc1.print();

       console.log(bc1);


利用空对象作为中介

 /**

         * @param 子类

         * @param 父类

         * */

        function extend(child, parent) {

            function f() { }

            f.prototype = parent.prototype;

            child.prototype = new f();

            child.prototype.constructor = child;

        }

        // Object.prototype.foot = 2;

        /*

            空对象,几乎不占内存

            修改Student的prototype对象,不会影响到Person的prototype对象

        */

        /* 父类 */

        function Person() { }

        Person.prototype.head = 1;

        Person.prototype.foot = 2;

        /* 子类想继承父类的属性 */

        function Student() { }

        /* 新建一个空对象 */

        //    function f(){}

        //    /* 把父类的原型直接赋值给空对象的原型上 */

        //    f.prototype = Person.prototype;

        //    /* 把空对象的实例化对象 给到子类的原型上  */

        //    Student.prototype = new f();

        //    /* ★constructor构造器都是指向自己的 */

        //    Student.prototype.constructor = Student;

        extend(Student, Person)

        let stu1 = new Student();

        console.log(stu1.foot);

        console.log(stu1);

        /* 不会影响到Person的prototype对象 */

        // Student.prototype.age = 30;

        //    let p = new Person();

        //    console.log(p);

        /* 原型链就是一层一层向上找的过程  */

        /* 原型链继承就是利用了上面这种特性 */

        /* 写一个类 Car color price 属性 */

        /* 类 Bmw 继承Car的所有属性 并实例化Bmw这个类

        写个方法可以把 color 和 price 打印到页面上 */

        function Car() {

        }

        Car.prototype.color = '白色'

        Car.prototype.price = '100w'

        // function f(){}

        // f.prototype = Car.prototype;

        // Bmw.prototype = new f();

        // Bmw.prototype.constructor = Bmw;

        extend(Bmw, Car)

        function Bmw() {

            this.print = function () {

                document.write(`${this.color}--${this.price}`);

            }

        }

        let b1 = new Bmw();

        b1.print();

你可能感兴趣的:(2022-01-14)