继承的原理及方法

继承的实现：

1.所有开发者定义的类都可以作为基类.

2.出于安全原因，本地类和宿主类不能作为基类，这样可以防止公用访问编译过的浏览器级的代码，因为这些代码可以被用于恶意攻击.

3.创建的子类将继承超类的所有属性和方法，包括构造函数及方法的实现.

4.所有属性和方法都是公用的，因此子类可直接访问这些方法，子类还可以添加超类中没有的新属性和方法，也可以覆盖超类的属性和方法.

call()方法的使用：

它的第一个参数用作this的对象，其他参数都直接传递给函数自身.

apply()的使用：

apply()方法有两个参数，用作this的对象和要传递给函数的参数的数组.

bind()方法的使用：

bind()方法的主要作用就是将函数绑定到某个对象，bind()方法会创建一个函数，函数体内this对象的值会被绑定到传入bind()函数的值.

        // Function.prototype.bind(this Arg[,arg1[,arg2[,...]]])
        // eg:
        Function.prototype.bind=function(context){
            var self=this;//保存原函数
            return function(){//返回一个新函数
                return self.apply(context,arguments);
                // 执行新函数时，将传入的上下文context作为新函数的this
            }
        }

call方法的使用：

        // 改变this指向，继承后再传参
        function sayColor(sPrefix, sSuffix) {
            alert(sPrefix + this.color + sSuffix);
        }
        var obj = new Object(); //原始对象
        obj.color = "blue";
        sayColor.call(obj, "这个颜色是：", "颜色的后缀！");

apply方法的使用：

 function sayColor(sPrefix, sSuffix) {
            alert(sPrefix + this.color + sSuffix);
        }
        var obj = new Object();
        obj.color = "blue";
        sayColor.apply(obj, new Array("这个颜色是：", "颜色的后缀！"));//数组形式传入

bind的用法：

        // 把A this指向B，并且把实参也给B
        var A = function(name) {
            this.name = name;
        }
        var B = function() {
            A.bind(this.arguments);
        }
        B.prototype.getName = function() {
            return this.name;
        }
        var b = new B("hello");
        console.log(b.getName()); //"hello"

call、apply、bind区别：

    工作原理：call和apply是让当前执行函数this指向第一个参数(对象)，bind方式将第一参数对象this指向当前绑定的对象.

    语法上：call和apply属于立即执行函数，call传递的内容参数类型，apply传递的是数组，bind异步执行函数.

    共同点：改变this指向.

构造函数继承(多重继承，纯构造函数继承)：

     function ClassA(sColor) {
            this.color = sColor;
            this.sayColor = function() {
                alert(this.color);
            }
        }

        function ClassB(bColor, bName) {
            this.newMethod = ClassA;//立即执行
            this.newMethod(bColor);//立即执行
            delete this.newMethod;//删除this指向
            this.name = bName;
            this.sayName = function() {
                alert(this.name);
            }
        }

原型链：

1.原型链扩展了这种方式，以一种有趣的方式实现继承机制.

2.原型链的弊端是不支持多重继承.

3.原型链会用另一类型的对象重写类的prototype属性

把ClassB的prototype属性设置成ClassA的实例：

        function ClassA() {}
        ClassA.prototype.color = "blue";
        ClassA.prototype.sayColor = function() {
            alert(this.color);
        }

        function ClassB() {}
        ClassB.prototype = new ClassA();

寄生组合类继承(混合函数继承)：

        function ClassA(sColor) {
            this.color = sColor;
        }
        ClassA.prototype.sayColor = function() {
            alert(this.color);
        }

        function ClassB(sColor, sName) {
            // this.color = sColor;//相当于运行了一遍这个函数
            ClassA.call(this, sColor); //这里this指的B对象，所以ClassA.call立即执行的.当A运行时，里面this.color=sColor;原来指的时A，但是，通过call运行，现在指向B，所以当ClassA运行完后，ClassB就有color.
            // this.newMethod = ClassA; //立即执行
            // this.newMethod(bColor); //立即执行
            // delete this.newMethod; //删除this指向(相当于这三句话)
            this.name = sName;
        }
        ClassB.prototype = new ClassA();
        ClassB.prototype.sayName = function() {
            alert(this.name);
        }

new的作用总结：

1.new的详细操作步骤：

(1) 创建一个新对象.

(2) 将构造函数的作用域赋给新对象(因此this就指向了这个新对象).

(3) 执行构造函数中的代码(为这个新对象添加属性).

(4) 返回新对象.