JavaScript 面向對象

1. 什麼是對象？

       對象object 是一些相關的變數和方法的軟體集。

       特性： 屬性和方法

       JavaScript中的所有事物都是對象。

       創建對象的方法：

1. 字面量
2. new Object()  創建
3. 自定義構造函數
4. Object.create() 創建
5. 工廠函數

var obj = new Object();
// obj是對象，Object是類
// 對象是類的實例和具體，類是對象的集合

         建立一個工廠函數

function createStudent(name,age,ClassName){
            var obj = new Object();
            obj.name = name;
            obj.age = age;
            obj.ClassName = ClassName;
            obj.study = function(){
                console.log("學習Css");
            }
            return obj;
        }

        var ming=  createStudent("明",20,"1811");
        var hong=  createStudent("紅",21,"1811");

// 可以很好減少代碼量

2.什麼是面向對象？

        面向對象是一個思想，就是把解決問題的註意力集中到對象上。

        面向對象的三大特點：封裝 繼承 多態。    

        封裝：把所有相關的屬性和方法封裝在一個對象里。
        繼承：自己沒有的屬性或者方法，可以把別的拿過來用
        多態：不同的對象根據事件情況，執行代碼不同。js可以模擬實現。

3.常用的內置對象（構造函數）

Number String Boolean
Array Date Math RegExp
Function Object
Global Error

        構造函數: new  後面就是構造函數，構造函數中的this就是指向當前對象。

var arr = new Array();
// arr 是對象，Array 是類。 對象是由類所構造的。
// Array() 是構造函數

       把工廠函數變換成構造函數

function createStudent(name,age,ClassName){
            this.name = name;
            this.age = age;
            this.ClassName = ClassName;
            this.study = function(){
                console.log("學習Css");
            }
            return obj;
        }

        var ming= new createStudent("明",20,"1811");
        var hong= new createStudent("紅",21,"1811");

         ming.study();
         hong.study();

         // ming 是對象  createStudent是類  createStudent是構造函數
         // 類的本質還是函數
        

4.原型對象

         js就是基於原型的對象。

function Person(){

}
var xiaoming = new Person();
//1. 每個類（函數） 天生有一個prototype 的屬性，創建了一個對象，而這個對象的就是這個函數的原型，這個對象里有個constructor(構造函數) 的屬性，屬性值是類本身。
//2. 我們所有new 一個類的時候，其實是調用它的構造函數。構造函數里的屬性都是私有的，構造函數里的this都是實例對象。
//3. 每個對象上天生有一個__proto__ ，指向類的原型。

5.原型鏈

          原型鏈： 由各級對象的__proto__逐級繼承形成的關係。

          原型鏈的作用也是節省空間。

          __proto__和prototype:

                 1.  prototype 是類的或者函數的， __proto__ 是對象的。
                 2.  __proto__是查找機制 ,prototype是存儲機制。

function Person(name,age){  
        this.name= name;
}

 var zhang = new Person("zhang");
 console.log(zhang.name);  //zhang
 console.log(zhang.age);  //undefined

//當zhang 查找某個屬性時(比如:name)：
//zhang 這個對象首先看name 是私有的，是就直接使用，不是的就通過 __proto__ 往它的 //類的prototype 上查找，有就直接使用，沒有就繼續向上查找，直到查找到基類object ,沒有 //就是undefined  ,有就直接使用。這種查找機制 叫原型鏈。

// 所以zhang.name 返回的是zhang，而zhang.age 返回undefined

6.繼承

// 父類
function Person(name){
     this.name = name;
     this.eat= function(){
      console.log("chi");
}
}
Person.prototype.age = 10; // 添加原型屬性

         1. 原型繼承

function Son(){
      this.age = 23;
}
var p1 = new Person("zhang");
Son.prototype = p1;
var s1 = new Son;
console.dir(s1.name); // zhang

// 將父類的實例賦值給子類的原型：私有的公有的都繼承為共有的。

       2. call繼承 (call方法是函數/類天生自帶的一個方法。);

function Son(){
      this.age = 23;
      Person.call(this,"123"8);
}
var p1 = new Person("zhang");
var s1 = new Son;
console.log(s1.age); // 23
console.log(s1.name); // 123

//只繼承了父類構造函數的屬性，沒有繼承父類原型的屬性。

        3. 冒充對象繼承

var p1 = new Person("zhang");

for(var key in p1){
        console.log(key); //name in 
}

// 將父類私有的和公有的都繼承為子類私有的 使用for in
// for in 可以遍歷對象的共有屬性fn就是公有的

        4. 混合繼承  (call 繼承和原型繼承的結合)

// 父類
function Person(name){
     this.name = name;
}
Person.prototype.age = 10; // 添加原型屬性

var p1 = new Person;
function Son() {
   Person.call(this); // 私有的繼承為私有的了
}
Son.prototype=p1;
var s1 = new Son;
console.log(s1); // zhang

// 私有的繼承為私有的 私有的和公有的再次繼承為公有的。

         5. 組合繼承

         // 父類
        function Person(){   
            this.name ="zhang";
        }
        Person.prototype.fn=function(){
            console.log(111);
        }
        var p = new Person;

         // 子類
        function Son(){
            Person.call(this);
        }
        Son.prototype=Object.create(Person.prototype);
        var s = new Son;
        s.__proto__.fn=function(){
            console.log(222);
        }
        s.fn(); //222
        p.fn(); //111

          6.  中間類繼承

function fn(a,b,c){
            arguments.__proto__ = Array.prototype;
            arguments.push(89);
            console.log(arguments);
}
fn(45,56,23); //45,56,23,89