23种设计模式之工厂模式

23种设计模式之工厂模式

工厂模式一般被分为以下几种：

简单工厂模式

工厂方法模式

抽象工厂模式

1.简单工厂模式

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

简单工厂分为三个组成部分：

• 产品抽象类，定义功能
• 具体产品类，功能实现
• 静态工厂类，生产产品

1.1 产品抽象类

产品抽象类是用来定义产品的功能，一般以接口或者抽象类的形式展现

//接口
public interface IRun {
	void run();
}

//抽象类
public abstract class AbsRun {
	public abstract void run();
}

1.2 具体产品类

产品类就是产品抽象类的实现，具体功能对象的具体实现。（这里可以进行更加具体的功能分类）

//两条腿的产品实现
public class TwoRun implement IRun {
	@Override
	public void run() {
		System.out.println("我两条腿跑。");
	}
}

//四条腿产品实现
public class FourRun implement IRun {
	@Override
	public void run() {
		System.out.println("我四条腿跑。");
	}
}

//四条腿以上产品实现
public class MoreRun implement IRun {
	@Override
	public void run() {
		System.out.println("我有更多腿跑。");
	}
}

1.3 静态工厂类

静态工厂类是用来生产产品的实例的，通过某种定义好的产品类型来创建对应的产品实例。

//工厂类
public class RunFactory{
	public static IRun create(String type){
		IRun iRun;
		switch(type){
			case "2":
				iRun = new TwoRun();
				break;
			case "4":
				iRun = new FourRun();
				break;
			default:
				iRun = new MoreRun();
				break;
	}
}

public static void main(String[] args){
	IRun two = RunFactory.create("2");
	IRun four = RunFactory.create("4");
	IRun more = RunFactory.create("6");
	two.run();
	fout.run();
	more.run();
}

打印结果
-------------------
我两条腿跑。
我四条腿跑。
我更多条腿跑。

总结

这里就是对“run”这个功能的多种实现。在面对这种需求的时候，我们是先写具体的功能类到最后在进行相似功能抽象，向上提取才得到工厂模型的。其实这种思维方式在编程上应该反过来，在写功能之前应该先对功能进行定义，在完善具体产品的实现。这样可以大大减少我们代码Review的时间，还增强了代码拓展性，大大提升了我们开发效率。所以我们利用好设计模式才是程序员进阶必要条件。

并且在开发过程中我们还可以进行第二层抽象，那就是抽象类，在定义好功能接口之后，我们可以在中间添加抽象类，将公共部分进行合并，产品类只需要进行个性功能的实现，这样产品实现类只体现出不同的功能，也可以简化代码增强可读性。例如：

public abstract class AbsTwoRun implement IRun {
	
	@Override
	public void run() {
		packing();
	}
	
	//定义包装方法
	public abstract void packing();
	
}

//具体实现类
public class ManRun extends AbsTwoRun {
	@Override
	public void packing(){
		System.out.println("我穿着鞋用两只脚跑。");
	}
}

public class Checken extends AbsTwoRun {
	@Override
	public void packing() {
		System.out.println("我不穿鞋用两只脚跑。");
	}
}

这里就是对功能的拆分，那么工厂方法模型又是怎样呢~

2 工厂方法模型

工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭 原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。

我们在介绍简单工厂模型的时候对它进行了拓展。工厂方法模型的具体操作就是将工厂进行了具体功能的分配。

就上面的例子我们可以将每个类型的产品对应一个工厂实现。

public interface IFactory {
	IRun create();
}

//Two Run
public class TwoFactory implement IFactory {
	@Override
	public IRun create(){
		return TwoRun();
	}
}
//Four Run
public class FourFactory implement IFactory {
	@Override
	public IRun create(){
		return FourRun();
	}
}
//More Run
public class MoreFactory implement IFactory {
	@Override
	public IRun create(){
		return MoreRun();
	}
}

这样我们就可以直接通过获取产品对应的工厂来获取产品的实例。虽然多了一层封装，但是更便于封装。

3 抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。

• 它由四部分组成：
  1. 抽象工厂：用来定义多个产品的抽象。
  2. 具体工厂：对应具体产品创建产品实例。
  3. 抽象产品：用来定义产品功能。
  4. 具体产品：产品功能实现，通过具体工厂获得。

抽象工厂

public interface IFactory {
	//定义Run产品工厂方法
	void createRun();
	
	//定义包装产品工厂方法
	void createPacking();
}

抽象产品

public interfact IRun {
	void run();
}

public interface IPacking() {
	void packing();
}

具体产品

跑的具体产品

//两条腿的产品实现
public class TwoRun implement IRun {
	@Override
	public void run() {
		System.out.println("我两条腿跑。");
	}
}

//四条腿产品实现
public class FourRun implement IRun {
	@Override
	public void run() {
		System.out.println("我四条腿跑。");
	}
}

//四条腿以上产品实现
public class MoreRun implement IRun {
	@Override
	public void run() {
		System.out.println("我有更多腿跑。");
	}
}
----------------------------------------

包装的具体实现

//光脚包装产品
public class NoPacking implement IPacking {
	@Override
	public void packing() {
		System.out.println("我光着脚。");	
	}
}

//穿鞋包装产品
public class Shoes implement IPacking {
	@Override
	public void packing() {
		System.out.println("我穿东西。");
	}
}

具体工厂

//野人 产品---两条腿，光着脚
public class Savage implement IFactory {
	@Override
	public IRun createRun() {
		return new TwoRun();
	}
	
	@Override
	public IPacking createPacking() {
		return new NoPacking();
	}
}
打印结果
----------
我两条腿跑。
我光着脚。


//千里马 产品---四条腿，有马掌
public class Maxima implement IFactory {
	@Override
	public IRun createRun(){
		return new FourRun();
	}
	
	@Override
	public IPacking createPacking() {
		return new Shoes();
	}
}

打印结果
---------------
我四条腿跑。
我穿东西。

在这里具体工厂就是对抽象产品的多种组合，用来处理复杂的情景。也是将多种简单工厂模型组合在一起实现复杂功能。

工厂模式总结

工厂模式就是产品需要通过工厂生产。这也就决定了它的特点-产品与工厂耦合。因为工厂直接生成了产品的实例，拓展性很差，每次拓展新产品，都需要修改工厂或者添加新的工厂。

所以这里就想到了策略模式，它们有很多相似之处，但策略模式却是解耦和的。