面向对象

编程思想

把构成问题的事务分解成模块（对象），描述这些对象的整体，先整体再具体。
附：面向过程：分析出解决问题所需的步骤，依次执行，先具体再整体。

创建方式

1. 字面量创建
   弊端：代码冗余
2. 内置构造函数
   弊端：代码冗余
3. 工厂函数
   弊端：无法判断对象属于哪一个类型
4. 自定义构造函数
   弊端：每个实例调用的方法应该是一致的，但是实际上在生成实例时，各自都创建了自己的方法。消耗了内存。

构造函数

构造函数创建对象时的4个步骤

1. 创建一个新对象
2. 改变this指向，指向这个新对象
3. 执行构造函数里的代码，给这个新对象添加属性和方法
4. 返回这个新对象

this指向问题

指导思想：谁调用指向谁

1. 普通函数：this -> window
2. 对象方法里：this -> 对象
3. 严格模式下：this -> undefined
4. 箭头函数：this -> 定义时所在环境中的那个this对象
5. 构造函数：this -> 实例

例子：

<script>
    // //普通函数
    function foo() {
        console.log(this); //window
    }
    foo();

    // //对象方法里this
    var obj = {
        age: 21,
        sayHello: function() {
            console.log(this); //Object
        }
    }
    obj.sayHello();

    //严格模式
    "use strict"

    function foo() {
        console.log(this); //严格模式下普通函数里this是指向undefined
    }
    foo();
</script>

<script>
    //箭头函数1
    var obj = {
        age: 21,
        sayHello: () => {
            console.log(this); //window
        }
    }
    obj.sayHello();


    //箭头函数2
    var name = "window";
    var obj = {
        name: "aa",
        sayHello: function() {
            console.log(this); //Object
            setTimeout(() => {
                //setTimeout是window内置的方法
                console.log(this.name); //Object
            })
        }
    }
    obj.sayHello();
</script>

<script>
//构造函数
    function Person(name, age) {
        this.name = name; //this指向实例
        this.age = age;
        this.sayHello = function() { 
            console.log(this.name);
        }
    }
    var person = new Person("john", 20);
    console.log(person.name, person.age);
</script>

原型对象

1. 原型对象：每个函数都有的一个属性，prototype
2. 原型对象上的属性和方法能被实例所访问。
3. 解决了多个实例相同的方法指向不一样的问题，但是无法添加自己的属性值。

原型链

1. 每一个构造函数都有一个原型对象。
2. 每一个原型对象上都有一个指向构造函数的指针（constructor）
3. 每一个实例上有指向这个原型对象的内部指针__proto__
4. 原型对象上的属性和方法能被实例所访问到。

以上内容都是在逆战班中强化总结所得。