JavaScript 原型3

抽象类

<script language="JavaScript" type="text/javascript">
    < !--
    //定义extend方法
    Object.extend = function(destination, source) {
        for (property in source) {
            destination[property] = source[property];
        }
        return destination;
    }
    Object.prototype.extend = function(object) {
        return Object.extend.apply(this, [this, object]);
    }
    //定义一个抽象基类base，无构造函数
    function base() {}
    base.prototype = {
        initialize: function() {
            this.oninit(); //调用了一个虚方法
        }
    }
    //定义class1
    function class1() {
        //构造函数
    }
    //让class1继承于base并实现其中的oninit 方法
    class1.prototype = (new base()).extend({
        oninit: function() { //实现抽象基类中的oninit虚方法
            //oninit函数的实现
        }
    });
    //-->
    
</script>

这样，当在class1 的实例中调用继承得到的initialize方法时，就会自动执行派生类中的oninit()方法。从这里也可以看到解释型语言执行的特点，它们只有在运行到某一个方法调用时，才会检查该方法是否存在，而不会向编译型语言一样在编译阶段就检查方法存在与否。JavaScript 中则避免了这个问题。

以prototype-1.3.1 为例，其中定义了一个类的创建模型：

//Class是一个全局对象，有一个方法create，用于返回一个类
var Class = {
    create: function() {
        return function() {
            this.initialize.apply(this, arguments);
        }
    }
}

这里Class是一个全局对象，具有一个方法create，用于返回一个函数（类），从而声明一个类，可以用如下语法：

var class1=Class.create();

这个函数也是一个类的构造函数，当new这个类时便会得到执行。它调用了一个initialize方法，从名字来看，是类的构造函数。而从类的角度来看，它是一个虚方法，是未定义的。但这个虚方法的实现并不是在派生类中实现的，而是创建完一个类后，在prototype 中定义的，例如prototype可以这样写：

var class1 = Class.create();
class1.prototype = {
    initialize: function(userName) {
        alert(“hello, ” + userName);
    }
}

这样，每次创建类的实例时，initialize方法都会得到执行，从而实现了将类的构造函数和类成员一起定义的功能。

<script type="text/javascript">
    var Class = {
        create: function() {
            return function() {
                this.initialize.apply(this, arguments);
            }
        }
    }
    var class1 = Class.create();
    class1.prototype = {
        initialize: function(userName) {
            alert("hello," + userName);
        }
    }
    var c = new class1("hongda");
</script>