混合对象 "类" ---js实现继承的两种方式

面向对象的好处：

1、每一个对象的本质上就是一个命名空间。可以用这种方法来模拟java和c#的包
2、使用对象来隐藏数据。

function newClass() {
    this.firstName="frank";
    lastName="cc";
    console.log(lastName);  //cc
}
    var cc=new newClass();
    console.log(cc.firstName);   //frank
    console.log(cc.lastName);   //undefined

lastName就被封装在类newClass中，只有在类内可以访问，类外不可以访问。

类理论

类：数据和操作数据的行为的互联
js中没有类，类是它的一种设计模式。所以js中的并不存在可以被实例化的类。同时js中的对象的并不会被复制到其他对象，他们只是被关联起来。
使用程序实现真正的对象之间的复制。把类当作蓝图，把房子当作实例。类和实例的关系。
第一种继承方式：显式混入

  function mixin(sourceObject,targetObject) {
        for(var key in sourceObject){
            if(!(key in targetObject)){
                targetObject[key]=sourceObject[key];
            }
        }
        return targetObject;
    }
    var Vechile={
        engine:1,
        igintion:function () {
          console.log("turing on my engine"+this.engine)  ;
        },
        drive:function () {
            this.igintion();
            console.log("streeting and moving forward");
        }
    }
    var car=mixin(Vechile,{
        wheels:4,
        engine:2,
        drive:function () {
            Vechile.drive.call(this);
            console.log("Rolling on all"+this.wheels+"wheels");
        }
    })
   car.drive();  //turing on my engine2   streeting and moving forward   Rolling on all4wheels

现在的car中已经有了Vechine的属性和函数的副本了。但是从技术的角度来讲，复制的是函数的引用。也就是car只是从Vechile中复制了igintion的引用。而不是函数本身。Vechile.drive.call(this)这句话就是显式多态。但是这种方式会导致代码复杂。
第二种继承的方式：

  function Vechile() {
        this.engine=1;
    }
    Vechile.prototype.igintion=function () {
        console.log("引擎正在发动");
    }
    Vechile.prototype.drive=function () {
        this.igintion();
        console.log("开始行走");
    }
    function Car() {
        var car=new Vechile();
        car.wheels=4;
        var Vdrive=car.drive;
        car.drive=function () {
            Vdrive.call(this);
            console.log("汽车正在启动");
        }
        return car;
    }
    var car=new Car();
    car.drive();