工厂方法模式、抽象工厂模式、单例模式

1、工厂方法模式

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

1.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的运行结果我想应该很明显了。

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

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();    } }

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

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

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();    } }

运行结果依旧很明显。

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

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();    } }

运行结果依旧显然。

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

3、单例模式

单例模式，不需要过多的解释。

直接看代码吧：

package test; public class MyObject {     private static MyObject myObject;     private MyObject() {    }     public static MyObject getInstance() {        if (myObject != null) {        } else {            myObject = new MyObject();        }        return myObject;    } }

但是这样会引发多线程问题，详细解说可以看《Java多线程编程核心技术》书中的第六章。