对js面向对象的浅析一。

    之前一直写的代码都是面向过程的，最近接触学习了面向对象的方法。首先要区分的是面向过程POP跟面向对象OOP的区别。面向过程： 面向过程编程是以功能为中心来进行思考和组织的一种编程方法，它强调的是系统的数据被加工和处理的过程，在程序设计中主要以函数或者过程为程序的基本组织 方式，系统功能是由一组相关的过程和函数序列构成。而面向对象的编程中，对象的属性与方法不再像面向过程那样分开存放，而是视为一个整体。

   那么什么是对象呢？什么是面向对象呢？
    可以说everything is object，我们生活中的很多东西、事物都可以是对象。在JavaScript中，我们对象就是包含一组变量和函数的集合。这个也是面向对象中的一个术语，既表示客观现实世界中的具体事物，又表示软件系统解空间中的基本元素。在JavaScript中对象可以分为两类：Function和Object。
什么是面向对象呢？这个问题我觉得可以从两方面来解析。一、在使用对象的时候，只关注对象提供的功能，不关注其内部细节。二、构造对象。

  面向对象有三大基本特性：抽象、封装、继承。

    首先对于抽象的理解是：将对象的核心信息抽出来用。根据JavaScript语言的特点，通常一个类（实际上是伪类）通常是将字段放置于构造函数（实际上是new 运算符调用的函数，JavaScript本身并没有构造函数的概念）中，而将方法放置于函数的prototype属性里。
    封装：对象字面量或者实例化对象模式。
    继承：从已有的对象上，继承出新的对象。
构造对象：


var o = {};


    创建一个对象并设置属性及初始值：


var person = {name: "Angel", age: 18, married: false};


    创建一个对象并设置属性和方法：


var speaker = {text: "Hello World", say: function(){alert(this.text)}};


    创建一个更复杂的对象，嵌套其他对象和对象数组等：


    var company =
    {
        name: "Microsoft",
        product: "softwares",
        chairman: {name: "Bill Gates", age: 53, Married: true},
        employees: [{name: "Angel", age: 26, Married: false}, {name: "Hanson", age: 32, Marred: true}],
        readme: function() {document.write(this.name + " product " + this.product);}
    };




    JSON的形式就是用大括“{}”号包括起来的项目列表，每一个项目间并用逗号“,”分隔，而项目就是用冒号“:”分隔的属性名和属性值。这是典型的字典 表示形式.


构造对象


    除JSON外，在JavaScript中我们可以使用new操作符结合一个函数的形式来创建对象。例如：




    function MyFunc() {};         //定义一个空函数
    var anObj = new MyFunc();  //使用new操作符，借助MyFun函数，就创建了一个对象


上面的代码改写成这种等价形式：




    function MyFunc(){};
    var anObj = {};     //创建一个对象
    MyFunc.call(anObj); //将anObj对象作为this指针调用MyFunc函数




    可以这样理解，JavaScript先用new操作符创建了一个对象，紧接着就将这个对象作为this参数调用了后面的函数。其 实，JavaScript内部就是这么做的，而且任何函数都可以被这样调用！

     function Person(name)   //带参数的构造函数     {          this.name = name;   //将参数值赋给给this对象的属性        this.SayHello = function() {alert("Hello, I'm " + this.name);};   //给this对象定义一个SayHello方法。      };        function Employee(name, salary)     //子构造函数      {          Person.call(this, name);        //将this传给父构造函数         this.salary = salary;       //设置一个this的salary属性         this.ShowMeTheMoney = function() {alert(this.name + " $" + this.salary);};  //添加ShowMeTheMoney方法。     };          var BillGates = new Person("Bill Gates");   //用Person构造函数创建BillGates对象     var SteveJobs = new Employee("Steve Jobs", 1234);   //用Empolyee构造函数创建SteveJobs对象      BillGates.SayHello();   //显示：I'm Bill Gates    SteveJobs.SayHello();   //显示：I'm Steve Jobs    SteveJobs.ShowMeTheMoney();   //显示：Steve Jobs $1234     alert(BillGates.constructor == Person);  //显示：true    alert(SteveJobs.constructor == Employee);  //显示：true        alert(BillGates.SayHello == SteveJobs.SayHello); //显示：false

    这段代码表明，函数不但可以当作构造函数，而且还可以带参数，还可以为对象添加成员和方法。其中的第9行，Employee构造函数又将自己接收的 this作为参数调用Person构造函数，这就是相当于调用基类的构造函数。第21、22行还表明这样一个意思：BillGates是由Person构 造的，而SteveJobs是由Employee构造的。对象内置的constructor属性还指明了构造对象所用的具体函数！


    其实，如果你愿意把函数当作“类”的话，她就是“类”，因为她本来就有“类”的那些特征。难道不是吗？她生出的儿子各个都有相同的特征，而且构造函数也与类同名嘛！

    但要注意的是，用构造函数操作this对象创建出来的每一个对象，不但具有各自的成员数据，而且还具有各自的方法数据。换句话说，方法的代码体(体现函数 逻辑的数据)在每一个对象中都存在一个副本。尽管每一个代码副本的逻辑是相同的，但对象们确实是各自保存了一份代码体。上例中的最后一句说明了这一实事， 这也解释了JavaScript中的函数就是对象的概念。


    同一类的对象各自有一份方法代码显然是一种浪费。在传统的对象语言中，方法函数并不象JavaScript那样是个对象概念。即使也有象函数指针、方法指针或委托那样的变化形式，但其实质也是对同一份代码的引用。一般的对象语言很难遇到这种情况。


    不过，JavaScript语言有大的灵活性。我们可以先定义一份唯一的方法函数体，并在构造this对象时使用这唯一的函数对象作为其方法，就能共享方法逻辑。例如：

    function SayHello()     //先定义一份SayHello函数代码
    {
        alert("Hello, I'm " + this.name);
    };
    
    function Person(name)   //带参数的构造函数
    {
        this.name = name;   //将参数值赋给给this对象的属性
        this.SayHello = SayHello;   //给this对象SayHello方法赋值为前面那份SayHello代码。
    };


    var BillGates = new Person("Bill Gates");   //创建BillGates对象
    var SteveJobs = new Person("Steve Jobs");   //创建SteveJobs对象
    
    alert(BillGates.SayHello == SteveJobs.SayHello); //显示：true


    最后一行的输出结果表明两个对象共享了一个函数对象。但是性能上并不好。可以加上原型解决。

初看原型

    prototype源自法语，软件界的标准翻译为“原型”，代表事物的初始形态，也含有模型和样板的意义。JavaScript中的prototype概念恰如其分地反映了这个词的内含，我们不能将其理解为C++的prototype那种预先声明的概念。
    JavaScript的所有function类型的对象都有一个prototype属性。这个prototype属性本身又是一个object类型的对 象，因此我们也可以给这个prototype对象添加任意的属性和方法。既然prototype是对象的“原型”，那么由该函数构造出来的对象应该都会具 有这个“原型”的特性。事实上，在构造函数的prototype上定义的所有属性和方法，都是可以通过其构造的对象直接访问和调用的。也可以这么 说，prototype提供了一群同类对象共享属性和方法的机制。

    function Person(name)
    {
        this.name = name;   //设置对象属性，每个对象各自一份属性数据
    };
    
    Person.prototype.SayHello = function()  //给Person函数的prototype添加SayHello方法。
    {
        alert("Hello, I'm " + this.name);
    }

    var BillGates = new Person("Bill Gates");   //创建BillGates对象
    var SteveJobs = new Person("Steve Jobs");   //创建SteveJobs对象

    BillGates.SayHello();   //通过BillGates对象直接调用到SayHello方法
    SteveJobs.SayHello();   //通过SteveJobs对象直接调用到SayHello方法

    alert(BillGates.SayHello == SteveJobs.SayHello); //因为两个对象是共享prototype的SayHello，所以显示：true


    程序运行的结果表明，构造函数的prototype上定义的方法确实可以通过对象直接调用到，而且代码是共享的。显然，把方法设置到prototype的 写法显得优雅多了，尽管调用形式没有变，但逻辑上却体现了方法与类的关系，相对前面的写法，更容易理解和组织代码。

    那么，对于多层次类型的构造函数情况又如何呢？

    我们再来看下面的代码：

 

1     function Person(name)   //基类构造函数 2     { 3         this.name = name; 4     }; 5      6     Person.prototype.SayHello = function()  //给基类构造函数的prototype添加方法 7     { 8         alert("Hello, I'm " + this.name); 9     };10     11     function Employee(name, salary) //子类构造函数12     {13         Person.call(this, name);    //调用基类构造函数14         this.salary = salary;15     };16     17     Employee.prototype = new Person();  //建一个基类的对象作为子类原型的原型，这里很有意思18     19     Employee.prototype.ShowMeTheMoney = function()  //给子类添构造函数的prototype添加方法20     {21         alert(this.name + " $" + this.salary);22     };23 24     var BillGates = new Person("Bill Gates");   //创建基类Person的BillGates对象25     var SteveJobs = new Employee("Steve Jobs", 1234);   //创建子类Employee的SteveJobs对象26 27     BillGates.SayHello();       //通过对象直接调用到prototype的方法28     SteveJobs.SayHello();       //通过子类对象直接调用基类prototype的方法，关注！29     SteveJobs.ShowMeTheMoney(); //通过子类对象直接调用子类prototype的方法30 31     alert(BillGates.SayHello == SteveJobs.SayHello); //显示：true，表明prototype的方法是共享的。