1.简单工厂
可以理解为：一个工厂根据不同的需求生产不同的产品，但是一次只能生产一种中的一个。
组成：一个抽象产品，n个继承抽象产品的具体子类，及一个具体的工厂函数。
| 组成 | 描述 |
|---|---|
| 抽象产品 | 抽象描述产品，需被子类继承 |
| 具体产品类 | 继承了抽象产品接口，并描述了具体产品的细节 |
| 具体工厂函数 | 封装了根据参数判断来实例化哪种具体产品类的逻辑 |
代码实现：
/**
*
* 简单工厂模式：一个工厂函数，根据传参不同，实现不同具体产品类的实例化
*
*/
//抽象产品类
abstract class Food{
abstract name:string;
}
//具体产品类
class Chicken extends Food {
public name:string = '鸡肉';
}
class Duck extends Food {
public name:string = '鸭肉';
}
//工厂函数
function simpleFactory(type:string){
switch(type){
case 'chicken':
return new Chicken;
case 'duck':
return new Duck;
default:
return null;
}
}
console.log(simpleFactory('chicken'))
console.log(simpleFactory('duck'))
打印结果：
Chicken { name: '鸡肉' }
Duck { name: '鸭肉' }
优点：只需要关心想要的实例对应的传参即可，无需关心内部实现。
缺点：当产品种类不断增加的时候的时候，需要不断给工厂函数增加判定代码，违反了开闭原则。
2.工厂方法
可以理解为：不同的产品有对应的不同的工厂生产，即每一个工厂只生产一种产品
组成：一个抽象产品，n个实现抽象产品的具体产品子类，一个抽象工厂，及对应n个具体产品的具体工厂。
| 组成 | 描述 |
|---|---|
| 抽象产品 | 抽象描述产品，需被子类实现 |
| 具体产品类 | 实现了抽象产品接口，并描述了具体产品的细节 |
| 抽象工厂 | 抽象描述工厂，需被子类实现 |
| 具体工厂 | 实现了抽象产品接口，并描述了具体工厂的细节 |
代码实现：
/**
*
* 工厂方法模式：通过实现抽象工厂类来实现具体产品的具体工厂，一个工厂只生产一种具体的产品。
*
*/
//抽象产品类
abstract class Food{
abstract name:string;
}
//具体产品类
class Chicken extends Food {
public name:string = '鸡肉';
}
class Duck extends Food {
public name:string = '鸭肉';
}
//抽象工厂类
abstract class Factory{
abstract name:string;
}
//具体工厂类
class ChickenFactory extends Factory {
public name:string = '鸡肉工厂'
public produceChicken():Chicken{
return new Chicken;
}
}
class DuckFactory extends Factory {
public name:string = '鸭肉工厂'
public produceDuck():Duck{
return new Duck;
}
}
let chickenFactory = new ChickenFactory;
console.log(chickenFactory,chickenFactory.produceChicken())
let duckFactory = new DuckFactory;
console.log(duckFactory,duckFactory.produceDuck())
打印结果：
ChickenFactory { name: '鸡肉工厂' } Chicken { name: '鸡肉' }
DuckFactory { name: '鸭肉工厂' } Duck { name: '鸭肉' }
优点：符合开闭原则，增加新产品时，无需改动旧代码。
缺点：每一种具体产品都对应一个具体工厂，类的个数会随着产品数量增加而增加，增加了复杂度。
3.抽象工厂
可以理解为：一个工厂具有生产多种类的产品的能力。比如一个工厂不止可以生产手机，可以生产耳机，平板电脑，智能手表等
组成：n个抽象产品，m个继承抽象产品的具体子类，一个抽象工厂，x个具体子类的具体工厂。
| 组成 | 描述 |
|---|---|
| 抽象产品 | 抽象描述产品，需被子类继承 |
| 具体产品类 | 继承了抽象产品接口，并描述了具体产品的细节 |
| 抽象工厂 | 抽象描述工厂，需被子类继承 |
| 具体工厂 | 继承了抽象产品接口，并描述了具体工厂的细节 |
代码实现：
/**
*
* 抽象工厂模式：通过抽象工厂类实现的具体工厂类，不仅仅能生产一种产品，而是能生产一个族群的产品，这个抽象工厂类也叫“超级工厂"
*
*
*/
//抽象产品类
abstract class Pone {
abstract name: string;
}
abstract class IWacth {
abstract name: string;
}
//具体产品类
class MiPone extends Pone {
public name: string = '小米手机'
}
class IPone extends Pone {
public name: string = '苹果手机'
}
class MiWatch extends IWacth {
public name: string = '小米智能手表'
}
class AppleWatch extends IWacth {
public name: string = '苹果智能手表'
}
//抽象工厂函数
abstract class AbstractFactory {
abstract name: string;
abstract producePone(): Pone;
abstract produceIWacth(): IWacth;
}
class MiFactory extends AbstractFactory {
public name: string = '小米工厂';
public producePone(): Pone {
return new MiPone;
}
public produceIWacth(): IWacth {
return new MiWatch;
}
}
let mifactory = new MiFactory;
console.log(mifactory,mifactory.producePone(),mifactory.produceIWacth())
打印结果：
MiFactory { name: '小米工厂' } MiPone { name: '小米手机' } MiWatch { name: '小米智能手表' }
优点：一个工厂可以生产不止一种产品，减少了具体工厂子类的数量。
缺点：违背了开闭原则，如果要增加产品时，需要修改原先代码。
===========================================================
