网站首页  汉语字词  英语词汇  考试资料  写作素材  旧版资料

请输入您要查询的考试资料：

　

标题 在JavaScript中模拟类(class)及类的继承关系
内容
    Javascipt语法不支持"类"（class）[es6已经支持]，但是有模拟类的方法。今天我主要谈谈Javascipt中模拟“类”的方法及js中继承的总结和回顾。
    js中实现“类”与继承，既是重点，又是难点。很多同学可能都对js中“类”与继承都有所了解，但是深入剖析的时候，感觉力不从心、模棱两可。
    我们先来总结一下js定义“类”的几种方法：
    方法一：构造函数法
    这个方法是比较经典的方法，我们会经常见到。生成实例的时候，使用new关键字。类的属性和方法，还可以定义在构造函数的prototype对象之上。
    function Person(name,age,job){
     this.name=name;
     this.age=age;
     this.job=job;
    }
    Person.prototype.sayName=function(){
     alert(this.name);
    }
    var person1 = new Person("张三","29","web frontpage manager");
    var person2 = new Person("李四","22","doctor");
    person1.sayName(); //弹出"张三"
    console.log(person2.name)//输出“李四”
    方法二：Object.create()法
    方法Object.creat()作为new操作符的替代方案是ES5之后才出来的。用这个方法，"类"就是一个对象，不是函数。
    var myMammal = {
     name : 'Herb the Mammal',
     get_name : function () {
     return this.name;
     },
     says : function () {
     return this.saying || '';
     }
    }
    var myCat = Object.create(myMammal);
    myCat.name = 'Henrietta';
    myCat.saying = 'meow';
    myCat.get_name = function () {
     console.log(this.says + ' ' + this.name + this.says);
    }
    myCat.get_name();
    输出：
    function () {
     return this.saying || '';
     } Henriettafunction () {
     return this.saying || '';
     }
    目前，各大浏览器的最新版本（包括IE9）都部署了这个方法。如果遇到老式浏览器，可以用下面的代码自行部署。
    if (!Object.create) {
    Object.create = function (o) {
    　 function F() {}
    　F.prototype = o;
    　return new F();
    };
    }
    方法三：极简主义法
    封装
    这种方法不使用this和prototype，代码部署起来非常简单。 首先，它也是用一个对象模拟"类"。在这个类里面，定义一个构造函数creatFn()，用来生成实例。
    var Dog= {
    creatFn: function(){
    　// some code here
    }
    };
    然后，在creatFn()里面，定义一个实例对象，把这个实例对象作为返回值。
    var Dog= {
    creatFn: function(){
    　var dog= {};
    　dog.name = "狗狗";
    　dog.makeSound = function(){ alert("汪汪汪"); };
    　return dog;
    }
    };
    使用的时候，调用creatFn()方法，就可以得到实例对象。
    var dog1 = Dog.creatFn();
    dog1.makeSound(); // 汪汪汪
    这种方法的好处是，容易理解，结构清晰优雅，符合传统的"面向对象编程"的构造，因此可以方便地部署下面的特性。
    继承
    让一个类继承另一个类，实现起来很方便。只要在前者的creatFn()方法中，调用后者的creatFn()方法即可。 先定义一个Animal类。
    var Animal = {
    creatFn: function(){
    　var animal = {};
    　animal.eat= function(){ alert("吃饭饭"); };
    　return animal;
    }
    };
    然后，在Dog的creatFn()方法中，调用Animal的creatFn()方法。
    var Dog= {
    creatFn: function(){
    　var dog= Animal.creatFn();
    　dog.name = "狗狗";
    　dog.makeSound = function(){ alert("汪汪汪"); };
    　return dog;
    }
    };
    这样得到的Dog实例，就会同时继承Dog类和Animal类。
    var dog1= Dog.creatFn();
    dog1.eat(); // 吃饭饭
    私有属性和私有方法
    在creatFn()方法中，只要不是定义在dog对象上的方法和属性，都是私有的。
    var Dog= {
    creatFn: function(){
    　var dog= {};
    　var sound = "汪汪汪";
    　dog.makeSound = function(){ alert(sound); };
    　return dog;
    }
    };
    上例的内部变量sound，外部无法读取，只有通过dog的公有方法makeSound()来读取。
    var dog1 = Dog.creatFn();
    alert(dog1.sound); // undefined
    数据共享
    有时候，我们需要所有实例对象，能够读写同一项内部数据。这个时候，只要把这个内部数据，封装在类对象的里面、creatFn()方法的外面即可。
    var Dog= {
    sound : "汪汪汪",
    creatFn: function(){
    　var dog= {};
    　dog.makeSound = function(){ alert(Dog.sound); };
    　dog.changeSound = function(x){ Dog.sound = x; };
    　return dog;
    }
    };
    然后，生成两个实例对象：
    var dog1 = Dog.creatFn();
    var dog2 = Dog.creatFn();
    dog1.makeSound(); // 汪汪汪
    这时，如果有一个实例对象，修改了共享的数据，另一个实例对象也会受到影响。
    dog2.changeSound("呜呜呜");
    dog1.makeSound(); //呜呜呜
    js继承
    关于继承，网上也有很多资料可以查询，但是很多朋友对其理解的不够深入。讲到继承，假如你不去查资料，猛地一下，可能说不出个所以然来。这就说明我们的基础知识打的不够扎实。没有理解透彻。今天，我站在前辈的基础之上，再来和大家一起回顾一下这个 继承。
    继承最常用的两种方式如下：
    原型链继承（对象间的继承）
    类式继承（构造函数间的继承）
    原型链继承
    什么是原型链继承？这里我就不说什么定义了。其实就是用prototype继承父级。
    举个例子：
    function Parent(){
     this.name = 'mike';
    } 
    function Child(){
     this.age = 12;
    }
    Child.prototype = new Parent();//Child继承Parent，通过原型，形成链条
    var test = new Child();
    alert(test.age);
    alert(test.name);//得到被继承的属性
    //继续原型链继承
    function Brother(){ //brother构造
     this.weight = 60;
    }
    Brother.prototype = new Child();//继续原型链继承
    var brother = new Brother();
    alert(brother.name);//继承了Parent和Child,弹出mike
    alert(brother.age);//弹出12
    上面例子，通过原型，形成链条，Child继承了Parent，Brother有继承了Child，最后brother既有Child和Parent的属性，又有自己的属性。这就是原形链的继承。
    类式继承（借用构造函数）
    类式继承一般是通过运用call或者apply 进行子类型构造函数的内部调用超类型的构造函数。举个例子：
    function Parent(age){
     this.name = ['mike','jack','smith'];
     this.age = age;
    }
    function Child(age){
     Parent.call(this,age);
    }
    var test = new Child(21);
    alert(test.age);//21
    alert(test.name);//mike,jack,smith
    test.name.push('bill');
    alert(test.name);//mike,jack,smith,bill
    上面的两种继承是最基本的两种继承方式。
    此外还有一些继承方式，我们一起来看一下！
    组合继承
    组合继承通常是上面两种继承方式组合在一起使用的继承方式。
    举例如下：
    function Parent(age){
     this.name = ['mike','jack','smith'];
     this.age = age;
    }
    Parent.prototype.run = function () {
     return this.name + ' are both' + this.age;
    };
    function Child(age){
     Parent.call(this,age);//对象冒充，给超类型传参
    }
    Child.prototype = new Parent();//原型链继承
    var test = new Child(21);//写new Parent(21)也行
    alert(test.run());//mike,jack,smith are both21
    原型式继承
    和上面讲的原形链式继承只有一字之差，但是不是同一个内容。我们所说的原型式继承，就是我们上节课所讲的，通过Object.create()方式来创建新的类。因为这种方式老式浏览器不支持。因此，假如我们不用Object.create()，也可以有替代法，方式如下：
    function obj(o){
    function F(){}
    F.prototype = o;
    return new F();
    }
    这个函数，就实现了我们Object.create()创建类的方式！
    因此举例如下：
    function obj(o){
     function F(){}
     F.prototype = o;
     return new F();
     }
    var box = {
     name : 'trigkit4',
     arr : ['brother','sister','baba']
    };
    var b1 = obj(box);
    alert(b1.name);//trigkit4
    b1.name = 'mike';
    alert(b1.name);//mike
    alert(b1.arr);//brother,sister,baba
    b1.arr.push('parents');
    alert(b1.arr);//brother,sister,baba,parents
    var b2 = obj(box);
    alert(b2.name);//trigkit4
    alert(b2.arr);//brother,sister,baba,parents
    寄生式继承
    举例如下：
    function creatAnother(original){
     var clone=new Object(original);
     clone.sayHi=function(){
     alert("hi")
     };
     return clone;
    }
    var person={
     name:"haorooms",
     friends:["hao123","zhansan","lisi"]
    }
    var antherPerson=creatAnother(person);
    antherPerson.sayHi();//hi
    寄生组合式
    function inheritPrototype (subType,superType) {
     var prototype = Object.creat(superType.prototype);
     prototype.constructor = subType;
     subType.prototype = prototype;
    };
    function SuperType (name) {
     this.name = name;
     this.colors = ['red', 'blue', 'green'];
    }
    SuperType.prototype.sayName = function () {
     console.log(this.name);
    }
    function SubType(name, age) {
     //继承属性
     SuperType.call(this,name);
     this.age = age;
    }
    //继承方法
    inheritPrototype(SubType,SuperType);
    SubType.prototype.sayAge = function () {
     console.log(this.age);
    }
    var instance = new SubType();
    类的继承，基本上就是如上几种方式。下面再简单的说一下ES6的class类吧！
    es6实现类
    //定义类
    class Point {
     constructor(x, y) {
     this.x = x;
     this.y = y;
     }
     toString() {
     return '('+this.x+', '+this.y+')';
     }
    }
    var point = new Point(2, 3);
    point.toString() // (2, 3)
    point.hasOwnProperty('x') // true
    point.hasOwnProperty('y') // true
    point.hasOwnProperty('toString') // false
    point.__proto__.hasOwnProperty('toString') // true
    Class的继承
    class ColorPoint extends Point {
     constructor(x, y, color) {
     super(x, y); // 调用父类的constructor(x, y)
     this.color = color;
     } 
     toString() {
     return this.color + ' ' + super.toString(); // 调用父类的toString()
     }
    }
随便看

　

在线学习网考试资料包含高考、自考、专升本考试、人事考试、公务员考试、大学生村官考试、特岗教师招聘考试、事业单位招聘考试、企业人才招聘、银行招聘、教师招聘、农村信用社招聘、各类资格证书考试等各类考试资料。

　

Copyright © 2002-2024 cuapp.net All Rights Reserved
更新时间：2025/5/16 3:57:04