设计模式知识连载（15）---抽象工厂模式:

最新推荐文章于 2022-11-14 18:51:37 发布

宇智波幽助

最新推荐文章于 2022-11-14 18:51:37 发布

阅读量144

点赞数

分类专栏：设计模式文章标签：设计模式抽象工厂模式

本文链接：https://blog.csdn.net/yuzhiboyouzhu/article/details/78795625

版权

设计模式专栏收录该内容

51 篇文章 0 订阅

订阅专栏

<body>

<h3>设计模式知识连载（15）---抽象工厂模式:</h3>
<p>
    抽象工厂模式：通过对类的工厂抽象使其业务用于对产品类簇的创建（制定了类的结构），
    而不负责创建某一类产品的实例。唯一一种抽象化创建模式
</p>

<script type="text/javascript">


    /**
    *   案例
    */


    // （了解抽象类用的）汽车抽象类【父类】，当使用其 实例对象的方法时会抛出错误
    var Car = function () {} ;

    Car.prototype = {
        getPrice : function() {
            return new Error('抽象方法不能调用') ;
        },
        getSpeed : function() {
            return new Error('抽象方法不能调用') ;
        }
    } ;

    /*-------------------------------------------------------*/

    // 抽象工厂方法
    var VehicleFactory = function(subType, superType) {

        // 判断抽象工厂中是否有该抽象类
        if( typeof VehicleFactory[superType] === 'function') {

            // 缓存类
            function F() {} ;

            // 继承父类属性和方法
            F.prototype = new VehicleFactory[superType]() ;

            // 将子类constructor指向子类
            subType.constructor = subType ;

            // 子类原型继承“父类”
            subType.prototype = new F() ;
        }else{
            // 不存在该抽象类时，抛出错误
            throw new Error('未创建该抽象类') ;
        }
    } ;

    // 小汽车抽象类
    VehicleFactory.Car = function() {
        this.type = 'car' ;
    } ;
    VehicleFactory.Car.prototype = {
        getPrice : function() {
            return new Error('抽象方法不能调用') ;
        },
        getSpeed : function() {
            return new Error('抽象方法不能调用') ;
        }
    } ;

    // 公交车抽象类
    VehicleFactory.Bus = function(){
        this.type = 'bus' ;
    } ;
    VehicleFactory.Bus.prototype = {
        getPrice : function() {
            return new Error('抽象方法不能调用') ;
        },
        getSpeed : function() {
            return new Error('抽象方法不能调用') ;
        }
    } ;

    // 货车抽象类
    VehicleFactory.Truck = function() {
        this.type = 'truck' ;
    } ;
    VehicleFactory.Truck.prototype = {
        getPrice : function() {
            return new Error('抽象方法不能调用') ;
        },
        getSpeed : function() {
            return new Error('抽象方法不能调用') ;
        }
    } ;

    // 抽象和实现

    // 宝马汽车子类
    var BMW = function(price, speed) {
        this.price = price ;
        this.speed = speed ;
    } ;
    // 抽象工厂实现对Car抽象类的继承
    // VehicleFactory(BMW, Car) ;   // Uncaught Error: 未创建该抽象类
    VehicleFactory(BMW, 'Car') ;
    /*
    *   这样写，等价于把BMW.prototype原有的内容都覆盖了。
    *   所以会导致bmw.type = 'undefined'
    */
    // BMW.prototype = {
    //  getPrice : function() {
    //      return this.price ;
    //  },
    //  getSpeed : function() {
    //      return this.speed ;
    //  }
    // } ;
    /*
    *   这样写，才是在BMW.prototype原有的基础上添加
    *   因此bmw.type = 'car'
    */
    BMW.prototype.getPrice = function() {
        return this.price ;
    } ;
    BMW.prototype.getSpeed = function() {
        return this.speed ;
    } ;

    // 兰博基尼汽车子类
    var Lamborghini = function(price, speed) {
        this.price = price ;
        this.speed = speed ;
    } ;
    // 抽象工厂实现对Car抽象类的继承
    VehicleFactory(Lamborghini, 'Car') ;
    Lamborghini.prototype.getPrice = function() {
            return this.price ;
    } ;
    Lamborghini.prototype.getSpeed = function() {
            return this.speed ;
    } ;

    // 宇通汽车子类
    var YUTONG = function(price, passenger) {
        this.price = price ;
        this.passenger = passenger ;
    } ;
    // 抽象工厂实现对Car抽象类的继承
    VehicleFactory(YUTONG, 'Bus') ;
    YUTONG.prototype.getPrice = function() {
        return this.price ;
    } ;
    YUTONG.prototype.getPassengerNum = function() {
        return this.passenger ;
    }

    // 奔驰汽车子类
    var BenzTruck = function(price, trainLoad) {
        this.price = price ;
        this.trainLoad = trainLoad ;
    } ;
    // 抽象工厂实现对Car抽象类的继承
    VehicleFactory(BenzTruck, 'Truck') ;
    BenzTruck.prototype.getPrice = function() {
        return this.price ;
    } ;
    BenzTruck.prototype.getTrainLoad = function() {
        return this.trainLoad ;
    } ;

    // 实例化
    var bmw = new BMW(200000, 200) ;
    var lamborghini = new Lamborghini(300000, 300) ;
    var yutong = new YUTONG(100000, 10) ;
    var benz = new BenzTruck(500000, '柏油马路') ;

    console.log('宝马汽车子类--------------------------------------------------') ;
    console.log('bmw：', bmw) ;
    console.log('bmw.type：', bmw.type) ;
    console.log('bmw.getPrice：', bmw.getPrice()) ;
    console.log('bmw.getSpeed：', bmw.getSpeed()) ;
    console.log('兰博基尼汽车子类----------------------------------------------') ;
    console.log('lamborghini：', lamborghini) ;
    console.log('lamborghini.type：', lamborghini.type) ;
    console.log('lamborghini.tgetPrice：', lamborghini.getPrice()) ;
    console.log('lamborghini.getSpeed：', lamborghini.getSpeed()) ;
    console.log('宇通汽车子类--------------------------------------------------') ;
    console.log('yutong：', yutong) ;
    console.log('yutong.type：', yutong.type) ;
    console.log('yutong.tgetPrice：', yutong.getPrice()) ;
    console.log('yutong.getSpeed：', yutong.getSpeed()) ;    // Error: 抽象方法不能调用
    console.log('yutong.getPassengerNum：', yutong.getPassengerNum()) ;  
    console.log('奔驰汽车子类--------------------------------------------------') ;
    console.log('benz：', benz) ;
    console.log('benz.type：', benz.type) ;
    console.log('benz.tgetPrice：', benz.getPrice()) ;
    console.log('benz.getSpeed：', benz.getSpeed()) ;        // Error: 抽象方法不能调用
    console.log('benz.getPassengerNum：', benz.getTrainLoad()) ; 

</script>

</body>

宇智波幽助

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式知识连载（15）---抽象工厂模式:

<body><h3>设计模式知识连载（15）---抽象工厂模式:</h3><p> 抽象工厂模式：通过对类的工厂抽象使其业务用于对产品类簇的创建（制定了类的结构），而不负责创建某一类产品的实例。唯一一种抽象化创建模式</p><script type="text/javascript"> /** * 案例 */ // （了解抽象类用的）汽车抽象类
复制链接

扫一扫

专栏目录