工厂模式

一、工厂模式介绍

1、工厂模式简介

（1）实例化对象，用工厂方法代替new操作；

（2）工厂模式包括工厂方法模式和抽象工厂模式，抽象工厂模式是工厂方法模式的扩展；

2、工厂模式的意图

（1）定义一个接口来创建对象，但是让子类来决定哪些类需要被实例化；

（2）工厂方法把实例化的工作推迟到子类中去实现；

3、什么情况下适合工厂模式？

（1）有一组类似的对象需要创建；

（2）在编码时不能预见需要创建哪种类的实例；

（3）系统需要考虑扩展性，不应依赖于产品类实例如何被创建、组合和表达的细节；

4、工厂模式的动机

（1）在软件系统中经常面临着“对象”的创建工作，由于需求的变化，这个对象可能随之也会发生变化，但它却拥有比较稳定的接口。为此，我们要提供一种封装机制来隔离出这个易变对象的变化，从而保持系统中其他依赖该对象的对象不随着需求变化而变化；

（2）基于以上情况，代码设计应尽量松耦合，一个对象的依赖对象的变化与本身无关，具体产品与客户端剥离，责任分割；

5、工厂模式类图





二、工厂模式应用

1、引例

发型接口：

public interface HairInterface {
//画一个发型
public void drawHair();
}左偏分发型实现类：

public class LeftHair implements HairInterface{

@Override
public void drawHair() {
System.out.println("画一个左偏分发型");
}

}

右偏分发型实现类：

public class RightHair implements HairInterface{

@Override
public void drawHair() {
System.out.println("画一个右偏分发型");
}

}

测试类：

public class Test {

public static void main(String[] args) {
//画一个左偏分发型
HairInterface left = new LeftHair();
left.drawHair();
//画一个右偏分发型
HairInterface right = new RightHair();
right.drawHair();
}

}

2、以上是最普通的实现方式，但是非常麻烦，每画一个新发型，都要new一个新实例，耦合性高。运用工厂模式，我们增加一个发型的工厂管理类：
/**
* 发型的工厂管理类
*/
public class HairFactory {
//根据标识生产对象
public HairInterface getHair(String hair){
if("left".equals(hair)){
return new LeftHair();
}else if("right".equals(hair)){
return new RightHair();
}
return null;
}
}此时，测试类修改为：
public class Test {

public static void main(String[] args) {
//画一个左偏分发型
HairFactory factory = new HairFactory();
HairInterface hair = factory.getHair("left");
if(hair!=null){
hair.drawHair();
}
}

}3、上述的工厂管理类，还可以简化，通过类名去生产对象，修改如下：
/**
* 发型的工厂管理类
*/
public class HairFactory {

//根据类名生产对象
public HairInterface getHairByClassName(String className){
try {
HairInterface hair = (HairInterface) Class.forName(className).newInstance();
return hair;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
}此时，测试类修改为：
public class Test {

public static void main(String[] args) {
//画一个左偏分发型
HairFactory factory = new HairFactory();
HairInterface hair = factory.getHairByClassName("Factory.LeftHair");
if(hair!=null){
hair.drawHair();
}
}

}4、上述方法已经实现了工厂模式的应用，但是通过类名去生产对象，如果类名过长就容易写错，所以可以通过映射的方法去优化，此时需要添加一个属性文件type.properties和属性读取类PropertiesReader.java

type.properties代码如下：
left=Factory.LeftHair
right=Factory.RightHairPropertiesReader.java

public class PropertiesReader {

public Map<String, String> getProperties(){
Properties props = new Properties();
Map<String, String> map = new HashMap<String, String>();
try {
InputStream in = getClass().getResourceAsStream("type.properties");
props.load(in);
Enumeration en = props.propertyNames();
while (en.hasMoreElements()) {
String key = (String) en.nextElement();
String property = props.getProperty(key);
map.put(key, property);
System.out.println(key + "  " + property);
}
} catch (Exception e) {
e.printStackTrace();
}
return map;
}
}

工厂管理类修改为：
/**
* 发型的工厂管理类
*/
public class HairFactory {

// 根据类名的映射生产对象
public HairInterface getHairByClassKey(String key) {
try {
Map<String, String> map = new PropertiesReader().getProperties();
HairInterface hair = (HairInterface) Class.forName(map.get(key)).newInstance();
return hair;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
}测试类修改为：
public class Test {

public static void main(String[] args) {
//画一个左偏分发型
HairFactory factory = new HairFactory();
HairInterface hair = factory.getHairByClassKey("left");
if(hair!=null){
hair.drawHair();
}
}

}三、抽象工厂模式应用
应用场景：脸萌需要做不同的头像系列，比如男孩新年系列、男孩圣诞系列、女孩新年系列、女孩圣诞系列

/**
* 男孩系列
*/
public interface Boy {
public void drawBoy();
}

/**
* 女孩系列
*/
public interface Girl {
public void drawGirl();
}

/**
* 新年男孩系列
*/
public class HNBoy implements Boy{

@Override
public void drawBoy() {
System.out.println("新年男孩系列");
}

}

/**
* 圣诞男孩系列
*/
public class MCBoy implements Boy{

@Override
public void drawBoy() {
System.out.println("圣诞男孩系列");
}

}

/**
* 新年女孩系列
*/
public class HNGirl implements Girl{

@Override
public void drawGirl() {
System.out.println("新年女孩系列");
}

}

/**
* 圣诞女孩系列
*/
public class MCGirl implements Girl{

@Override
public void drawGirl() {
System.out.println("圣诞女孩系列");
}

}

/**
* 人物的实现接口
*/
public interface PersonFactory {
public Boy getBoy();
public Girl getGirl();
}

/**
* 新年系列加工厂
*/
public class HNFactory implements PersonFactory{

@Override
public Boy getBoy() {
return new HNBoy();
}

@Override
public Girl getGirl() {
return new HNGirl();
}

}

/**
* 圣诞系列加工厂
*/
public class MCFactory implements PersonFactory{

@Override
public Boy getBoy() {
return new MCBoy();
}

@Override
public Girl getGirl() {
return new MCGirl();
}

}

/**
* 测试类
*/
public class Test {

public static void main(String[] args) {
//生成一个圣诞系列的Boy
PersonFactory factory = new MCFactory();
Boy boy = factory.getBoy();
boy.drawBoy();
//		//生成一个圣诞系列的Girl
//		PersonFactory factory = new MCFactory();
//		Girl girl = factory.getGirl();
//		girl.drawGirl();
//		//生成一个新年系列的Boy
//		PersonFactory factory = new HNFactory();
//		Boy boy = factory.getBoy();
//		boy.drawBoy();
//		//生成一个新年系列的Girl
//		PersonFactory factory = new HNFactory();
//		Girl girl = factory.getGirl();
//		girl.drawGirl();
}

}

【运行结果】圣诞男孩系列

四、总结
1、工厂方法模式和抽象工厂模式的对比

（1）工厂模式是一种极端情况的抽象工厂模式，而抽象工厂模式可以看成是工厂模式的推广；

（2）工厂模式是用来创建一个产品的等级结构，而抽象工厂模式是用来创建多个产品的等级结构；

（3）工厂模式只有一个抽象产品类，而抽象工厂模式有多个抽象产品类；

2、工厂模式的优点

（1）系统可以在不修改具体工厂角色的情况下引进新的产品；

（2）客户端不必关心对象如何创建，明确了职责；

（3）更好的理解面向对象的原则，面向接口编程，而不是面向实现编程；

3、工厂模式适用于哪些场景

（1）一个系统应当不依赖于产品类实例被创建、组成、表示的细节，这对于所有形态的工厂模式都是重要的；

（2）这个系统的产品有至少一个的产品族；

（3）同属于同一个产品族的产品是设计成在一起使用的，这一约束必须得在系统的设计中体现出来；

（4）不同的产品以一系列的接口面貌出现，从而使系统不依赖于接口实现的细节；

五、工厂模式的一个常用举例