JavaScript的闭包、继承和多态笔记

---

闭包

函数对象可以通过作用域链相互关联，函数体内部的变量都可以保存在函数作用域内，这种特性称之为“闭包”。
当一个函数嵌套了另外一个函数，外部函数将嵌套的函数对象作为返回值返回的时候，我们会发现函数定义时的作用域链（函数内的变量）到函数执行时依然有效（被调用）。

闭包典型应用实例：简单计数器

需求： 简单计数器。计数器对象counter，属性add、subtract、reset。调用add()，计数器+1；调用substract()，计数器-1；调用reset()，计数器归零

//实例代码1
function counter(){
    var result = 0 ;
    return{
        add: function(){ return result++; },
        subtract: function(){ return result--; },
        reset: function(){ return result=0; }
    };
}
var counter1 = counter(), counter2 = counter();
counter1.add()                \\ => 0
counter2.add()                \\ => 0
counter1.add()                 \\ => 1
counter1.reset()               \\ => 0
//以上感觉没有问题。
counter1.reset()               \\0
counter1.subtract()          \\0
counter1.add()                \\-1
counter1.add()                \\0
//以上输出就很奇怪了，为什么在第一次subtract是0，后调用add，结果为-1？

实例代码2
function counter(){
    var result = 0;
    var func ={};
    func.add = function(){
        result++;
        return result;
    };
    func.subtract= function(){
        result--;
        return result;
    };
    func.reset= function(){
        result=0;
        return result;
    };
    return func;
}
//result是一个函数内的局部变量，但是却起到了全局变量的效果，并且不会相互影响。可以减少代码之前的相互干扰，减少耦合性。
var counter1 = counter(), counter2 = counter();
counter1.reset()               \\0
counter1.subtract()          \\-1
counter1.add()                \\0
counter1.add()                \\1
//输出正常，^ . ^

---

继承

以前学习java中有类和实例的概念。在JavaScript中，不区分类和实例的概念，而是通过原型（prototype）来实现面向对象编程。
原型继承：
比如，创建一个Array对象
var arr = [ 1, 2, 3 ];
其原型链是：
arr ----> Array.prototype ----> Object.prototype ----> null
因此Array.prototype定义了indexOf()、shift()等方法，因此可以再Array对象上直接调用这些方法。
实例：

//父类  人，具有属性 名字和介绍自己的方法。
function person(name){
    this.name = name;                                      //必须使用this进行绑定
    this.hello = function(){
        alert("Hello, I'm "+this.name+".");
    };
}
//小明对象，继承人的属性和方法。
var xiaoming = new person("小明");      //必须有new关键词，变成构造函数
xiaoming.name;
xiaoming.hello();

父类还可以写成这样：

function person(objname){
    this.name = objname || "Unnamed";
}
 person.prototype.hello()= function(){
    alert("Hello, I'm "+this.name+".");
 }

在ES6以后，新的关键词class可以定义类了。

class person{
    constructor(name) {                               //包含了构造函数constructor
        this.name = name;
    }

    hello() {                                                  //没有function关键词
        alert('Hello, ' + this.name + '!');
    }
}

同时继承更加的方便，可以直接采用extends关键词实现

class seniorPerson  extends person{
    constructor(name,sex){
        super(name);
        this.sex = sex;
    }
    
    mySex(){
        alert('I am a'+this.sex+'.');
    }
}

---

多态

在学习java的时候，多态实际上是重载(Reload)或者重写(Rewrite)。

• 重载：多个方法，方法名相同，参数的个数或者参数的类型不一样。
• 重写：子类重写父类的方法。

在JavaScript中如果函数名相同，后面的会把前面的函数覆盖掉，因此不存在重载。