老师寄生组合式少用了一次超类函数，但是又多写了一个函数啊

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // 寄生组合式继承 比 组合继承（组合继承调用了两次超类函数） 好一点？？
        // 函数接收两个参数 subType子类的构造函数 superType父类的构造函数
        function inheritPrototype(subType,surperType) {
            var prototype=Object.create(surperType.prototype);
            subType.prototype=prototype;
        }
        // surperType
        function People(name, age, sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
        People.prototype.sayHello = function () {
            console.log('你好我是' + this.name + '我的年龄是' + this.age + '我是' + this.sex + '生');
        };
        People.prototype.sleep = function () {
            console.log(this.name + 'zzzz');
        };
        // subType
        function Student(name, age, sex, school, studentNumber) {
            People.call(this,name, age, sex);
            this.school = school;
            this.studentNumber = studentNumber;
        }
 
        // 实现继承
        inheritPrototype(Student,People);  //老师这里要实现继承也要调用一次函数啊
        Student.prototype.study = function () {
            console.log(this.name + '学习了');
        }
        Student.prototype.exam = function () {
            console.log(this.name + '考试了');
        }
        Student.prototype.sayHello = function () {
            console.log(this.name + '敬礼');
        }
        // Student的实例
        var xiaogang = new Student('小刚', 12, '男', '艾利斯顿商学院', 10086);
        console.log(xiaogang.name);
        console.log(xiaogang.school);
        xiaogang.sayHello();
        xiaogang.exam()
        // Peopel实例
        var laozhao = new People('张继你', 55, '男');
        laozhao.sayHello();  
    </script>
</body>
</html>

下面是第二个问题：讲了这么多种继承，是不是最初的利用原型链实现继承最省内存呢？初了子类属性代码看起来没那么简洁之外。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // 利用原型链实现继承 子类拥有符类的所有属性和方法
        function People(name, age, sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
        People.prototype.sayHello= function () {
            console.log('你好我是' + this.name + '我的年龄是' + this.age + '我是' + this.sex + '生');
        };
        People.prototype.sleep= function () {
            console.log(this.name + 'zzzz');
        };
        // 子类也要被定义
        function Student(name, age, sex,school,studentNumber) {
            this.name = name;
            this.age = age;
            this.sex = sex;
            this.school=school;
            this.studentNumber=studentNumber;
        }
        // ***实现继承的关键语句！!!!
        Student.prototype=new People();
        Student.prototype.study=function() {
            console.log(this.name+'学习了');
        }
        Student.prototype.exam=function() {
            console.log(this.name+'考试了');
        }
        // 子类可以重写父类的方法
        Student.prototype.sayHello=function() {
            console.log(this.name+'敬礼');
        }
 
        // Student的实例
        var xiaogang=new Student('小刚',12,'男','艾利斯顿商学院',10086);
        console.log(xiaogang.name);
        console.log(xiaogang.school);
        xiaogang.sayHello();
        xiaogang.exam();
 
        // Peopel实例
        var laozhao=new People('张继你',55,'男');
        laozhao.sayHello();
        
    </script>
</body>
</html>

WYW265672 2022-05-10

源自：面向对象 8-8 寄生组合式继承

收起

1回答

好帮手慕星星 2022-05-11 10:18:57

同学你好，解答如下：

1、多写一个函数就是为了解决组合式继承中调用两次超类的情况。inheritPrototype函数中将超类的原型创建出一个新的对象，子类的原型指向这个对象，就继承了超类的原型。这样只在call()的时候调用一次超类。

虽然调用了一次inheritPrototype函数，但是没有再调用一次超类。

2、原型继承不是最省内存的，因为相同的属性在超类中有一份，子类中也有一份，都是私有的，实例化的时候都会创建一份各自的。

实际开发中一般用寄生组合式最多，因为属性只用了一份，超类只调用了一次。

祝学习愉快！

收起回答

提问者 WYW265672 #1

为什么多调用超类会比多调用其他函数费内存？

2022-05-11 11:52:41
好帮手慕星星回复提问者 WYW265672 #2

调用一次超类就会复制一份私有属性，例如原型继承（第二段代码）
继承了超类，但是没有传值，这样超类中的属性就没有值为undefined
浪费内存，是没必要的。而寄生组合式继承就没有多复制一份（第一段代码）
自己再理解下。

2022-05-11 17:47:05