Java设计模式之工厂模式

工厂方法模式

工厂方法模式分为三种：普通工厂模式、多个工厂方法模式和静态工厂方法模式。

1、普通工厂模式

普通工厂模式就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

package com.mode.create;

public interface MyInterface {
    public void print();
}

package com.mode.create;

public class MyClassOne implements MyInterface {

    @Override
    public void print() {
        System.out.println("MyClassOne");
    }

}

package com.mode.create;

public class MyClassTwo implements MyInterface {

    @Override
    public void print() {
        System.out.println("MyClassTwo");
    }

}

package com.mode.create;

public class MyFactory {

    public MyInterface produce(String type) {  
        if ("One".equals(type)) {  
            return new MyClassOne();  
        } else if ("Two".equals(type)) {  
            return new MyClassTwo();  
        } else {  
            System.out.println("没有要找的类型");  
            return null;  
        }  
    }

}

package com.mode.create;

public class FactoryTest {

    public static void main(String[] args){
        MyFactory factory = new MyFactory();  
        MyInterface myi = factory.produce("One");  
        myi.print();
    }

}

FactoryTest的运行结果我想应该很明显了。

再回头来理解这句话：普通工厂模式就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

3.1.2、多个工厂方法模式

多个工厂方法模式，是对普通工厂方法模式的改进，多个工厂方法模式就是提供多个工厂方法，分别创建对象。

直接看代码吧，我们修改MyFactory和FactoryTest如下：

package com.mode.create;

public class MyFactory {

    public MyInterface produceOne() {
        return new MyClassOne();
    }

    public MyInterface produceTwo() {
        return new MyClassTwo();
    }

}

package com.mode.create;

public class FactoryTest {

    public static void main(String[] args){
        MyFactory factory = new MyFactory();  
        MyInterface myi = factory.produceOne();
        myi.print();
    }

}

运行结果也是十分明显了。

再回头来理解这句话：多个工厂方法模式，是对普通工厂方法模式的改进，多个工厂方法模式就是提供多个工厂方法，分别创建对象。

3.1.3、静态工厂方法模式

静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

直接看代码吧，我们修改MyFactory和FactoryTest如下：

package com.mode.create;

public class MyFactory {

    public static MyInterface produceOne() {
        return new MyClassOne();
    }

    public static MyInterface produceTwo() {
        return new MyClassTwo();
    }

}

package com.mode.create;

public class FactoryTest {

    public static void main(String[] args){ 
        MyInterface myi = MyFactory.produceOne();
        myi.print();
    }

}

运行结果依旧很明显。

再回顾：静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

3.2、抽象工厂模式

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则。

为解决这个问题，我们来看看抽象工厂模式：创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

这样就符合闭包原则了。

下面来看看代码：

MyInterface、MyClassOne、MyClassTwo不变。

新增如下接口和类：

package com.mode.create;

public interface Provider {
    public MyInterface produce(); 
}

package com.mode.create;

public class MyFactoryOne implements Provider {

    @Override
    public MyInterface produce() {
        return new MyClassOne();
    }

}

package com.mode.create;

public class MyFactoryTwo implements Provider {

    @Override
    public MyInterface produce() {
        return new MyClassTwo();
    }

}

修改测试类FactoryTest如下：

package com.mode.create;

public class FactoryTest {

    public static void main(String[] args){ 
        Provider provider = new MyFactoryOne();
        MyInterface myi = provider.produce();
        myi.print();
    }

}

运行结果依旧显然。

再回顾：抽象工厂模式就是创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

参考：Java经典设计模式之五大创建型模式（附实例和详解）