面相对象的学习，对象的封装与继承

1.什么是面向对象

面向对象的语言都有一个标志，就是他们都有类的概念。对象的抽象就是类，类的实例化就是对象。

面向对象编程指得是编程的一种思想模式

比如要制作一辆汽车

面向过程的话我们需要：

（1）列出需要什么组件

（2）购买组件

（3）组装生产

（4）得到成品

面向对象的话我们只需要按一下按钮就生产出一辆车来，至于车是怎么生产出来的我们不需要了解

2.创建对象

1         var car = {};//创建一个空对象
2         car.name = name;
3         car.color = color;
4         car.show=function(){
5             alert(car.name);
6         }

这种是JavaScript创建对象最基本的方法，但有个缺点，想创建一个类似的对象，就会产生大量的代码，不够优化，所以我们会用一个函数把它封装起来，这就用到了对象的封装

3.对象封装

3.1工厂模式

    function Car(name,color){
        var car = {};//创建一个空对象
        car.name = name;
        car.color = color;
        car.show=function(){
            alert(this.name);
        }
        return car;
    }
    
    var car1=Car("奥迪","白色");
    var car2=Car("宝马","黑色");

工厂模式解决了对象重复实例化的问题，但是不能识别到底是哪个对象的实例，因为都是用new Object()创建的

3.2构造函数

    function Car(name,color){
        this.name = name;
        this.color = color;
        this.show=function(){
            alert(this.name);
        }
    }

    var car1=new Car("奥迪","白色");
    var car2=new Car("宝马","黑色");

　　alert(car1.show==car2.show2);//false,引用地址不同

使用构造函数的方法，即解决了重复实例化的问题，又解决了对象识别的问题

但是每次实例一个对象的时候都会重新占用一次内存，因为car1和car2的属性和方法的内存地址是不同的，造成内存的浪费

3.3原型方式

每个对象都有prototype属性，对象可以继承prototype里的属性和方法

    function Car(){}
    Car.prototype.name = "奥迪";
    Car.prototype.color = "白色";
    Car.prototype.show = function(){
        alert("开汽车");
    }
    
    var car1 = new Car();
    var car2 = new Car();

　　alert(car1.show==car2.show2);//true,引用地址相同

属性和方法都写在原型里面，然后实例化出对象就不会重新分配内存，解决了内存资源浪费的问题

但是如果实例化出的对象属性值或者方法不同怎么办？我们制造的车并不都是奥迪，也不都是白色的。

3.4混合模式

混合模式是把构造函数与原型结合起来使用，将不变的方法和属性写在原型中，将需要改变的属性和方法写在构造函数里

    function Car(name,color){
        this.name = name;
        this.color = color;
    }

    Car.prototype.show = function(){
        alert("开汽车");
    }

    var car1=new Car("奥迪","白色");
    var car2=new Car("宝马","黑色");

3.对象继承

原型链继承

对象冒充call和apply