Java设计模式笔记（3）抽象工厂模式

抽象工厂模式：为创建一组相关的或者相互依赖的对象提供一个接口，而且无需指定他们的具体类。

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

package com.juno.AbstractFactoryPattern;// 抽象产品类public abstract class AbstractProductA {// 每个产品共有的方法public void shareMethod() {}// 每个产品相同方法，不同实现public abstract void doSomething();}

package com.juno.AbstractFactoryPattern;// 抽象产品类public abstract class AbstractProductB {// 每个产品共有的方法public void shareMethod() {}// 每个产品相同方法，不同实现public abstract void doSomething();}

package com.juno.AbstractFactoryPattern;// 产品A1的实现类public class ProductA1 extends AbstractProductA {@Overridepublic void doSomething() {System.out.println("产品A1的实现方法");}}

package com.juno.AbstractFactoryPattern;// 产品A1的实现类public class ProductA2 extends AbstractProductA {@Overridepublic void doSomething() {System.out.println("产品A2的实现方法");}}

package com.juno.AbstractFactoryPattern;// 产品A1的实现类public class ProductB1 extends AbstractProductB {@Overridepublic void doSomething() {System.out.println("产品B1的实现方法");}}

package com.juno.AbstractFactoryPattern;// 产品A1的实现类public class ProductB2 extends AbstractProductB {@Overridepublic void doSomething() {System.out.println("产品B2的实现方法");}}

package com.juno.AbstractFactoryPattern;public abstract class AbstractCreatorA {// 创建A产品家族public abstract AbstractProductA createProductA();// 创建B产品家族public abstract AbstractProductB createProductB();}

package com.juno.AbstractFactoryPattern;public class CreatorA1 extends AbstractCreatorA{@Overridepublic AbstractProductA createProductA() {// 只生产产品等级为1的A产品return new ProductA1();}@Overridepublic AbstractProductB createProductB() {// 只生产产品等级为1的B产品return new ProductB1();}}

package com.juno.AbstractFactoryPattern;public class CreatorA2 extends AbstractCreatorA{@Overridepublic AbstractProductA createProductA() {// 只生产产品等级为2的A产品return new ProductA2();}@Overridepublic AbstractProductB createProductB() {// 只生产产品等级为2的B产品return new ProductB2();}}

package com.juno.AbstractFactoryPattern;//抽象工厂类，负责定义产品对象的产生public abstract class AbstractCreatorB {/** * 创建一个产品A对象，其输入参数可以自行设置 * 通常为String、Enum、Class等，当然也可以为空 */public abstract <T extends AbstractProductA> T createProductA(Class<T> c);/** * 创建一个产品B对象，其输入参数可以自行设置 * 通常为String、Enum、Class等，当然也可以为空 */public abstract <T extends AbstractProductB> T createProductB(Class<T> c);}

package com.juno.AbstractFactoryPattern;public class CreatorB extends AbstractCreatorB {@SuppressWarnings("unchecked")@Overridepublic <T extends AbstractProductA> T createProductA(Class<T> c) {AbstractProductA product = null;try {product = (AbstractProductA) Class.forName(c.getName()).newInstance();} catch (Exception e) {// TODO 异常处理}return (T)product;}@SuppressWarnings("unchecked")@Overridepublic <T extends AbstractProductB> T createProductB(Class<T> c) {AbstractProductB product = null;try {product = (AbstractProductB) Class.forName(c.getName()).newInstance();} catch (Exception e) {// TODO 异常处理}return (T)product;}}

package com.juno.AbstractFactoryPattern;public class Client {public static void main(String[] args) {// 定义出两个工厂AbstractCreatorA creatorA1 = new CreatorA1();AbstractCreatorA creatorA2 = new CreatorA2();// 产生A1对象AbstractProductA a1 = creatorA1.createProductA();// 产生A2对象AbstractProductA a2 = creatorA2.createProductA();// 产生A1对象AbstractProductB b1 = creatorA1.createProductB();// 产生A2对象AbstractProductB b2 = creatorA2.createProductB();a1.doSomething();a2.doSomething();b1.doSomething();b2.doSomething();System.out.println("---------------------------");AbstractCreatorB creatorB = new CreatorB();AbstractProductA a_1 = creatorB.createProductA(ProductA1.class);AbstractProductA a_2 = creatorB.createProductA(ProductA2.class);ProductB1 b_1 = creatorB.createProductB(ProductB1.class);ProductB2 b_2 = creatorB.createProductB(ProductB2.class);a_1.doSomething();a_2.doSomething();b_1.doSomething();b_2.doSomething();}}

打印：产品A1的实现方法产品A2的实现方法产品B1的实现方法产品B2的实现方法---------------------------产品A1的实现方法产品A2的实现方法产品B1的实现方法产品B2的实现方法