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">

</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框架中起了很大的作用

posted @ 2016-09-10 20:14 石shi 阅读(2568) 评论(0) 编辑收藏举报

刷新页面返回顶部

石

Javascript中类的实现机制（四）

公告