工厂方法模式,定义了一个创建对象的接口,由子类决定要实例化的类是哪一个,工厂方法让类的实例化推迟到子类。
简单工厂模式的区别是工厂方法是具体的,不需要推迟到子类。
抽象工厂方法模式,提供一个接口,用于创建相关依赖对象的家族,而不需要明确指定具体类。
下面以剪头发为例来实现工厂方法:
发型工厂
package com.sunny.project;
import java.util.Map;
/**
* 发型工厂
* @author Administrator
*
*/
public class HairFactory {
/**
* 根据类型来创建对象
* @param key
* @return
*/
public HairInterface getHair(String key){
if("left".equals(key)){
return new LeftHair();
}else if("right".equals(key)){
return new RightHair();
}
return null;
}
/**
* 根据类的名称来生产对象
* @param className
* @return
*/
public HairInterface getHairByClass(String className){
try {
HairInterface hair = (HairInterface) Class.forName(className).newInstance();
return hair;
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 根据类的名称来生产对象
* @param className
* @return
*/
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) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
}
发型接口类
package com.sunny.project;
/**
* 发型接口
* @author Administrator
*
*/
public interface HairInterface {
/**
* 画图
*/
public void draw();
}
中分发型实现类
package com.sunny.project;
/**
* 中分发型
* @author Administrator
*
*/
public class InHair implements HairInterface {
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println("-----------------中分发型-------------------");
}
}
配置读取工具类(配置内容为in=com.sunny.project.InHair)
package com.sunny.project;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
* properties文件的读取工具
* @author Administrator
*
*/
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;
}
}
测试类
package com.sunny.project;
public class SunnyTest {
public static void main(String[] args){
HairFactory factory = new HairFactory();
HairInterface hair = factory.getHairByClassKey("in");
hair.draw();
}
}
工厂方法模式
优点:
1. 良好的封装性,代码结构清晰。一个对象创建是有条件约束的,如一个调用者需要 一个具体的产品对象,只要知道这个产品的类名(或约束字符串)就可以了,不用知道创建对象的艰辛过程,减少模块间的耦合。
2. 工厂方法模式的扩展性非常优秀。在增加产品类的情况下,只要适当地修改具体的 工厂类或扩展一个工厂类,就可以完成“拥抱变化”。
3. 屏蔽产品类。这一特点非常重要,产品类的实现如何变化,调用者都不需要关心, 它只需要关心产品的接口,只要接口保持不变,系统中的上层模块就不要发生变化,因为产品类的实例化工作是由工厂类负责,一个产品对象具体由哪一个产品生成是由工厂类决定的。在数据库开发中,大家应该能够深刻体会到工厂方法模式的好处:如果使用JDBC连接数据库,数据库从MySql切换到Oracle,需要改动地方就是切换一下驱动名称(前提条件是SQL语句是标准语句),其他的都不需要修改,这是工厂方法模式灵活性的一个直接案例。
4. 工厂方法模式是典型的解耦框架。高层模块值需要知道产品的抽象类,其他的实现 类都不用关心,符合迪米特原则,我不需要的就不要去交流;也符合依赖倒转原则,只依赖产品类的抽象;当然也符合里氏替换原则,使用产品子类替换产品父类,没问题!
用途: 第一种情况是对于某个产品,调用者清楚地知道应该使用哪个具体工厂服务,实例化该具体工厂, 生产出具体的产品来。Java Collection中的iterator() 方法即属于这种情况。 第二种情况,只是需要一种产品,而不想知道也不需要知道究竟是哪个工厂为生产的,即最终选用哪个具体工厂的决定权在生产者一方,它们根据当前系统的情况来实例化一个具体的工厂返回给使用者,而这个决策过程这对于使用者来说是透明的。
抽象工厂模式
优点:
1. 抽象工厂模式隔离了具体类的生产,使得客户并不需要知道什么被创建
2. 当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一 个产品族中的对象
3. 增加新的具体工厂和产品族很方便,无须修改已有系统,符合“开闭原则”
缺点: 增加新的产品等级结构很复杂,需要修改抽象工厂和所有的具体工厂类,对“开闭原则”的支持呈现倾斜性。
用途:
1、一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有类型的工厂模式都是重要的。
2、系统中有多于一个的产品族,而每次只使用其中某一产品族。
3、属于同一个产品族的产品将在一起使用,这一约束必须在系统的设计中体现出来。
4、系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。