Javascript中类的实现机制（四）

一：理解类的实现机制

在JavaScript中可以使用function关键字来定义一个“类”，如何为类添加成员。在函数内通过this指针引用的变量或者方法都会成为类的成员，例如：
function class1(){
      var s="abc";
      this.p1=s;
      this.method1=function(){
             alert("this is a test method");
      }
}
var obj1=new class1();
通过new class1()获得对象obj1，对象obj1便自动获得了属性p1和方法method1。
在JavaScript中，function本身的定义就是类的构造函数，使用new创建对象的过程。
（1）当解释器遇到new操作符时便创建一个空对象；
（2）开始运行class1这个函数，并将其中的this指针都指向这个新建的对象；
（3）因为当给对象不存在的属性赋值时，解释器就会为对象创建该属性，例如在class1中，当执行到this.p1=s这条语句时，就会添加一个属性p1，并把变量s的值赋给它，这样函数执行就是初始化这个对象的过程，即实现构造函数的作用；
（4）当函数执行完后，new操作符就返回初始化后的对象。
通过这整个过程，JavaScript中就实现了面向对象的基本机制。由此可见，在JavaScript中，function的定义实际上就是实现一个对象的构造器，是通过函数来完成的。这种方式的缺点是：
(1)将所有的初始化语句、成员定义都放到一起，代码逻辑不够清晰，不易实现复杂的功能。
(2)每创建一个类的实例，都要执行一次构造函数。构造函数中定义的属性和方法总被重复的创建，例如：
this.method1=function(){
            alert("this is a test method");
      }
这里的method1每创建一个class1的实例，都会被创建一次，造成了内存的浪费。另一种类定义的机制：prototype对象，可以解决构造函数中定义类成员带来的缺点。

二：使用prototype对象定义类成员

一种为类添加成员的机制：prototype对象。当new一个function时，该对象的成员将自动赋给所创建的对象，例如：
<script language="JavaScript" type="text/javascript">

</script>
prototype是一个JavaScript对象，可以为prototype对象添加、修改、删除方法和属性。从而为一个类添加成员定义。
了解了函数的prototype对象，现在再来看new的执行过程。
（1）创建一个新的对象，并让this指针指向它；
（2）将函数的prototype对象的所有成员都赋给这个新对象；
（3）执行函数体，对这个对象进行初始化操作；
（4）返回（1）中创建的对象。
和new的执行过程相比，多了用prototype来初始化对象的过程，这也和prototype的字面意思相符，它是所对应类的实例的原型。这个初始化过程发生在函数体（构造器）执行之前，所以可以在函数体内部调用prototype中定义的属性和方法，例如：
<script language="JavaScript" type="text/javascript">

</script>
和上一段代码相比，这里在class1的内部调用了prototype中定义的方法showProp，从而在对象的构造过程中就弹出了对话框，显示prop属性的值为1。
需要注意，原型对象的定义必须在创建类实例的语句之前，否则它将不会起作用，例如：
<script language="JavaScript" type="text/javascript">

</script>
这段代码将会产生运行时错误，显示对象没有showProp方法，就是因为该方法的定义是在实例化一个类的语句之后。
由此可见，prototype对象专用于设计类的成员，它是和一个类紧密相关的，除此之外，prototype还有一个重要的属性：constructor，表示对该构造函数的引用，例如：
function class1(){
      alert(1);
}
class1.prototype.constructor(); //调用类的构造函数
这段代码运行后将会出现对话框，在上面显示文字“1”，从而可以看出一个prototype是和一个类的定义紧密相关的。实际上：class1.prototype.constructor==class1。

三：一种JavaScript类的设计模式　　

类可以在function定义的函数体中添加成员，又可以用prototype定义类的成员，编程的代码显得混乱。如何以一种清晰的方式来定义类呢？下面给出了一种类的实现模式。
在JavaScript 中，由于对象灵活的性质，在构造函数中也可以为类添加成员，在增加灵活性的同时，也增加了代码的复杂度。为了提高代码的可读性和开发效率，可以采用这种定义成员的方式，而使用prototype对象来替代，这样function的定义就是类的构造函数，符合传统意义类的实现：类名和构造函数名是相同的。例如：
function class1(){
      //构造函数
}
//成员定义
class1.prototype.someProperty="sample";
class1.prototype.someMethod=function(){
      //方法实现代码
}
虽然上面的代码对于类的定义已经清晰了很多，但每定义一个属性或方法，都需要使用一次class1.prototype，不仅代码体积变大，而且易读性还不够。为了进一步改进，可以使用无类型对象的构造方法来指定prototype对象，从而实现类的成员定义：
//定义一个类class1
function class1(){
      //构造函数
}
//通过指定prototype对象来实现类的成员定义
class1.prototype={
      someProperty:"sample",
      someMethod:function(){
          //方法代码
      },
      …//其他属性和方法.
}
上面的代码用一种很清晰的方式定义了class1，构造函数直接用类名来实现，而成员使用无类型对象来定义，以列表的方式实现了所有属性和方法，并且可以在定义的同时初始化属性的值。这也更象传统意义面向对象语言中类的实现。只是构造函数和类的成员定义被分为了两个部分，这可看成JavaScript中定义类的一种固定模式，这样在使用时会更加容易理解。
注意：在一个类的成员之间互相引用，必须通过this指针来进行，例如在上面例子中的 someMethod方法中，如果要使用属性someProperty，必须通过this.someProperty的形式，因为在JavaScript 中每个属性和方法都是独立的，它们通过this指针联系在一个对象上。

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

        "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

    <title></title>

    <script language="JavaScript" type="text/javascript">

     /function Person() {

          // console.log("这里可以写一些类成员初始化的代码");

          //在这进行初始化值

          this.personName = "孙丽媛";

          this.personAge = "20";

      }

      //创建类

      //先在执行这个代码    后返回构造函数  进行赋值   最后输出

      Person.prototype.personName = "";

      Person.prototype.personAge = 0;

      Person.prototype.showInfo = function () {

          alert(this.personName + "," + this.personAge);

      }

        var person=new Person();

        person.showInfo();

     function Person(personName,personAge) {

      // console.log("这里可以写一些类成员初始化的代码");

      //在这进行初始化值

      this.personName = personName;

      this.personAge = personAge;

      }

      //创建类

      //先在执行这个代码    后返回构造函数  进行赋值   最后输出

      Person.prototype.personName = "";

      Person.prototype.personAge = 0;

      Person.prototype.showInfo = function () {

      alert(this.personName + "," + this.personAge);

      }

      var person=new Person("sun",15);

      person.showInfo();

        function Person(personName,personAge){

            console.log("可以做一些初始化的工作");

            this.personName=personName;

            this.personAge=personAge;

        }

        Person.prototype={

            personName:"zhang",

           personAge:18,

                shouInfo:function(){

                    alert(this.personName+","+this.personAge)

                }

        };

        var p=new Person("lisi",30);

     p.shouInfo();

    </script>

</head>

<body>

</body>

</html>

四：实现类的公有成员

前面定义的任何类成员都属于公有成员的范畴，该类的任何实例都对外公开这些属性和方法。

五：实现类的私有成员

私有成员即在类的内部实现中可以共享的成员，不对外公开。JavaScript中并没有特殊的机制来定义私有成员，但可以用一些技巧来实现这个功能。
        这个技巧主要是通过变量的作用域性质来实现的，在JavaScript中，一个函数内部定义的变量称为局部变量，该变量不能够被此函数外的程序所访问，却可以被函数内部定义的嵌套函数所访问。在实现私有成员的过程中，正是利用了这一性质。
在类的构造函数中可以为类添加成员，通过这种方式定义的类成员，实际上共享了在构造函数内部定义的局部变量，这些变量就可以看作类的私有成员
例如：
<script language="JavaScript" type="text/javascript">
<!--
function class1(){
      var pp=" this is a private property"; //私有属性成员pp
      function pm(){  //私有方法成员pm，显示pp的值
             alert(pp);
      }
      this.method1=function(){
             //在公有成员中改变私有属性的值
             pp="pp has been changed";
      }
      this.method2=function(){
             pm();  //在公有成员中调用私有方法
      }
}

var obj1=new class1();
obj1.method1(); //调用公有方法method1
obj1.method2(); //调用公有方法method2
//-->
</script>

这样，就实现了私有属性pp和私有方法pm。运行完class1以后，尽管看上去pp和pm这些局部变量应该随即消失，但实际上因为class1是通过new来运行的，它所属的对象还没消失，所以仍然可以通过公开成员来对它们进行操作。
注意：这些局部变量（私有成员），被所有在构造函数中定义的公有方法所共享，而且仅被在构造函数中定义的公有方法所共享。这意味着，在prototype中定义的类成员将不能访问在构造体中定义的局部变量（私有成员）。
要使用私有成员，是以牺牲代码可读性为代价的。而且这种实现更多的是一种JavaScript技巧，因为它并不是语言本身具有的机制。但这种利用变量作用域性质的技巧，却是值得借鉴的。

实例：借助局部变量来模拟分装类的私有方法：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

        "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

    <title></title>

    <script language="JavaScript" type="text/javascript">

    function Person(){

        //局部变量加——

        var _age=10;

        function _changeAge(age){

            if(age<20){

                age = 20;

            }

            _age = age;

        }

        this.setAge=function(age){

            _changeAge(age);

        }

        this.getAge=function(){

            return _age;

        }

    }

        var p=new Person();

        var age= p.getAge();

        alert(age);

        p.setAge(100);

        age=p.getAge();

        alert(age);

    </script>

</head>

<body>

</body>

</html>

六：实现类的静态成员

静态成员属于一个类的成员，它可以通过“类名.静态成员名”的方式访问。在JavaScript中，可以给一个函数对象直接添加成员来实现静态成员，因为函数也是一个对象，所以对象的相关操作，对函数同样适用。例如：
function class1(){//构造函数
}
//静态属性
class1.staticProperty="sample";
//静态方法
class1.staticMethod=function(){
      alert(class1.staticProperty);
}
//调用静态方法
class1.staticMethod();
通过上面的代码，就为类class1添加了一个静态属性和静态方法，并且在静态方法中引用了该类的静态属性。
如果要给每个函数对象都添加通用的静态方法，还可以通过函数对象所对应的类Function来实现，例如：
//给类Function添加原型方法：show ArgsCount
Function.prototype.showArgsCount=function(){
      alert(this.length);    //显示函数定义的形参的个数
}
function class1(a){
      //定义一个类
}
//调用通过Function的prototype定义的类的静态方法showArgsCount
class1. showArgsCount ();
由此可见，通过Function的prototype原型对象，可以给任何函数都加上通用的静态成员，这在实际开发中可以起到很大的作用，比如在著名的prototype-1.3.1.js框架中，就给所有的函数定义了以下两个方法：
//将函数作为一个对象的方法运行
Function.prototype.bind = function(object) {
var __method = this;
return function() {
     __method.apply(object, arguments);
}
}
//将函数作为事件监听器
Function.prototype.bindAsEventListener = function(object) {
var __method = this;
return function(event) {
    __method.call(object, event || window.event);
}
}
这两个方法在prototype-1.3.1框架中起了很大的作用

Javascript中类的实现机制（四）的更多相关文章

JavaScript中类的实现机制
理解类的实现机制在前面已经讲过,在JavaScript中可以使用function关键字来定义一个“类”.现在介绍如何为类添加成员.其过程很简单,在函数内通过this指针引用的变量或者方法都会成为类的成 ...
160930、Javascript的垃圾回收机制与内存管理
一.垃圾回收机制-GC Javascript具有自动垃圾回收机制(GC:Garbage Collecation),也就是说,执行环境会负责管理代码执行过程中使用的内存. 原理:垃圾收集器会定期(周期性 ...
悟透Javascript undefined,null,"",0这四个值转换为逻辑值时就是false &this关键字
话题一:undefined,null,"",0这四个值转换为逻辑值时就是false 也就是在if判断时会把上面的五个作为false来判断.但是它们的类型确是不尽相同的,如下所示. ...
javascript中类的属性研究
原文:javascript中类的属性研究本篇文章主要针对javascript的属性进行分析,由于javascript是一种基于对象的语言,本身没有类的概念,所以对于javascript的类的定义有很 ...
JavaScript 原型与继承机制详解
引言初识 JavaScript 对象的时候,我以为 JS 是没有继承这种说法的,虽说 JS 是一门面向对象语言,可是面向对象的一些特性在 JS 中并不存在(比如多态,不过严格来说也没有继承).这就困 ...
Javascript prototype 及继承机制的设计思想
我一直很难理解Javascript语言的继承机制. 它没有"子类"和"父类"的概念,也没有"类"(class)和"实例" ...
[书籍翻译] 《JavaScript并发编程》第四章使用Generators实现惰性计算
本文是我翻译<JavaScript Concurrency>书籍的第四章使用Generators实现惰性计算,该书主要以Promises.Generator.Web workers等技术 ...
javascript的垃圾回收机制与内存管理
一.垃圾回收机制—GC Javascript具有自动垃圾回收机制(GC:Garbage Collecation),也就是说,执行环境会负责管理代码执行过程中使用的内存. 原理:垃圾收集器会定期(周期性 ...
javascript 之 prototype继承机制
理解Javascript语言的继承机制 javascript没有"子类"和"父类"的概念,也没有"类"(class)和"实例&qu ...

随机推荐

CM记录-Hadoop运维管理
1.自动化运维--cloudera manager 2.手动运维 a.启动./start.all.sh,停止./stop-all.sh b.hdfs启动/停止:./start-dfs.sh ./s ...
Hive记录-Hive on Spark环境部署
1.hive执行引擎 Hive默认使用MapReduce作为执行引擎,即Hive on mr.实际上,Hive还可以使用Tez和Spark作为其执行引擎,分别为Hive on Tez和Hive on ...
关于Meta标签的一些知识
1.定义文档的编码格式(H5的标准写法) <meta charset="UTF-8"> 2.声明指定的浏览器以及版本 <meta http-equiv=" ...
支付宝app支付流程
JS——取消事件冒泡，实现div的显示与隐藏 event.cancelBubble = true;
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...
Python巧用正则表达式，完成接口参数替换
最近给Python11期的小朋友们上课,遇到了一个参数替换的问题,首先描述下场景: 需要参数化的数据如下所示: 这个时候如果利用单纯的if判断和字符串的find和replace方法,做起来是非常不明智 ...
git进阶命令
首先, clone 一个远端仓库,到其目录下: $ Git clone git://example.com/myproject $ cd myproject 然后,看看你本地有什么分支: $ git ...
消息队列介绍和SpringBoot2.x整合RockketMQ、ActiveMQ 9节课
1.JMS介绍和使用场景及基础编程模型简介:讲解什么是小写队列,JMS的基础知识和使用场景 1.什么是JMS: Java消息服务(Java Message Service),Java ...
Mybatis进阶学习笔记——动态代理方式开发Dao接口、Dao层（推荐第二种）
1.原始方法开发Dao Dao接口 package cn.sm1234.dao; import java.util.List; import cn.sm1234.domain.Customer; pu ...
map_server地图服务器
http://wiki.ros.org/map_server 概述 map_server提供map_server ROS节点,它提供地图数据作为一个ROS服务器.也提供map_saver命令行功能,能 ...

Javascript中类的实现机制（四）

Javascript中类的实现机制（四）的更多相关文章

随机推荐

热门专题