JavaScript学习——对象的创建和继承

对象的创建

使用Object()构造函数或者对面字向量来创建对象

JavaScript中有多种对象创建模式，其中最简单的就是使用Object()构造函数或者对象字面量来创建对象。

        var LY1 = {
            name: "LY",
            age: 21,
            sayname: function() {
                alert(this.name);
            }
        };
        LY1.sayname();//使用对象字面量创建对象
        var LY2 = new Object();
        LY2.name = "LY";
        LY2.age = 21;
        LY2.sayname = function() {
            alert(this.name);
        }
        LY2.sayname();//使用Object()构造函创建对象

构造函数模式和原型模式

这两种方法在创建类似的对象时会产生大量相似的代码。更好的方法是使用构造函数模式和原型模式。

        function LY1(name, age) {
            this.name = name;
            this.age = age;
            this.sayname = function() {
                alert(this.name);
            };
        }
        var ly1 = new LY1("LY1", 21);
        var ly11 = new LY1("LY11", 21); //使用构造函数的方法创建对象
        function LY2() {}
        LY.prototype.name = "LY2";
        LY.prototype.age = 21;
        LY.prototype.sayname = function() {
            alert(this.name);
        }
        var ly2 = new LY2();
        var ly22 = new LY2(); //使用原型模式构造对象

在ECMAScript中，每一个函数都是一个对象，都相当于Function类型的一个实例

因此，在使用构造函数LY1构造对象ly1和ly11时，sayname方法在每个实例中都构建了一遍，这导致了不同的作用域链

解决这个问题的方法是使用原型模式

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

但如果将所有属性和方法都由原型模式指定，则会导致所有实例没有自己独立的属性或者方法

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

        function LY(name, age) {
            this.name = name;
            this.age = age;
        }
        LY.prototype = {
            constructor: LY,
            sayName: function() {
                alert(this.name);
            }
        };
        var ly1 = new LY();
        var ly2=  new LY();

这样创建的两个对象就既有共享属性又有自己独立的属性

动态原型模式

动态原型模式和传统的OO语言中的构造函数最相似

function LY(name, age) {
    this.name = name;
    this.age = age;
    if (typeof this.sayName != "function") {
        LY.prototype.sayName = function() {
            alert(this.name);
        };
    }
}

继承

原型链

原型链是实现继承的主要方法。其实质是通过将被继承的类型的实例赋值给一个原型对象

function Child() {
    this.name = "LY";
}

function Parent() {
    this.age = 21;
}
Parent.prototype.getAge = function() {
    alert(age);
}
Child.prototype = new Parent();
Child.prototype.getName = function() {
    alert(this.name);
};
var child = new Child();

将Parent类型的实例赋值给Child类型的原型，赋值之后Child类型的实例child继承了Parent()的属性,接着又向Child类型的原型添加了getName()方法

这样的方式虽然可以实现继承，但是，将Parent()的实例赋给Child的原型后，实例属性就变为原型属性了，这样，实例中的属性就会被所有Child()实例共享

借用构造函数

可以使用借用构造函数解决这个问题

借用构造函数是在子类型构造函数中调用超类型构造函数

function Parent() {
    this.age = 21;
}

function Child() {
    Parent.call(this);
}
Child.prototype = new Parent();
var child1 = new Child();
var child2 = new Child();

这样在创建child1和child2是就会分别创建Parent()的实例，在修改child1时就不会对child2产生影响

组合继承

组合继承就是将原型链和借用构造函数组合一起，使用原型链实现对原型属性和方法的继承，使用构造函数实现对实例属性的继承

function Parent() {
    this.age = 21;
}

function Child() {
    this.name = "LY";
    Parent.call(this);
}
Child.prototype = new Parent();
var child1 = new Child();
var child2 = new Child();

在上面的代码中，借用call()函数使得Child()函数获得Parent()函数中的属性。使用原型链获得Parent原型中的方法
组合继承是JavaScript中使用较多的继承方式