设计模式之工厂模式

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、抽象工厂模式的优缺点(转)
优点：就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。
缺点：产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

总之，使用工厂模式时，只需要关心解耦的目地是否达到。