前言
之前看书认真了解过这三种模式,但因为没有做记录,都给忘完了。现在重新分析网上的博客发现跟书里讲的不太一样,哎…。现在能做的就是把现在的理解给记录一下,若以后有更深入的理解在作补充
简单工厂
不符合开放闭合原则:增加一个类型,既需要修改Factory类,又需要新创建类
class Factory {
static CreateTaix(val) {
return new Taix(val);
}
static CreateBus(val) {
return new Bus(val);
}
}
function Taix(val) { this.val = val; }
function Bus(val) { this.val = val; }
const car = Factory.CreateTaix('BMW');
const bus = Factory.CreateBus('YuTong');
console.log(car, bus);
工厂方法
符合开放闭合原则,但不支持同品牌的多个产品
class Factory {
create() {
console.warn('子类必须重写create函数');
}
}
class ProductAFactory extends Factory {
create() {
return new ProductA();
}
}
class ProductBFactory extends Factory {
create() {
return new ProductB();
}
}
class Product {
show() {
console.log(this);
}
}
class ProductA extends Product {
}
class ProductB extends Product {
}
const aF = new ProductAFactory();
aF.create().show();
const bF = new ProductBFactory();
bF.create().show();
抽象工厂
这不就是上面两个的组合嘛
class Factory {
createContainer() {
console.warn('子类必须重写createContainer函数');
}
createModule() {
console.warn('子类必须重写createModule函数');
}
}
class FactoryA extends Factory {
createContainer() {
return new ContainerProductA();
}
createModule() {
return new ModuleProductA();
}
}
class FactoryB extends Factory {
createContainer() {
return new ContainerProductB();
}
createModule() {
return new ModuleProductB();
}
}
class Product {
show() {
console.log(this);
}
}
class ContainerProduct extends Product {
}
class ModuleProduct extends Product {
}
class ContainerProductA extends ContainerProduct {
}
class ContainerProductB extends ContainerProduct {
}
class ModuleProductA extends ModuleProduct {
}
class ModuleProductB extends ModuleProduct {
}
const mFactoryA = new FactoryA();
const mFactoryB = new FactoryB();
//A厂当地客户需要容器产品A
mFactoryA.createContainer().show();
//A厂当地客户需要模具产品A
mFactoryA.createModule().show();
//B厂当地客户需要容器产品B
mFactoryB.createContainer().show();
//B厂当地客户需要模具产品B
mFactoryB.createModule().show();