美文网首页
Web前端------JS高级继承的实现方式

Web前端------JS高级继承的实现方式

作者: Peak_One | 来源:发表于2018-07-07 18:35 被阅读61次
    原型实现继承
    <!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>title</title>
  <script>

    /*
    *
    * 面向对象编程思想:根据需求,分析对象,找到对象有什么特征和行为,通过代码的方式来实现需求,要想实现这个需求,就要创建对象,要想创建对象,就应该显示有构造函数,然后通过构造函数来创建对象.,通过对象调用属性和方法来实现相应的功能及需求,即可
    * 首先JS不是一门面向对象的语言,JS是一门基于对象的语言,那么为什么学习js还要学习面向对象,因为面向对象的思想适合于人的想法,编程起来会更加的方便,及后期的维护....
    * 面向对象的编程语言中有类(class)的概念(也是一种特殊的数据类型),但是JS不是面向对象的语言,所以,JS中没有类(class),但是JS可以模拟面向对象的思想编程,JS中会通过构造函数来模拟类的概念(class)
    *
    *
    *
    *
    * 小明,小红，小丽，小白，小花 都是人
    * 共同的特征和行为
    * 特征--->属性
    * 行为---方法
    *
    * 面向对象的特性:封装,继承,多态
    *
    * 封装:就是包装
    * 一个值存储在一个变量中--封装
    * 一坨重复代码放在一个函数中--封装
    * 一系列的属性放在一个对象中--封装
    * 一些功能类似的函数(方法)放在一个对象中--封装
    * 好多相类似的对象放在一个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);
    console.log(stu.sex);
    stu.eat();
    stu.play();
    stu.sleep();
    console.log("下面的是学生对象中自己有的");
    console.log(stu.score);
    stu.study();


  </script>
</head>
<body>


</body>
</html>
    借用构造函数实现继承
    <!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>title</title>
  <script>
    //    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);
    //    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);
    //    stu2.sayHi();
    //    var stu3=new Student("130");
    //    console.log(stu3.name,stu3.age,stu3.sex,stu3.weight,stu3.score);
    //    stu3.sayHi();


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


    //解决方案:继承的时候,不用改变原型的指向,直接调用父级的构造函数的方式来为属性赋值就可以了------借用构造函数:把要继承的父级的构造函数拿过来,使用一下就可以了



    //借用构造函数:构造函数名字.call(当前对象,属性,属性,属性....);
    //解决了属性继承,并且值不重复的问题
    //缺陷:父级类别中的方法不能继承

    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);

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

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


  </script>
</head>
<body>


</body>
</html>
    组合继承
    <!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>title</title>
  <script>


    //原型实现继承
    //借用构造函数实现继承
    //组合继承:原型继承+借用构造函数继承

    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);
    stu.sayHi();
    stu.eat();
    var stu2=new Student("小黑黑",200,"男人","1010分");
    console.log(stu2.name,stu2.age,stu2.sex,stu2.score);
    stu2.sayHi();
    stu2.eat();

    //属性和方法都被继承了



  </script>
</head>
<body>


</body>
</html>
    拷贝继承
    <!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>title</title>
  <script>

    //拷贝继承；把一个对象中的属性或者方法直接复制到另一个对象中

//    var obj1={
//      name:"小糊涂",
//      age:20,
//      sleep:function () {
//       console.log("睡觉了");
//      }
//    };
//
//    //改变了地址的指向
//    var obj2=obj1;
//    console.log(obj2.name,obj2.age);
//    obj2.sleep();



//    var obj1={
//      name:"小糊涂",
//      age:20,
//      sleep:function () {
//        console.log("睡觉了");
//      }
//    };
//
//
//    var obj2={};
//    for(var key in obj1){
//      obj2[key]=obj1[key];
//    }
//    console.log(obj2.name);



    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();



  </script>
</head>
<body>


</body>
</html>
    继承总结
    //面向对象特性:封装,继承,多态

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

//继承:
/*
* 原型作用: 数据共享 ，目的是:为了节省内存空间,
* 原型作用: 继承  目的是:为了节省内存空间
*
* 原型继承:改变原型的指向
* 借用构造函数继承:主要解决属性的问题
* 组合继承:原型继承+借用构造函数继承
* 既能解决属性问题,又能解决方法问题
* 拷贝继承:就是把对象中需要共享的属性或者犯法,直接遍历的方式复制到另一个对象中
* */
    浅拷贝
    <!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>$永远的24k纯帅$</title>
  <script>
    //浅拷贝:就是把一个对象的地址拷贝到另一个对象中,指向相同,对象中的属性或者方法都是一起拷贝过去的

    //浅拷贝,把一对象A中的内容直接拷贝到对象中B中
    var obj1={
      name:"风斯托罗斯基",
      age:20,
      car:["奔驰","宝马","奥拓"]
    };

    var obj2={};
    function extend(a,b) {
      //把a对象中的东西,拷贝到b对象中
      for(var key in a){
        b[key]=a[key];
      }
    }
    extend(obj1,obj2);


    console.dir(obj1);
    console.dir(obj2);
  </script>
</head>
<body>


</body>
</html>
    深拷贝
    <!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>$永远的24k纯帅$</title>
  <script>
    //深拷贝:把一个对象中的属性,依次的,一个一个的复制到另一个对象中
    var obj1={
      name:"风斯托罗斯基",
      age:20,
      car:["奔驰","宝马","奥拓"],
      dog:{
        name:"哮天犬",
        age:2,
        color:"黑色"
      }
    };

    var obj2={};
    //把a中的拷贝到b中
    function extend(a,b) {
      //遍历a这个对象中所有的属性
      for(var key in a){
        var item=a[key];//获取了a对象中的属性
        if(item instanceof Array){
          b[key]=[];//在b对象中添加一个属性,但是这个属性的类型是数组,
          extend(item,b[key]);
        }else if(item instanceof Object){
          b[key]={};
          extend(item,b[key]);
        }else{
          b[key]=item;
        }
      }
    }

    extend(obj1,obj2);
    console.dir(obj2);
    console.dir(obj1);

  </script>

  <script>

  </script>
</head>
<body>


</body>
</html>

    欢迎关注我的个人微信公众号，免费送计算机各种最新视频资源！你想象不到的精彩！


    0.jpg

    相关文章

      网友评论

          本文标题：Web前端------JS高级继承的实现方式

          本文链接：https://www.haomeiwen.com/subject/nryguftx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|Web前端------JS高级继承的实现方式|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！