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。