面向对象（oop）

1.单例模式

var obj={
    name:'张三',
    age:20,
}

var obj2={
    name:'李四',
    age:23,
}

通过对象，每一个对象都要重写一份一模一样的代码

2.工厂模式

        function f(name, age) {
            var obj = {
                name: name,
                age: age
            }
            return obj;
        }
        var p1 = f('李四', 18);
        var p2 = f('张三', 23);
        console.log(p1.name);   //李四
        console.log(p2.name);   //张三

通过函数，函数封装，体现高内聚，低耦合的思想。减少页面中冗余代码，提高重复利用率。

返回的都是Object对象，没有办法区分

3.构造函数模式

        function Person(name, age) {
            this.name = name;
            this.age = age;
            this.say = function () {
                console.log('hello' + this.name);
            }
        }
        function Dog(cry) {
            this.cry = cry;
            this.say = function () {
                console.log(this.cry);
            }
        }
        var p1 = new Person('李四', 18);
        var p2 = new Person('张三', 23);
        var dog = new Dog('汪汪');
        console.log(p1);
        console.log(p2);
        console.log(dog);

这种方式，能够区分，也存在问题，我们每次调用构造函数，都会创建一个相同的方法

4.原型对象(公私分明)

每一个函数都有一个属性（prototype）指向原型对象

        function Person(name, age) {
            this.name = name;
            this.age = age;
        }
        Person.prototype.say = function () {
            return ('hello--' + this.name);
        }

        var p1 = new Person('李四', 18);
        var p2 = new Person('张三', 23);
        console.log(p1.say());
        console.log(p2.say());

要理解两个知识点

1.this指向

        一般情况下，谁调用，指向谁。

        在js 全局作用域，this指向window。

        在对象方法中，this执行这个对象本身。

        在构造函数中，this指向本类的实例对象。

        在事件处理程序中，this指向绑定事件的dom元素。

   更改this指向，可以使用call，apply，bind

        apply和call一样，修改this指向的同时调用函数，唯一区别是，传参不同。apply需要提供一个数组。

        bind修改this指向时不会调用函数，而是生成一个新的函数，新的函数和原函数代码一样，但是里面的this是绑定的。

2.原型和原型链

 

 js 中的对象都有一个属性叫做__proto__，指向对象的原型。当访问对象中的属性和方法时，首先会在对象本身寻找，如果找不到会在原型中寻找，原型中找不到会在原型的原型中寻找，直到最顶层。

js 中类都有一个prototype的属性，表示本类的原型对象，通过这个类的实例化对象，__proto__指向本类的prototype。

一个类的prototype也是一个对象，它也有__proto，把它的__proto__指向另一个类的prototype时，那么这个类的对象就能访问另一个类中的方法，从而实现了方法的继承。

        function Person(name, age) {
            this.name = name;
            this.age = age;
        }
        Person.prototype.sayPerson=function(){
            return ('person');
        }


        function Student(name, age, className) {
            Person.call(this, name, age);
            this.className = className;
        }
        Student.prototype.sayStudent=function(){
            return ('student');
        }

        Student.prototype.__proto__ = Person.prototype;
        
        var s = new Student('李四', 20, '3班');
        
        console.log(s);
        console.log(s.sayStudent());
        console.log(s.sayPerson());

A类的prototype指向另一个类B，B的prototype又可以指向C，这种结构叫做原型链。