说到抽象工厂，如果有接触过别的语言的话，其他语言 大概都有个 虚函数和抽象函数，然后继承的自雷重写这个方法。

利用js 也可以模拟这种操作。

在这里，抽象化创建模式不是一个真实的对象实例，而是一个类簇，制定了类的结构，这也就区别于简单工厂模式创建

单一对象，工厂模式创建多类对象。

//  抽象工厂方法

var VirtualFactory = function ( subType , superType ) {
        // 判断抽象工厂是否有该抽象类
        if( typeof VirtualFactory[superType] === 'function' ){
            // 缓存类
            function F(){}
            // 继承弗雷属性和方法，类式继承，引用类型（函数，对象，数组等）会被实例化子类公用
            F.prototype = new VirtualFactory[superType]() ;
            F.constructor = subType;
            subType.prototype = new F();
        }else{
            throw new Error('未创建该抽象类');
        }
    };
    // 小汽车抽象类
    VirtualFactory.Car = function () {
        this.type = 'car';
    };
    VirtualFactory.Car.prototype = {
        getPrice: function () {
            return new Error('抽象方法不能调用');
        },
        getSpeed: function () {
            return new Error('抽象方法不能调用');
        }
    };
    // 公交车抽象类
    VirtualFactory.Bus = function () {
        this.type = 'bus';
    };
    VirtualFactory.Bus.prototype = {
        getPrice: function () {
            return new Error('抽象方法不能调用');
        },
        getPassengerNum: function () {
            return new Error('抽象方法不能调用');
        }
    };
    // 货车抽象类
    VirtualFactory.Trunk = function () {
        this.type = 'trunk';
    };
    VirtualFactory.Trunk.prototype = {
        getPrice: function () {
            return new Error('抽象方法不能调用');
        },
        getTrainload: function () {
            return new Error('抽象方法不能调用');
        }
    };
    
    // 宝马汽车类
    var BMW = function ( price , speed) {
        this.price = price;
        this.speed = speed;
    };
    VirtualFactory( BMW , 'Car' );
    BMW.prototype.getPrice = function () {
        console.log( this.price );
    };


    var c1 = new BMW( '30W' , '200km/s');
    c1.getPrice();
    console.log( c1.getSpeed() );