想象一下,设计一个手机的流水生产线,你需要怎么设计,首先要明确手机由两部分组成,一个是操作系统,一个是处理器这个是手机的核心所以我们要首先做出一个抽象工厂类
class MobilePhoneFactory{
// 提供操作系统的接口
createOs{
throw new Error('抽象工厂的方法不能直接调用,你需要将我重写')
}
//提供硬件的接口
createHadeWare(){
throw new Error('抽象工厂的方法不能直接调用,你需要将我重写')
}
}
楼上这个类,除了约定手机流水线的通用能力之外,啥也不干,你如果用 new 调用之外,它还会给你报错,这个类就是个定规矩的,但是没有具体的职能,这就是我们说的抽象工厂
抽象工厂不干活,具体工厂干活,当我们明确了一个型号的手机的具体生产方案的时候,具体工厂就可以来干活了,比如我们要建造一个android系统 加 高通硬件的一个手机,我们给他起名字叫facker
具体工厂继承自抽象工厂
class facker extends MobilePhoneFactory{
createOs(){
// 提供安卓系统实例
return new AndroidOs()
}
createHareWare(){
// 提供高通硬件系统实例
rerurn new QualcommHardWare()
}
}
我们在提供系统的时候调用了两个函数AndroidOs,QualcommHardWare,他们提供具体的硬件,和操作系统实例,因为是两个不同功能我们需要把他们抽离出来,符合软件系统里,高聚合,低耦合的特性,需要把系统封装为一个类,硬件封装为一个类
// 定义一个手机系统的抽象工厂
class Os{
controlHardWare(){
throw new Error('抽象方法不允许直接调用需要你将我重写')
}
}
// 定义操作系统的具体产品类
class AndroidOS extends Os{
controlHardWare(){
console.log('我会用android系统的方法去操作硬件')
}
}
// class Apple extetends Os{
console.log('我会用苹果系统的方法去操作硬件')
}
// 定义手机硬件
// 定义手机硬件这类产品的抽象产品类
class HardWare {
// 手机硬件的共性方法,这里提取了“根据命令运转”这个共性
operateByOrder() {
throw new Error('抽象产品方法不允许直接调用,你需要将我重写!');
}
}
// 定义具体硬件的具体产品类
class QualcommHardWare extends HardWare {
operateByOrder() {
console.log('我会用高通的方式去运转')
}
}
class MiWare extends HardWare {
operateByOrder() {
console.log('我会用小米的方式去运转')
}
}
好了,如此一来,当我们需要生产一台FakeStar手机时,我们只需要这样做:
// 这是我的手机
const myPhone = new facker()
// 让他拥有操作系统
const myOs = myPhone.createOs()
// 让他拥有硬件
const myHareWare = myPhone.createHareWare()
// 让操作系统运转起来
myOs.controlHardWare()
// 让硬件跑起来
myHareWare.QualcommHardWare()
关键的时候来了,如果这台手机过时了在生产一台手机就会变的简单
class ximi3c extends MobilePhoneFactory{
createOs(){
// 新手机用的操作系统
}
createHadeWare(){
// 新手机用的硬件
}
}
这样一个遵循开放封闭(对拓展开放,对修改封闭),并且符合低耦合,高聚合的一个系统就设计出来了