JavaScript中的继承

面向对象的编程思想
在看继承之前，先向下什么是面向对象的编程思想？
根据需求，分析对象，找到对象有什么特征和行为，通过代码的方式来实现需求。要想实现这个需求，就要创建对象，要想创建对象，就应该显示有构造函数，然后通过构造函数来创建对象，通过对象调用属性和方法来实现相应的功能及需求即可。

面向对象的特征：封装，继承，多肽

• 封装
  一个值存储在一个变量中 --封装
  一堆重复代码放到一个函数中 --封装
  一系列的属性放在一个对象中 --封装
  一些功能类似的函数（方法）放在一个对象中 --封装
  好多相类似的对象放在一个js文件中 --封装

• 继承
  首先继承是一种关系，类（class）与类之间的关系，JS中没有类，但是可以通过构造函数模拟类，然后通过原型来实现继承，继承也是为了数据共享，js中的继承也是为了实现数据共享

  • 原型作用之一:数据共享,节省内存空间
  • 原型作用之二:为了实现继承
  • 继承是一种关系:
    父类级别与类级别的关系

• 多肽
  一个对象有不同的行为,或者是同一个行为针对不同的对象,产生不同的结果,要想有多态,就要先有继承,js中可以模拟多态,但是不会去使用,也不会模拟,

---

例子:

    //人,都有姓名,性别,年龄, 吃饭, 睡觉, 玩
    //学生,都有姓名,性别,年龄, 成绩, 吃饭, 睡觉, 玩 ,学习的行为

    //js中通过原型来实现继承

    function Person(name,age,sex) {
      this.name=name;
      this.sex=sex;
      this.age=age;
    }
    Person.prototype.eat=function () {
      console.log("人可以吃东西");
    };
    Person.prototype.sleep=function () {
      console.log("人在睡觉");
    };
    Person.prototype.play=function () {
      console.log("生活就是不一样的玩法而已");
    };


    function Student(score) {
      this.score=score;
    }
    //改变学生的原型的指向即可==========>学生和人已经发生关系
    Student.prototype=new Person("小明",10,"男");
    Student.prototype.study=function () {
      console.log("学习很累很累的哦.");
    };

    //相同的代码太多,造成了代码的冗余(重复的代码)

    var stu=new Student(100);
    console.log(stu.name);//小明
    console.log(stu.age);//10
    console.log(stu.sex);//男
    stu.eat();//人可以吃东西
    stu.play();//生活就是不一样的玩法而已
    stu.sleep();//人在睡觉
    console.log("下面的是学生对象中自己有的");
    console.log(stu.score);//100
    stu.study();//学习很累很累的哦.

为了数据共享，改变原型的方向，做到了继承-----通过改变原型执行实现的继承
缺陷：因为改变原型指向的同时实现继承，直接初始化了属性，继承过来的属性的值都是一样的了，这就是问题，只能重新调用对象的属性进行重新赋值(如下)

       function Person(name,age,sex,weight) {
         this.name=name;
         this.age=age;
         this.sex=sex;
         this.weight=weight;
       }
       Person.prototype.sayHi=function () {
         console.log("您好");
       };
       function Student(score) {
         this.score=score;
       }
       //希望人的类别中的数据可以共享给学生---继承
       Student.prototype=new Person("小明",10,"男","50kg");
    
       var stu1=new Student("100");
       console.log(stu1.name,stu1.age,stu1.sex,stu1.weight,stu1.score);//小明 10 男 50kg 100
       stu1.sayHi();//您好
    
       var stu2=new Student("120");
       stu2.name="张三";
       stu2.age=20;
       stu2.sex="女";
       console.log(stu2.name,stu2.age,stu2.sex,stu2.weight,stu2.score);//张三 20 女 50kg 120
       stu2.sayHi();//您好
       var stu3=new Student("130");
       console.log(stu3.name,stu3.age,stu3.sex,stu3.weight,stu3.score);//小明 10 男 50kg 130
       stu3.sayHi();//您好

解决方案：继承的时候，不用改变原型的指向，直接调用父级的构造函数的方式来为属性赋值就可以了------借用构造函数：把要继承的父级的构造函数拿过来,使用一下就可以了
解决了属性继承，并且值不重复的问题
缺陷：父级类别中的方法不能继承

    function Person(name, age, sex, weight) {
      this.name = name;
      this.age = age;
      this.sex = sex;
      this.weight = weight;
    }
    Person.prototype.sayHi = function () {
      console.log("您好");
    };
    function Student(name,age,sex,weight,score) {
      //借用构造函数
      Person.call(this,name,age,sex,weight);
      this.score = score;
    }
    var stu1 = new Student("小明",10,"男","10kg","100");
    console.log(stu1.name, stu1.age, stu1.sex, stu1.weight, stu1.score);//小明 10 男 10kg 100

    var stu2 = new Student("小红",20,"女","20kg","120");
    console.log(stu2.name, stu2.age, stu2.sex, stu2.weight, stu2.score);//小红 20 女 20kg 120

    var stu3 = new Student("小丽",30,"妖","30kg","130");
    console.log(stu3.name, stu3.age, stu3.sex, stu3.weight, stu3.score);//小丽 30 妖 30kg 130

组合继承

原型继承+借用构造函数继承，这样的话，属性和方法都被继承了

    function Person(name,age,sex) {
      this.name=name;
      this.age=age;
      this.sex=sex;
    }
    Person.prototype.sayHi=function () {
      console.log("阿涅哈斯诶呦");
    };
    function Student(name,age,sex,score) {
      //借用构造函数:属性值重复的问题
      Person.call(this,name,age,sex);
      this.score=score;
    }
    //改变原型指向----继承
    Student.prototype=new Person();//不传值
    Student.prototype.eat=function () {
      console.log("吃东西");
    };
    var stu=new Student("小黑",20,"男","100分");
    console.log(stu.name,stu.age,stu.sex,stu.score);//小黑 20 男 100分
    stu.sayHi();//阿涅哈斯诶呦
    stu.eat();//吃东西
    var stu2=new Student("小黑黑",200,"男人","1010分");
    console.log(stu2.name,stu2.age,stu2.sex,stu2.score);//小黑黑 200 男人 1010分
    stu2.sayHi();//阿涅哈斯诶呦
    stu2.eat();//吃东西

拷贝继承

把一个对象中的属性或者方法直接复制到另一个对象中

• 第一种(改变了地址的指向，一个改变另一个也随着改变，不可取)

   var obj1={
     name:"小糊涂",
     age:20,
     sleep:function () {
      console.log("睡觉了");
     }
   };

   var obj2=obj1;
   console.log(obj2.name,obj2.age);//小糊涂 20
   obj2.sleep();//睡觉了
   obj2.age = 30
   console.log(obj1.name,obj1.age);//小糊涂 30

• 第二种

    function Person() {
    }
    Person.prototype.age=10;
    Person.prototype.sex="男";
    Person.prototype.height=100;
    Person.prototype.play=function () {
      console.log("玩的好开心");
    };
    var obj2={};
    //Person的构造中有原型prototype,prototype就是一个对象,那么里面,age,sex,height,play都是该对象中的属性或者方法

    for(var key in Person.prototype){
      obj2[key]=Person.prototype[key];
    }
    console.dir(obj2);
    obj2.play();//玩的好开心

总结继承

继承,类与类之间的关系,面向对象的语言的继承是为了多态服务的,
js不是面向对象的语言,但是可以模拟面向对象.模拟继承.为了节省内存空间
继承:

• 原型作用：数据共享 ，目的是:为了节省内存空间,
• 原型作用：继承 目的是:为了节省内存空间
• 原型继承：改变原型的指向
• 借用构造函数继承：主要解决属性的问题
• 组合继承:原型继承+借用构造函数继承：既能解决属性问题,又能解决方法问题
• 拷贝继承：就是把对象中需要共享的属性或者犯法,直接遍历的方式复制到另一个对象中

相关附加
JavaScript原型
JavaScript中原型的简单语法
JavaScript原型链
JavaScript中的继承