java设计模式--工厂模式

所谓工厂，就是要造产品，比如一个小型砖瓦厂，只有一个窑，既能造砖又能造瓦，这种叫简单工厂模式。规模稍大一点呢，我多个窑，有的窑专门造砖，有的窑专门造瓦，想造别的，比如瓷砖，我再用个专门的窑，这种成了工厂方法模式。但若是我开个汽车装配厂，我既要轮胎，又要发动机，又要车架等等组合型的，那就要抽象工程模式。所以，我们的工厂模式分为三种：简单工厂模式，工厂方法模式，抽象工厂模式。

首先，简单工厂：

所谓简单工厂，就是你告诉我，你想要什么产品，我能产这种产品，就给你生产。简单工厂模式又叫静态工厂模式，因为这个工厂产出的产品是开始就定死的，就能造那几种，多了没办法。而设计原则是新增产品不要修改原有的代码，就好比你一个砖瓦窑想要生产瓷器，即便不砸了重来，也得内部整改很多东西。

以下的代码示例是一个简单工厂类，该工厂类可以生产手机，且只能生产IPhone和Samsung两款手机。倘若你想生产小米手机，不好意思，目前生产不了，RuntimeException，你非要生产呢，继续加判断，就等于改掉了目前的工厂类。

代码：

public class SimplePhoneFactory {
    
	public static Cellphone getCellphone(String type){
		if("iPhone".equals(type)){
			return new IPhone();
		}else if("Samsung".equals(type)) {
			return new Samsung();
		}else {
			throw new RuntimeException("没有正确的手机类型创建");
		}
	}
}

工厂方法：

工厂方法是在简单工厂的基础上，可以扩展的工厂，从设计的思路上，更加清晰的去管理工厂的生产。将每个产品的工厂实现细分出来。这种模式实现上面的手机工厂的话，就是一个广义的工厂（接口），然后具体的实现每个产品的工厂实现。如果要新增产品的话，直接加一个该新产品的实现工厂即可，不用改动原有代码。

代码：

 /*
  工厂方法接口 
 */
public interface PhoneFactory {
   public Cellphone getPhone(); 
}

/* 
 * @Description: iPhone 工厂
 */
public class IPhoneFactory implements PhoneFactory{

	@Override
	public Cellphone getPhone() {
		// TODO Auto-generated method stub
		return new IPhone();
	}

}

/* 
 * @Description:samsung工厂
 */
public class SamsungPhoneFactory  implements PhoneFactory{

	@Override
	public Cellphone getPhone() {
		// TODO Auto-generated method stub
		return new Samsung();
	}

}

　以上代码可以看出，每个产品都需要自己的实现工厂，这时如果我们需要新增加新产品，比如小米手机，只需要新增一个MIPhoneFactory来实现PhoneFactory即可。

抽象工厂：

开头也说了，针对于组合型产品，我们使用抽象工厂。也就是说，这种工厂相对其他两种，复杂的多。而实际上，我们没办法拿抽象工厂和简单工厂已经工厂方法比较，因为他们不是用来解决同一类问题的，基本上没有什么可比性。抽象工厂用来针对的是产品族，而简单工厂和工厂方法都是针对单一产品的，如果真让抽象工厂去对单个产品进行管理，反倒无能为力。

这里我们还以手机为例，我们要生产手机，需要很多配件，比如CPU，比如相机，比如内存等等，我们暂且只认为决定一款手机好坏只有这三个组件。使用抽象工厂来实现。

首先，我们定义CPU的接口，已经能生产的一些列CPU，这里以GoodCPU和BadCPU为例：

public interface CPU {
   void run();
   void start();
}
//高端CPU
class GoodCUP implements CPU{

	@Override
	public void run() {
		System.out.println("高端CPU运转方法。。。");
		
	}

	@Override
	public void start() {
		System.out.println("高端CPU开始方法。。。");
		
	}
	
}

//低端CPU
class  BadCPU implements CPU{

	@Override
	public void run() {
		System.out.println("低端CPU运转方法。。。");
		
	}

	@Override
	public void start() {
		System.out.println("低端CPU开始方法。。。");
		
	}
	
}

　　然后是相机接口，以及相关的相机生产类型，其中的方法是随便写的。

public interface Camera {
   public void take();
 
}

class GoodCamera implements Camera{

	@Override
	public void take() {
		System.out.println("高端相机拍照。。。");
		
	}
	
}

class BadCamera implements Camera{

	@Override
	public void take() {
		System.out.println("低端相机拍照。。。");
		
	}
	
}

　　最后一个内存的接口已经一系列类型：

public interface Memory {
    
	void work();
}

class GoodMemory implements Memory{

	@Override
	public void work() {
		System.out.println("高性能内存工作");
		
	}
	
}
class BadMemory implements Memory{

	@Override
	public void work() {
		System.out.println("低性能内存工作");
		
	}
	
}

我们前面说了，抽象工厂就是利用一些列组件组合产品的工厂，上面我们写的CPU，相机，内存都是我们要组件手机的组件。现在，我们开始写我们的抽象工厂。当然为了方便，肯定要有工厂接口：

public interface AbPhoneFactory {
   CPU getCPU();
   Camera getCamera();
   Memory getMemory();
}

　　然后，我们根据自己的需要，随机组合几种组件，即可得到我们的产品，当然这是一组（产品）组合出来的最终产品。

比如我们用好的CPU，好的内存，好的相机组合成一个好的手机：

public class GoodsPhoneFactory  implements AbPhoneFactory{

	@Override
	public CPU getCPU() {
		// TODO Auto-generated method stub
		return new GoodCUP();
	}

	@Override
	public Camera getCamera() {
		// TODO Auto-generated method stub
		return new GoodCamera();
	}

	@Override
	public Memory getMemory() {
		// TODO Auto-generated method stub
		return new GoodMemory();
	}

	

}

　　也可以用差的CPU，差的内存，差的相机组合成比较差劲的手机：

public class BadPhoneFactory implements AbPhoneFactory{

	@Override
	public CPU getCPU() {
		// TODO Auto-generated method stub
		return new BadCPU();
	}

	@Override
	public Camera getCamera() {
		// TODO Auto-generated method stub
		return new BadCamera();
	}

	@Override
	public Memory getMemory() {
		// TODO Auto-generated method stub
		return new BadMemory();
	}

}

　当然你也可以乱组合成中等的，这都是随你便了，只要加一个工厂实现即可。

最后，我们来总结一下吧：

对于单一产品，简单工厂更简单，但是新增产品时却很乏力，或者说不符合设计原则，而工厂方法是不修改原有类的前提下，新增工厂类实现，更符合设计原则。是不是我们在单一产品的时候就该选择工厂方法了呢？下面给出这么一个对比：

-- 结构复杂度简单工厂更加简单简单工厂优于工厂方法

-- 代码复杂度工厂方法复杂度较高简单工厂优于工厂方法
-- 客户端编程难度工厂方法客户端需要了解更多的实现工厂简单工厂优于工厂方法
-- 管理难度工厂方法由于实现工厂类较多，管理更难简单工厂优于工厂方法

结合以上四点，我们说简单工厂比工厂方法更加易用。这也就是开发时候简单工厂比工厂方法使用的更多的原因。

对于产品族，如果使用工厂模式，唯一的选择--抽象工厂。

OK，更多详细代码和本次测试代码请参考github：https://github.com/LiuJishuai/designPatterns。