莽夫

抽象工厂模式

抽象工厂模式: 通过对类的工厂抽象使其业务用于对产品类簇的创建, 而不负责创建某一类产品的实例.

抽象类

定义一个产品簇, 并声明一些必备的方法, 如果子类中没有去重写而直接调用就会抛出错误.

示例

1
2
3
4
5
6
7
8
9
var car = function (){}
car.prototype = {
	getPrice: function (){
        return new Error('抽象方法不能调用')
    },
    getspeed: function (){
        return new Error('抽象方法不能调用')
    }
}

抽象工厂方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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('未创建该抽象类')
    }
}

小汽车抽象类

1
2
3
4
5
6
7
8
9
10
11
VehicleFactory.car = function () {
    this.type = 'car'
}
VehicleFactory.car.prototype = {
    getPrice: function () {
        return new Error('抽象方法不能调用')
    },
    getspeed: function () {
        return new Error('抽象方法不能调用')
    },
}

公交车抽象类

1
2
3
4
5
6
7
8
9
10
11
VehicleFactory.Bus = function () {
    this.type = 'bus'
}
VehicleFactory.Bus.prototype = {
    getPrice: function () {
        return new Error('抽象方法不能调用')
    },
    getspeed: function () {
        return new Error('抽象方法不能调用')
    },
}

新建子类-具体实现

1
2
3
4
5
6
7
8
9
var BMW = function (price, speed) {
    this.price = price
    this.speed = speed
}
// 抽象工厂实现对car抽象类的继承
VehicleFactory(BMW, 'car')
BMW.prototype.getPrice = function () {
    return this.price
}

输出测试

1
2
3
4
5
6
var bmw = new BMW(1, 100)
console.log(bmw.getPrice()) // 1
console.log(bmw.price) // 1
console.log(bmw.speed) // 100
console.log(bmw.type) // car
console.log(bmw.getspeed()) // Error: 抽象方法不能调用