设计模式之工厂模式

简单工厂模式

简单工程模式是由一个工厂对象决定创建出哪一类型的类的实例
解决的问题： 直接使用new 创建对象耦合严重，必须知道对方存在，相互依赖，
使用简单工厂模式，隐藏实现，方便使用，减少耦合

• 简单示例

场景： 在很久很久以前，没有工厂，只有大师傅，我们做个工具什么的都要找他。这个时候你首先需要先知道整个人在哪来，然后找他给你做你想要的东西，但是呢，价格，工期什么的都需要你们详谈。后来发现这样效率很低啊，然后每次谈起来很费事，后来就用了中间商，中间商说，你只需要告诉我你要什么，具体的沟通我帮你搞定就好了，然后代办公司(简单工厂)就这么出现了。

// 1.定义实例

class Plant {
	constructor (name) {
		this.name = name
	}
	grow () {
		console.log('我正在生长')
	}
}

class Apple extends Plant {
	constructor (name, flavour) {
		super(name)
		this.flavour = flavour
	}
}
class Orange extends Plant {
	constructor (name, flavour) {
		super(name)
		this.flavour = flavour
	}
}

// 2.定义工厂
class Factory {
	static create (type) {
		switch (type) {
		case 'apple':
			return new Apple('苹果', '甜的');
		case 'orange':
			return new Orange('桔子', '酸的')
		default:
			throw new Error('你要的类没有的哦，换个别的把。。。')
		}
	}
}

// 3.创建实例
let apple = Factory.create('apple')
let orange = Factory.create('orange')
console.log(apple.flavour)

工厂方法模式

Factory Method， 又称多态性工厂模式, 给每个类设置一个工厂方法
在工厂方法模式中，核心的工厂类不在负责所有的产品创建，而是将具体的工作交给了子类去做

• 实例代码

过了一段时间，这个工厂发现光做一个业务，业务量太小，没办法养活工人啊。后来在想，是不是应该扩展一下业务线，这样子自己就可以有跟多的业务，而且还能扩大规模，然后只要保持好人员分工就好了，每个员工(类)负责自己的业务线。然后我们发现这个公司提供了很多业务，然后当我们有需求的时候，就去该公司，然后该公司会按照我们的需求，安排不同业务线的人员和我们对接，然后得到我们要的结果

// 1.定义实例
class Plant {
	constructor(name) {
		this.name = name;
	}
}

class Apple extends Plant {
	constructor(name, flavour) {
		super(name)
		this.flavour = flavour
	}
}

class Orange extends Plant {
	constructor(name, flavour) {
		super(name)
		this.flavour = flavour
	}
}

// 工厂一般是接口， 规定子类必须实现的方法
// 依赖抽象，而不依赖实现， 如果一个类要实现该接口，必须实现该接口中的所有方法

class Factory {
	create(name, flavout) {}
}

class AppleFactory extends Factory {
	static create(name, flavout) {
		return new Apple(name, flavout)
	}
}

class OrangeFactory extends Factory {
	static create(name, flavout) {
		return new Orange(name, flavout)
	}
}

// 创建实例
let apple = AppleFactory.create('苹果', '甜的')
let orange = OrangeFactory.create('桔子', '酸甜')

• 实现解耦合，单独一个配置对象管理

//  1.配置对象
const settings = {
	apple: AppleFactory,
	orange: OrangeFactory
}
// 2.创建实例
let apple = settings['apple'].create('苹果', '甜的')
let orange = settings['orange'].create('桔子', '酸甜')
console.log(apple)
console.log(orange)

• 再进一步解耦和

1. 每个类保存为一个文件，然后动态导入
2. let apple = require(’./apple’).create()

抽象工厂模式

是指多个抽象对象时，使用一种工厂模式
可以向客户端提供一个接口，是客户端再不必指定产品的具体情况下，创建国歌产品族中的产品

• 示例

又过了很多年，人们的生活水平越来越高，随之要求也越来越高，有人喜欢花哨的，有人喜欢简约的，这个时候工厂发现单独处理某一个产品对于公司来说，内部损耗严重，需要优化，怎么办呢？ 成立一个部门(Factory), 然后负责华丽需求的产品线工作； 成立另外一个部门，负责简约风格的产品线工作.

// 1.创建类

// icon 类
class Icon {}

class AppleIcon {
	render () {
		console.log('绘制 apple icon')
	}
}
class WindowIcon {
	render () {
		console.log('绘制 Windows icon')
	}
}

// 按钮类
class Button {}

class AppleButton {
	render () {
		console.log('绘制 apple 按钮')
	}
}
class WindowButton {
	render () {
		console.log('绘制 Windows 按钮')
	}
}

// 2.创建工厂
class Factory {
	createButton () {
		// 创建按钮
	}
	createIcon () {
		// 创建图标
	}
}

// window 工厂
class WindowFactory extends Factory {
	createButton () {
		return new WindowButton();
	}
	createIcon () {
		return new WindowIcon()
	}
}

// apple 工厂
class AppleFactory extends Factory {
	createButton () {
		return new AppleButton();
	}
	createIcon () {
		return new AppleIcon()
	}
}

// 调用

let winFactory = new WindowFactory()
let appleFactory = new AppleFactory()
// 画一个按钮
winFactory.createButton().render()
appleFactory.createButton().render()
// 画一个icon
winFactory.createIcon().render()
appleFactory.createIcon().render()

总结

简单工厂: 一般就是一个函数返回产品的实例
工厂方法： 多了工厂方法， 想要创建产品，需要先创建工厂的实例额，再通过次工厂来创建实例
抽象工厂： 一个工厂可以创建多个产品