1、概念:
实例化对象,用工厂方法代替new操作。包括工厂方法模式和抽象工厂模式,实际上抽象工厂模式是工厂方式模式的扩展。
工厂模式通过定义一个接口来创建对象,由子类决定具体的实例化类;将实例化工作推迟到子类中去实现。
2、适用场景:
2.1>有一组相似的对象需要创建
2.2>编码过程中不能预见需要创建哪种类的实例
2.3>为系统扩展性考虑,不依赖于类实例如何被创建、组合和表达的细节
如 JDBC、SpringBean等均采用该实现模式
3、模式实现:
工厂方法模式是用来创建一个产品的等级结构,只有一个抽象产品类,类图:
代码实现:
public interface IFruitFactory {
public void create();
}
public class Apple implements IFruitFactory{
public void create(){
System.out.println("-------------Apple------------");
}
}
public class Orange implements IFruitFactory{
public void create(){
System.out.println("----------Orange-----------");
}
}
//实现模式之后,扩展新增测试类
public class Pineapple implements IFruitFactory {
@Override
public void create() {
System.out.println("------------Pineapple--------------");
}
}
public class FruitTest {
public static void main(String[] args) throws Exception {
// Apple apple = null; //new Apple();
// apple = (Apple) Class.forName("com.jason.factory.cmm.Apple").newInstance();
// apple.create();
IFruitFactory factory = (IFruitFactory)Class.forName(
PropertiesUtil.getInstance().getValue("pineapple")).newInstance();
factory.create();
}
}
//配置文件读取工具类
public class PropertiesUtil {
private static PropertiesUtil propertiesUtil = null;
private PropertiesUtil(){
}
public static PropertiesUtil getInstance(){
return propertiesUtil == null ? new PropertiesUtil() : propertiesUtil;
}
public String getValue(String key) throws IOException{
Properties props = new Properties();
props.load(this.getClass().getClassLoader().getResourceAsStream("type.properties"));
return props.getProperty(key);
}
public static void main(String[] args) {
try {
System.out.println(PropertiesUtil.getInstance().getValue("orange"));
} catch (IOException e) {
e.printStackTrace();
}
}
}
//type.properties内容
apple=com.jason.factory.cmm.Apple
orange=com.jason.factory.cmm.Orange
pineapple=com.jason.factory.cmm.Pineapple
4、而抽象工厂模式用来创建多个产品的等级结构,拥有多个抽象产品类,其类图:
代码实现:
public interface DimFactory {
public IFruit getFruit();
public ICake getCake();
}
public class AppleFactory implements DimFactory {
@Override
public IFruit getFruit() {
return new Apple();
}
@Override
public ICake getCake() {
return new AppleCake();
}
}
public class OrangeFactory implements DimFactory {
@Override
public IFruit getFruit() {
return new Orange();
}
@Override
public ICake getCake() {
return new OrangeCake();
}
}
public interface IFruit {
public void createFruit();
}
public class Apple implements IFruit {
@Override
public void createFruit() {
System.out.println("----------苹果-----------");
}
}
public class Orange implements IFruit {
@Override
public void createFruit() {
System.out.println("----------橙子-----------");
}
}
public interface ICake {
public void createCake();
}
public class AppleFactory implements DimFactory {
@Override
public IFruit getFruit() {
return new Apple();
}
@Override
public ICake getCake() {
return new AppleCake();
}
}
public class OrangeCake implements ICake {
@Override
public void createCake() {
System.out.println("----------橙子蛋糕-----------");
}
}
//测试类
public class Test {
public static void main(String[] args) {
DimFactory factory = new AppleFactory();
IFruit fruit = factory.getFruit();
fruit.createFruit();
ICake cake = factory.getCake();
cake.createCake();
}
}
5、抽象工厂模式的优缺点(转)
优点:就是可以在类的内部对产品族进行约束。所谓的产品族,一般或多或少的都存在一定的关联,抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述,而不必专门引入一个新的类来进行管理。
缺点:产品族的扩展将是一件十分费力的事情,假如产品族中需要增加一个新的产品,则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时,对产品等级结构的划分是非常重要的。
总之,使用工厂模式时,只需要关心解耦的目地是否达到。