工厂模式

    工厂模式，我觉得这个比策略难懂。在网上看了好多帖子，先说简单工厂模式，许多人都这样说：工厂就是制造东西的吗，说白了就是制造对象，制造什么对象呢，这是你说了算的，所以你要给工厂原材料，它就能制造出相应的对象了。
2点使用原因：1.在编码时不能预见需要创建哪种类的实例。
             2.系统不应依赖于产品类实例如何被创建、组合和表达的细节
看代码：

//想生产的抽象的东西
interface Service {
    void method1();

    void method2();
}
//想生产的具体的东西implementation1 
class implementation1 implements Service {

    public void method1() {
        System.out.println("implementation1的 method1()方法");
    }

    public void method2() {
        System.out.println("implementation1的 method2()方法");
    }
}
//想生产的具体的东西implementation2 
class implementation2 implements Service {

    public void method1() {
        System.out.println("implementation2的 method1()方法");
    }

    public void method2() {
        System.out.println("implementation2的 method2()方法");
    }
}

//工厂方法，制造你想要的东西，原材料就是你想制造什么对象。
class ServiceFactory {
    public Service getService(String serviceName) {
        if (serviceName.equals("implementation1"))
            return new implementation1();
        else if (serviceName.equals("implementation2"))
            return new implementation2();

        return null;
    }
}
//使用
public class Apply {
    public static void customer(String serviceName){
        ServiceFactory sf = new ServiceFactory();
        Service s = sf.getService(serviceName);
        s.method1();
        s.method2();
    }

    public static void main(String[] args) {
        customer("implementation1");
        customer("implementation2");
    }
}

    看以上代码应该很容易理解，工厂按照我传递进去的参数，给我造出相应的对象，而我的代码要是想用这些对象，只要传递进去方法的名字，就能得到相应的对象了.
而且最早提及的2点都适用了，我不能预计还有没有新的服务（新产品）了，要是有了我只要实现抽象接口，并且修改工厂方法就可以在客户端适用了。
我的对象的创建，完全不依赖于对象，而是依赖于工厂提供的方法，就算对象千变万化，我的上层代码都不用改变，因为我有稳定的供货源----工厂方法。我只是从工厂中得到了对象，具体怎么得的，我并不关心。
由此也出现了一个问题，每次我有新东西的时候，不但要遵守规范（实现接口），连工厂方法的逻辑也要改变，为了使得更符合开闭原则。需要改进

    抽象工厂方法

interface Service {
    void method1();

    void method2();
}

class implementation1 implements Service {

    public void method1() {
        System.out.println("implementation1的 method1()方法");
    }

    public void method2() {
        System.out.println("implementation1的 method2()方法");
    }
}

class implementation2 implements Service {

    public void method1() {
        System.out.println("implementation2的 method1()方法");
    }

    public void method2() {
        System.out.println("implementation2的 method2()方法");
    }
}
//工厂的一般表现形式（抽象工厂）
interface ServiceFactory {
    Service getService();
}
//制造implementation1的实际工厂
class implementation1Factory implements ServiceFactory {

    public Service getService() {
        return new implementation1();
    }
}
//制造implementation2的实际工厂
class implementation2Factory implements ServiceFactory {

    public Service getService() {
        return new implementation2();
    }
}

public class Apply {
    public static void customer(ServiceFactory sf) {
        Service s = sf.getService();
        s.method1();
        s.method2();
    }

    public static void main(String[] args) {
        customer(new implementation1Factory());
        customer(new implementation2Factory());
    }
}

这样就好了很多，更具有通用性，尤其是

    public static void customer(ServiceFactory sf) {
        Service s = sf.getService();
        s.method1();
        s.method2();
    }

这段代码，完全是虚的，都是接口的引用在其中，全部都等着你自己实例化的对象往里多态呢。
现在再扩展就好了，原来的代码都不用动了，只增加2个符合接口规范的类就行了，一个是你要的服务的，一个是产生这个服务的接口的。

总结：当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了"开放－封闭"原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。

-------------------------------------------------
开源才是王道
代码改编自：thinking in java
我的MSN：[e-mail]与我交流。