1 简单工厂方法
2 工厂方法
3 抽象工厂方法
4 抽象工厂方法+简单工厂方法
简单工厂的工厂类使用静态方法，通过不同的入参实例化不同的对象并返回（这里利用反射机制进行实例化对象）
能够横向的添加产品，而不改动源码
产品接口
package simple; public interface Z { public void method1(); public void method2(); }
A1产品
package simple; public class A1 implements Z{ @Override public void method1() { System.out.println("A--method1"); } @Override public void method2() { System.out.println("A--method2"); } }
工厂类
public class Factory { public static Z getFunctionInstence(String type) throws Exception{ Z z =null; z = (Z) Class.forName(type).newInstance(); return z; } }
测试类
@Test public void testFactory() { try { Factory.getFunctionInstence("simple.A1").method2();
Factory.getFunctionInstence("simple.B1").method2(); } catch (Exception e) { e.printStackTrace(); } }
结果
A--method2
B--method2
工厂方法的工厂类实现了统一的控制接口，对于实例化不同的产品，只需要变换实现接口的工厂类即可
产品类及接口略
工厂接口
package standard; public interface IFunctionFactory { public Z getInstence(); }
工厂A
package standard; public class FactoryA implements IFunctionFactory{ @Override public Z getInstence() { return new A1(); } }
工厂B
package standard; public class FactoryB implements IFunctionFactory{ @Override public Z getInstence() { return new B1(); } }
测试类
@Test public void testFactory() { IFunctionFactory factory; factory= new FactoryA(); factory.getInstence().method1(); factory = new FactoryB(); //通过改变工厂接口的实现 factory.getInstence().method1(); }
结果
A--method1
B--method1
抽象工厂的管理模式与工厂模式类似，但由于工厂类中有多种方法，可以同时对不同组的产品进行管理
工厂接口
package abstractFactory; public interface IFunctionFactory { public X getInstence1(); public Y getInstence2(); }
工厂A
package abstractFactory; public class FactoryA implements IFunctionFactory{ @Override public X getInstence1() { return new A1(); } @Override public Y getInstence2() { return new A2(); } }
工厂B
package abstractFactory; public class FactoryB implements IFunctionFactory{ @Override public X getInstence1() { return new B1(); } public Y getInstence2() { return new B2(); } }
产品接口X,Y（略）
package abstractFactory; public interface X { public void method1(); public void method2(); }
继承产品接口X的产品A1,B1（略）
package abstractFactory; public class A1 implements X{ @Override public void method1() { System.out.println("A1--method1"); } @Override public void method2() { System.out.println("A1--method2"); } }
继承产品接口Y的产品A2，B2（略）
package abstractFactory; public class A2 implements Y{ @Override public void method1() { System.out.println("A2--method1"); } @Override public void method2() { System.out.println("A2--method2"); } }
测试类
package abstractFactory; import org.junit.Before; import org.junit.Test; public class FunctionFactoryTest { @Before public void setUp() throws Exception { } @Test public void testFactoryA() { IFunctionFactory factory ; factory = new FactoryA(); factory.getInstence1().method1(); factory.getInstence2().method1(); factory = new FactoryB(); factory.getInstence1().method2(); factory.getInstence2().method2(); } }
结果
A1--method1 A2--method1 B1--method2 B2--method2
抽象工厂方法用于对产品组进行管理，但是修改的时候需要修改的类较多。
通过简单工厂放方法对工厂类进行改造一定程度上可以实现开闭原则。
工厂类
package combination; public class Factory { String type=""; Factory(String type){ this.type=type; } public X getFactoryX() throws Exception{ return (X) Class.forName(type+"1").newInstance(); } public Y getFactoryY(String type) throws Exception{ return (Y) Class.forName(type+"2").newInstance(); } }
测试类
@Test public void test() throws Exception { Factory factory = new Factory("combination.B"); factory.getFactoryX().method2(); }
结果
B1--method2
原文：http://www.cnblogs.com/sunfan1988/p/3561500.html