java设计模式学习-工厂模式

工厂模式概念：

实例化对象，用工厂方法代替new操作。
工厂模式包括工厂方法模式和抽象工厂模式。
抽象工厂模式是工厂方法模式的扩展。

工厂模式动机：

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

工厂模式适合情况：

有一组类似的对象需要创建。
在编码时不能预见需要创建哪种类的实例。
系统需要考虑扩展性，不应依赖于产品类实例如何被创建、组合和表达的细节。

代码实例：
比如我们想创建不同的发型实例，发型种类有很多，而他们都有类似的属性——发型，我们将发型抽象为一个接口：

public interface HairInterface {

    /**
     * 画图
     */
    public void draw();
}

对应发型实例有：

public class InHair implements HairInterface {

    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println("-----------------中分发型-------------------");

    }
}

但是我们不能事先预知想要的发型，发型可能变动，所以此时可以想到用一个工厂管理发型的生产：

/**
 * 发型工厂
 * @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;
    }
}

实现过程中根据需求，用工厂“生产”，而不用一个一个实例化：

//      HairInterface left = new LeftHair();
//      left.draw();

        HairFactory factory = new HairFactory();
//      HairInterface right =  factory.getHair("right");
//      right.draw();

//      HairInterface left = factory.getHairByClass("com.sunny.project.LeftHair");
//      left.draw();

//      HairInterface hair = factory.getHairByClassKey("in");
//      hair.draw();

而抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。

即：
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。 　　
一个抽象工厂类，可以派生出多个具体工厂类。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
　　
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

引用：工厂模式概述