4) 方法
以下例子引用于<<__JavaScript: The Definitive Guide>>
function Rectangle_area(  ) { return this.width * this.height; }
function Rectangle_perimeter(  ) { return 2*this.width + 2*this.height; }
function Rectangle_set_size(w,h) { this.width = w; this.height = h; }
function Rectangle_enlarge(  ) { this.width *= 2; this.height *= 2; }
function Rectangle_shrink(  ) { this.width /= 2; this.height /= 2; }
function Rectangle(w, h)
{
    this.width = w;
    this.height = h;
    this.area = Rectangle_area;
    this.perimeter = Rectangle_perimeter;
    this.set_size = Rectangle_set_size;
    this.enlarge = Rectangle_enlarge;
    this.shrink = Rectangle_shrink;
}
這種風格可能和Java,c++很不同。方法中的this表示調用它的對象的引用。


5) prototype
prototype是一個對象，每個類都包含一個prototype對象(注意，每個類一個，而不是每個對象一個)。
看看下面的例子：
function User(name)
{
    this.name = name
}
User.prototype.name = "killercat"  // 類名.prototype.屬性(或方法)
user = new User("who"+"<br />")
document.write(user.name)
delete user.name
document.write(user.name)

再看一個例子：
function User(name)
{
}
User.prototype.name = "human"
user1 = new User()
user2 = new User()
document.write(user1.name+"<br />")
document.write(user2.name)
結果：
human
human
說明了，每個類一個prototype對象，而不是每個對象單獨一個。

obj.x 這條語句的查找順序是，先在obj中找x屬性，假如沒有，再進入obj對應的類中找prototype.x，對于方法來說，也一樣。因此，不要出現這樣的語句： user.prototype.name = "xxx" 必須是 user.name = "xxx" (prototype對象屬于一個類，而不是一個對象)

類名.prototype.屬性  // 相當于一個實例變量(屬性)，對方法也一樣
類名.屬性  // 相當于一個靜態(tài)變量(屬性)，對方法也一樣，調用的時候必須使用"類名.屬性"，不能使用"類對象.屬性"，因為它屬于一個類，而不是一個對象。
例如：
function User(name)
{
    this.name = name
}
User.type = "human"

user = new User("kc")
document.write(User.type + "<br />")
document.write(user.type)
結果：
human
undefined

另外，每個prototype都有一個constructor屬性，默認用于保存constructor的定義，例如上面的user對象，調用：
user.constructor得到：
function User(name) { this.name = name; }
我們可以通過typeof，知道參數的類型，假如是對象，就返回"object"，假如是方法就返回"function"

6) 利用prototype實現類間的繼承，例如：
// 父類
function Circle(r){
    this.r = r;

}
Circle.PI = 3.14;
Circle.prototype.getArea = function (){   
    return Circle.PI * this.r * this.r;
};
Circle.prototype.toString = function (){   
    if(( typeof this == "object") && (this.constructor == Circle)){
        return "circle with a radius " + this.r ;
    }
    else{
        return "unknown object";
    }   
};
Circle.max = function (c1,c2){
    return c1.r >= c2.r ? c1 : c2;
};

// 子類
function ColorCircle(r,color){
    this.r = r;
    this.color = color;
}
ColorCircle.prototype = new Circle(0);  // 保存父類的對象
ColorCircle.prototype.constructor = ColorCircle;  // 為constructor 改名字
ColorCircle.prototype.toString = function(){
    if(( typeof this == "object") && (this.constructor == ColorCircle)){
        return this.color+" circle with a radius " + this.r ;
    }
    else{
        return "unknown object";
    }   
}
ColorCircle.prototype.getColor = function(){
    return this.color;
}
ColorCircle.prototype.setColor = function(color){
    this.color = color;
}

也就是，使用prototype保存父類的對象，在構造子類的時候，父類對象同時被構造(因為prototype被構造)。也就是JavaScript繼承其實就是讓子類的prototype對象保存父類的對象。

最新評論