javaScript學習面向對象編程

下面介紹了幾種創建js對象的方式，實際上這並不是面向對象的編程。

因爲js本身就是面向對象的編程語言，但是js中沒有類和繼承的概念，只有原型鏈。

也就是說從普遍意義上說，js語言本身是不完備的面向對象的語言。因爲他沒有類和繼承的概念。

但是，js強大的原型鏈能夠模擬實現類和繼承。

完成繼承和類的概念，纔是js面向對象編程的纔是當務之急。

要構建繼承和類，就必須先理解原型的概念。

網上發現了一篇文章，講的很好《javaScript繼承機制的設計思想》

一直以來我對原型的概念都不是很理解。儘管我已經使用jQuery寫了一年多的項目，並接觸到一些ext.js,easyUI,jqueryMobile,backbone,argular...等等很多框架。

裏面的繼承方式和類的概念一直以來都沒有很好的理解，只是靠着記憶，能勉強解釋這些東西。

原型：

function Dog(name){
this.name = name;
this.species = "犬科" }
var dogA = new Dog("大毛");
var dogB = new Dog("二毛");
dogA.species ="貓科";
alert(dogA.species);//貓科
alert(dogB.species);//犬科

上面的例子有一個問題，儘管看起來，dogA和dogB都是通過Dog創建的對象。但是dogA和dogB並沒有共享的數據，也就說a和b只有本地屬性。沒有共同的引用屬性。

僅僅使用new的方式修改其中的一個屬性另一個是沒有影響的。有沒有方式可以共享屬性。於是就引入了原型。

function Dog(name){
    this.name =name;     
}
Dog.prototype.s = "犬科";
var dogA=new Dog("大毛");
var dogB=new Dog("二毛");
alert(dogA.s +"||" +dogB.s);
Dog.prototype.s="貓科";
alert(dogA.s +"||" +dogB.s);

通過原型的方式可以解決對象屬性的共享。就是這麼簡單。

另外提供了一些，方法判斷是引用原型的屬性還是本地的屬性。

Dog.isPrototypeOf(dogA);//true

dogA.hasOwnProperty(“name”);//true

dogA.hasOwnProperty(“s”);//false

//for in 只可以循環到可枚舉的屬性，prototype 和constructor是不可枚舉的

類和創建對象：

一、生成對象的原始模式。

　var Cat = {

　　　　name : '',

　　　　color : ''

　　} 
//我們需要根據這個原型的規則，創建對象
var cat1 = {}; // 創建一個空對象<p>　　　　cat1.name = "大毛"; // 按照原型對象的屬性賦值</p><p>　　　　cat1.color = "黃色";</p><p>　　var cat2 = {};</p><p>　　　　cat2.name = "二毛";</p><p>　　　　cat2.color = "黑色"; </p>

好了，這就是最簡單的封裝了，把兩個屬性封裝在一個對象裏面。

但是，這樣的寫法有兩個缺點，

一是如果多生成幾個實例，寫起來就非常麻煩；

二是實例與原型之間，沒有任何辦法，可以看出有什麼聯繫。

二、原始模式的改進：

function Cat(name,color){

　　　　return {

　　　　　　name:name,

　　　　　　color:color

　　　　}

　　} 
var cat1 = Cat("大毛","黃色");<p>　　var cat2 = Cat("二毛","黑色");</p>

這種方法的問題依然是，cat1和cat2之間沒有內在的聯繫，不能反映出它們是同一個原型對象的實例。

只是解決了代碼重複的問題。

三、構造函數方式

function Cat(name,color){

　　　　this.name=name;

　　　　this.color=color;

　　} 
//我們現在就可以生成實例對象了
var cat1 = new Cat("大毛","黃色");<p>　　var cat2 = new Cat("二毛","黑色");</p><p>　　alert(cat1.name); // 大毛</p><p>　　alert(cat1.color); // 黃色</p><p>//這時cat1和cat2會自動含有一個constructor屬性，指向它們的構造函數。</p><p>alert(cat1.constructor == Cat); //true</p><p>　　alert(cat2.constructor == Cat); //true</p>//Javascript還提供了一個instanceof運算符，驗證原型對象與實例對象之間的關係。

alert(cat1 instanceof Cat); //true

　　alert(cat2 instanceof Cat); //true

這種方式實際上解決上面提到的兩個問題。

看起來構造函數方法很好用，但是存在一個浪費內存的問題。

我們現在爲Cat對象添加一個不變的屬性"type"（種類），再添加一個方法eat（吃老鼠）。那麼，原型對象Cat就變成了下面這樣：

function Cat(name,color){

　　　　this.name = name;

　　　　this.color = color;

　　　　this.type = "貓科動物";
 　　　　this.eat = function(){alert("吃老鼠");};

　　} 
//還是採用同樣的方法，生成實例：
var cat1 = new Cat("大毛","黃色");<p>　　var cat2 = new Cat ("二毛","黑色");</p><p>　　alert(cat1.type); // 貓科動物</p><p>　　cat1.eat(); // 吃老鼠 </p>

表面上好像沒什麼問題，但是實際上這樣做，有一個很大的弊端。

那就是對於每一個實例對象，type屬性和eat()方法都是一模一樣的內容，每一次生成一個實例，都必須爲重複的內容，多佔用一些內存。這樣既不環保，也缺乏效率。

　alert(cat1.eat == cat2.eat); //false

能不能讓type屬性和eat()方法在內存中只生成一次，然後所有實例都指向那個內存地址呢？回答是可以的。

四、原型模式

Javascript規定，每一個構造函數都有一個prototype屬性，指向另一個對象。這個對象的所有屬性和方法，都會被構造函數的實例繼承。

這意味着，我們可以把那些不變的屬性和方法，直接定義在prototype對象上。

function Cat(name,color){

　　　　this.name = name;

　　　　this.color = color;

　　}

　　Cat.prototype.type = "貓科動物";

　　Cat.prototype.eat = function(){alert("吃老鼠")}; 
//創建實例
var cat1 = new Cat("大毛","黃色");<p>　　var cat2 = new Cat("二毛","黑色");</p><p>　　alert(cat1.type); // 貓科動物</p><p>　　cat1.eat(); // 吃老鼠</p><span style="color:#FF6666;">
</span>

這時所有實例的type屬性和eat()方法，其實都是同一個內存地址，指向prototype對象，因此就提高了運行效率。

alert(cat1.eat == cat2.eat); //true

其實以上三種方式顯而易見，原型的方式更加合理高效。

下面的例子其實和前面的一樣可以對照理解。

方式1 工廠方式:

function createCar(color){
    var car=new Object();
    car.color=color;
    car.showColor=function(){
        alert(car.color);
    }
    return car;
}
var car1=createCar("red");
var car2=createCar("green");
car1.showColor();
car2.showColor();

方式2 原型方式

function oMyCar(color){
    this.color=color;
    this.showColor=function(){
        alert(this.color);
    }
}
oMyCar.prototype.showMyColor=function(){
    alert("this is my car,"+this.color);
};
var myCar1=new oMyCar("blue");
//alert(myCar1 instanceof oMyCar);
var myCar2=new oMyCar("orange");
//alert(myCar2 instanceof oMyCar);
myCar1.showMyColor();

3 構造器方式

function CoolCar(color){
    this.color=color;
    if(typeof CoolCar._initialized=="undefined"){
        CoolCar.prototype.showColor=function(){
            alert("cool,"+this.color);
        };
        CoolCar.initialized=true;
    }
}
var coolCar1=new CoolCar("yellow");
coolCar1.showColor();

繼承：

一、構造函數綁定

第一種方法也是最簡單的方法，使用call或apply方法，將父對象的構造函數綁定在子對象上，即在子對象構造函數中加一行：

　function Cat(name,color){

　　　　Animal.apply(this, arguments);

　　　　this.name = name;

　　　　this.color = color;

　　}

　　var cat1 = new Cat("大毛","黃色");

　　alert(cat1.species); // 動物

二、 prototype模式

第二種方法更常見，使用prototype屬性。

如果"貓"的prototype對象，指向一個Animal的實例，那麼所有"貓"的實例，就能繼承Animal了。

　Cat.prototype = new Animal();

　　Cat.prototype.constructor = Cat;

　　var cat1 = new Cat("大毛","黃色");

　　alert(cat1.species); // 動物

代碼的第一行，我們將Cat的prototype對象指向一個Animal的實例。

　Cat.prototype = new Animal();

它相當於完全刪除了prototype 對象原先的值，然後賦予一個新值。但是，第二行又是什麼意思呢？

　Cat.prototype.constructor = Cat;

原來，任何一個prototype對象都有一個constructor屬性，指向它的構造函數。如果沒有"Cat.prototype = new Animal();"這一行，Cat.prototype.constructor是指向Cat的；加了這一行以後，Cat.prototype.constructor指向Animal

　　alert(Cat.prototype.constructor == Animal); //true

更重要的是，每一個實例也有一個constructor屬性，默認調用prototype對象的constructor屬性

alert(cat1.constructor == Cat.prototype.constructor); // true

因此，在運行"Cat.prototype = new Animal();"這一行之後，cat1.constructor也指向Animal

　alert(cat1.constructor == Animal); // true

這顯然會導致繼承鏈的紊亂（cat1明明是用構造函數Cat生成的），因此我們必須手動糾正，將Cat.prototype對象的constructor值改爲Cat。這就是第二行的意思。

這是很重要的一點，編程時務必要遵守。下文都遵循這一點，即如果替換了prototype對象，

o.prototype = {};

那麼，下一步必然是爲新的prototype對象加上constructor屬性，並將這個屬性指回原來的構造函數。

o.prototype.constructor = o;

三、直接繼承prototype

第三種方法是對第二種方法的改進。由於Animal對象中，不變的屬性都可以直接寫入Animal.prototype。所以，我們也可以讓Cat()跳過 Animal()，直接繼承Animal.prototype。

現在，我們先將Animal對象改寫：

    　　function Animal(){ }

    　　Animal.prototype.species = "動物";

然後，將Cat的prototype對象，然後指向Animal的prototype對象，這樣就完成了繼承。

    　　Cat.prototype = Animal.prototype;

    　　Cat.prototype.constructor = Cat;

    　　var cat1 = new Cat("大毛","黃色");

    　　alert(cat1.species); // 動物

與前一種方法相比，這樣做的

優點是效率比較高（不用執行和建立Animal的實例了），比較省內存。

缺點是 Cat.prototype和Animal.prototype現在指向了同一個對象，那麼任何對Cat.prototype的修改，都會反映到Animal.prototype。

所以，上面這一段代碼其實是有問題的。請看第二行

Cat.prototype.constructor = Cat;

這一句實際上把Animal.prototype對象的constructor屬性也改掉了！

　alert(Animal.prototype.constructor); // Cat

四、利用空對象作爲中介

由於"直接繼承prototype"存在上述的缺點，所以就有第四種方法，利用一個空對象作爲中介。

var F = function(){};

　　F.prototype = Animal.prototype;

　　Cat.prototype = new F();

　　Cat.prototype.constructor = Cat;

F是空對象，所以幾乎不佔內存。這時，修改Cat的prototype對象，就不會影響到Animal的prototype對象。

alert(Animal.prototype.constructor); // Animal

我們將上面的方法，封裝成一個函數，便於使用。

    　　function extend(Child, Parent) {

    　　　　var F = function(){};

    　　　　F.prototype = Parent.prototype;

    　　　　Child.prototype = new F();

    　　　　Child.prototype.constructor = Child;

    　　　　Child.uber = Parent.prototype;

    　　}

使用的時候，方法如下

extend(Cat,Animal);

　　var cat1 = new Cat("大毛","黃色");

　　alert(cat1.species); // 動物

這個extend函數，就是YUI庫如何實現繼承的方法。

另外，說明一點，函數體最後一行

Child.uber = Parent.prototype;

意思是爲子對象設一個uber屬性，這個屬性直接指向父對象的prototype屬性。（uber是一個德語詞，意思是"向上"、"上一層"。）這等於在子對象上打開一條通道，可以直接調用父對象的方法。這一行放在這裏，只是爲了實現繼承的完備性，純屬備用性質。

五、拷貝繼承

上面是採用prototype對象，實現繼承。我們也可以換一種思路，純粹採用"拷貝"方法實現繼承。簡單說，如果把父對象的所有屬性和方法，拷貝進子對象，不也能夠實現繼承嗎？這樣我們就有了第五種方法。

首先，還是把Animal的所有不變屬性，都放到它的prototype對象上。

　function Animal(){}

　　Animal.prototype.species = "動物";

然後，再寫一個函數，實現屬性拷貝的目的。這是函數應該是最常用的。jquery等

function extend2(Child, Parent) {

　　　　var p = Parent.prototype;

　　　　var c = Child.prototype;

　　　　for (var i in p) {

　　　　　　c[i] = p[i];

　　　　　　}

　　　　c.uber = p;

　　}

這個函數的作用，就是將父對象的prototype對象中的屬性，一一拷貝給Child對象的prototype對象。

使用的時候，這樣寫：

extend2(Cat, Animal);

　　var cat1 = new Cat("大毛","黃色");

　　alert(cat1.species); // 動物

//------extends---1

function ClassA(color){
    this.color=color;
    this.sayColor=function(){
        alert(this.color);
    };
}
function ClassB(color,name){
    this.newMethod=ClassA;
    this.newMethod(color);
    delete this.newMethod;
    
    this.name=name;
    this.sayName=function(){
        alert(this.name);
    }
}
var b=new ClassB("brrow!!!!!","hello!!");
b.sayColor();
b.sayName();
alert(b.newMethod);//undefined

//-----extends---2--call ==apply

function sayMyColor(pre,suf){
    alert(pre+this.color+suf);
}
var obj=new Object();
obj.color="red";
sayMyColor.call(obj,"this color is ","a vrey nice color indeed.");

function ClassC(color,name){
    ClassA.call(this,color);
    //ClassA.apply(this,new Array(color));
    //ClassA.apply(this.arguments);
    
    this.name=name;
    this.sayMyName=function(){
        alert(this.name);
    }
}
var c=new ClassC("shine","hi!!!");
c.sayColor();
c.sayMyName();

//======extends----3--混合

function ClassA1(color){
    this.color=color;
}
ClassA1.prototype.sayColor=function(){
    alert("+++++"+this.color);
}
function ClassB1(color,name){
    ClassA1.call(this,color );
    this.name=name;
}
ClassB1.prototype=new ClassA1();
ClassB1.prototype.sayName=function(){
    alert(this.name);
}
var b1=new ClassB1("!!!!huhu!!","!!!!!!heihei!!!");
b1.sayColor();
b1.sayName();

javaScript學習面向對象編程

容器中nginx無法使用同一個網絡下的容器域名

Python: SunMoonTimeCalculator

NETCore中實現一個輕量無負擔的極簡任務調度ScheduleTask

docker使用特定的網絡

使用c#強大的表達式樹實現對象的深克隆之解決循環引用的問題

「Pygors跨平臺GUI」2：安裝MinGW-w64、MSYS2還是WSL2

「Pygors跨平臺GUI」1：Pygors跨平臺GUI應用研究

nodejs學習07——API

避免DbContext同時在多個線程調用

GPT-4o 引領人機交互新風向，向量數據庫賽道沸騰了

jquery mobile 經驗小結（1）

瀏覽器默認樣式表 - 清風小閣 - 博客頻道 - CSDN.NET

javaScripr學習總結1

HTML5的History API介紹

html 中的meta標籤

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

javaScript學習 面向對象編程

javaScript學習面向對象編程