js 面向对象

1. Object 类型

        创建 Object 对象

        通过 new 关键字 或 对象字面量

        var person = new Object();

        person.name = 'Nicholas';

        或者

        var person = {

            name : 'Nicholas'

        }

        访问属性

                可以通过点或者方括号来访问对象属性，使用方括号访问应该以字符串放在方括号中，

                通过方括号访问的优点在于，可通过变量来访问属性。

                var propertyName = 'name';

                alert(person[propertyName]);      //  等于person.name;

 

2. 创建对象

            2.1 工厂模式

                    function createPerson(name,age){

                         var o = new Object();

                         o.name = name;

                         o.age = age;

                         return o;

                    }

                    var person1 = createPerson('mm', 28);

            2.2 构造函数模式

                    function Person(name, age){

                            this.name = name;

                            this.age = age;

                            this.sayName = function(){

                                    alert(this.name);

                            }

                    }

                    var person1 = new Person('mm', 28);

                    var person2 = new Person('mm', 26);

                    alert(person1 instanceof Person);          // true

                    alert(person1.sayName == person2.sayName);  // false

            2.3 原型模式

                    每一个函数都有一个 prototype(原型）属性，它指向一个对象，这个对象包含特定类型的所有实例共享的属性和方法。

                    function Perons(){}

                    Person.prototype.name = 'Nicholas';

                    Person.prototype.sayName = function(){

                            alert(this.name)j;

                    }

                    var person1 = new Person();

                    var person2 = new Person();

                    alert(person1.name);       // Nicholas

                    alert(person1.sayName == person2.sayName);         // true;     

                                    

                    只要创建一个新函数，就会为该函数创建一个 prototype 属性，这个属性指向函数的原型对象。在默认情况下，所有原型对象都会

                    自动获得一个 constructor（构造函数）属性，指向 prototype 属性所在函数指针。

                    当调用构造函数创建一个新实例后，该实例的内部包含一个指针，指向构造函数的原型对象。这个连接存在于实例与构造函数的原型对象之间，

                    而不是存在于实例与构造函数之间。

                    person1.name = null;         // 把属性值设为null，它就是null

                    delete person1.name;        // 删除属性，但对象还是可以访问父类中的属性。

                    hasOwnProperty()      检测一个属性是否为实例的属性，而不继承来的属性。

                    'name' in person1;     只要通过对象能够访问到属性就返回 true, 不管是自己有的还是继承的。

                    for - in 循环，也是返回所有能够通对象访问的、可以枚举的属性，即包实例中的，也包括原型中。

                    Object.keys(obj);     // 返回这个对象上可以枚举的属性，不包括继承的。

                    更简单的原型语法：

                            function Person(){}

                            Person.prototype = {

                                    constructor : Person,              // 注意，这里会被枚举

                                    name : 'mm',

                                    age : 26

                            }

                    原型对象的动态性：由于在原型中查找值的过程是一次搜索，因此我们对原型对象所做的任何修改都能够立即从实例上反映出来。

                            var friend = new Person();

                            Person.prototype.sayHi = function(){

                                    alert('hi');

                            }

                            friend.sayHi();               // hi

                    但是重写整个原型对象，就不行了，如：

                            Person.prototype = {

                                    sayName : function(){

                                            alert('hi');

                                    }

                            }

              2.4 组合使用构造函数模式和原型模式

                           构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。

                           function Person(name, age){

                                this.name = name;

                                this.age = age;

                                this.friends = ['mm', 'tt];

                            }

                            Person.prototype = {

                                constructor : Person,

                                sayName : function(){

                                        alert(this.name);

                                }

                            }     

3. 继承

            3.1 原型链

            ECMAscript中，将原型连作为实现继承的主要方法。

            实现原型链的基本模式。

            function SuperType(){

                this.property = true;

            }

            function SubType(){

                this.subproperty = false;

            }

            SubType.prototype = new SuperType();         // 子类构造函数的原型对象指向父类的实例。

            var instance = new SubType();                       // instance[[Prototype]] --> new SuperType() 

            alert(instance.subproperty);       // false

            alert(instance.property);            // true

 

     3.2  确定原型和实例的关系

instanceof : 只要用这个操作符来测试实例与原型链中出现过的构造函数，就会返回 true.

 

alert(instance instanceof SuperType);    // true

 

alert(SuperType.prototype.isPrototypeOf(instance);   // true

            3.3 原型链的问题

                    如果原型中包含引用类型的属性，那么子类共享这个属性，都会指向同一个对象。

                    在他创建子类型的实例，不能向超类型的构造函数传递参数。