1. 工厂方法模式
使用场景
- 工厂方法模式是new一个对象的替代品，所以在所有需要生成对象的地方都可以使用，到那时需要慎重考虑是否要增加一个工厂类进行管理，增加代码的复杂度。
- 需要灵活的、可扩展的框架时，可以考虑采用工厂方法模式。
- 工厂方法模式可以用在异构项目中。
- 可以使用在测试驱动开发的框架下。
定义
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
下面是工厂方法模式的通用类图：
通用类图
优点
-
良好的封装性，代码结构清晰
一个对象创建是有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类名（或约束字符串）就可以了，不用知道创建对象的艰辛过程，降低模块间的耦合。 -
工厂方法模式的扩展性非常优秀
在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。 -
屏蔽产品类
这一点非常重要，产品类的实现如何变化，调用者都不需要关系，它只需要关心产品的接口，只要接口保持不变，系统中的上层模块就不要发生变化。因为产品类的实例化工作是由工厂类负责的，一个产品对象具体由哪一个产品生成是由工厂类决定的。 -
工厂方法模式是典型的解耦框架
高层模块只需要知道产品的抽象类，其他的实现类都不用关心，符合迪米特法则，我不需要的就不要去交流；也符合依赖倒置原则，只依赖产品类的抽象；当然也符合里氏替换原则，使用产品子类替换父类也没问题。
具体实现
- 抽象产品类
/**
* 抽象产品类
*
*/
public abstract class Product {
// 产品类的公共方法
public void method1() {
// 业务处理逻辑
System.out.println("这是所有产品共有的方法！");
}
// 抽象方法
public abstract void method2();
}
- 具体产品类
具体产品1
/**
* 具体产品类1
*
*/
public class ConcreteProduct1 extends Product {
@Override
public void method2() {
System.out.println("产生了具体产品一！");
}
}
具体产品2
/**
* 具体产品类2
*
*/
public class ConcreteProduct2 extends Product {
@Override
public void method2() {
System.out.println("产生了具体产品二！");
}
}
- 抽象工厂类
/**
* 抽象工厂类
*
*/
public abstract class Creator {
/**
* 创建一个产品对象，其输入参数类型可以自行设置
* 通常为String、Enum、Class等，当然也可以为空
* @param <T>
* @param c
* @return
*/
public abstract <T extends Product> T createProduct(Class<T> c);
}
- 具体工厂类
/**
* 具体工厂类
*
*/
public class ConcreteCreator extends Creator {
@Override
public <T extends Product> T createProduct(Class<T> c) {
Product product = null;
try {
product = (Product) Class.forName(c.getName()).newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return (T) product;
}
}
- 测试类
/**
* 客户类
*
*/
public class testCreator {
/**
* @param args
*/
public static void main(String[] args) {
Creator creator = new ConcreteCreator();
Product product1 = creator.createProduct(ConcreteProduct1.class);
Product product2 = creator.createProduct(ConcreteProduct2.class);
/*
* 继续业务处理
*/
product1.method1();
product1.method2();
product2.method1();
product2.method2();
}
}
2. 抽象工厂模式
使用场景
一个对象族（或是一组没有任何关系的对象）都有相同的约束，则可以使用抽象工厂模式。
定义
为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。
抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
通用类图如下：
抽象工厂类图
优缺点
优点：
- 封装性。
每个产品的实现类不是高层模块要关心的，高层模块只关心抽象和接口，不关心对象是如何创建出来的。 - 产品族内的约束为非公开状态。
具体的产品族内的约束是在工厂内实现的。
缺点：
- 抽象工厂模式的最大缺点就是产品族扩展非常困难。
例如增加产品C，也就是说产品家族由原来2个增加到3个，抽象类AbstractFactory要增加一个方法createProductC()，然后两个实现类都要修改。
具体实现
- 抽象产品类
抽象产品类A
/**
* 抽象产品类A
*
*/
public abstract class AbstractProductA {
public void shareMethod(){
System.out.println("这是共享的产品A方法！");
}
public abstract void doSomething();
}
抽象产品类B
/**
* 抽象产品类B
*
*/
public abstract class AbstractProductB {
public void shareMethod(){
System.out.println("这是共享的产品B方法！");
}
public abstract void doSomething();
}
- 具体产品类
具体产品A1
/**
* 具体产品类A1
*
*/
public class ProductA1 extends AbstractProductA {
@Override
public void doSomething() {
System.out.println("这是产品A1");
}
}
具体产品A2
/**
* 具体产品类A2
*
*/
public class ProductA2 extends AbstractProductA {
@Override
public void doSomething() {
System.out.println("这是产品A2");
}
}
具体产品B1
/**
* 具体产品类B1
*
*/
public class ProductB1 extends AbstractProductB {
@Override
public void doSomething() {
System.out.println("这是产品B1");
}
}
具体产品B2
/**
* 具体产品类B2
*
*/
public class ProductB2 extends AbstractProductB {
@Override
public void doSomething() {
System.out.println("这是产品B2");
}
}
- 抽象工厂类
/**
* 抽象工厂类
*
*/
public abstract class AbstractFactory {
public abstract AbstractProductA createProductA();
public abstract AbstractProductB createProductB();
}
- 具体工厂类
具体工厂类1（产生X1系列产品）
/**
* 具体工厂类1
*
*/
public class Factory1 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
// TODO Auto-generated method stub
return new ProductA1();
}
@Override
public AbstractProductB createProductB() {
// TODO Auto-generated method stub
return new ProductB1();
}
}
具体工厂类2（产生X2系列产品）
/**
* 具体工厂类2
*
*/
public class Factory2 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
// TODO Auto-generated method stub
return new ProductA2();
}
@Override
public AbstractProductB createProductB() {
// TODO Auto-generated method stub
return new ProductB2();
}
}
- 测试类
/**
* 客户类
*
*/
public class testAbstractFactory {
/**
* @param args
*/
public static void main(String[] args) {
// 定义出两个工厂
AbstractFactory factory1 = new Factory1();
AbstractFactory factory2 = new Factory2();
// 产生A1对象
AbstractProductA a1 = factory1.createProductA();
// 产生A2对象
AbstractProductA a2 = factory2.createProductA();
// 产生B1对象
AbstractProductB b1 = factory1.createProductB();
// 产生B2对象
AbstractProductB b2 = factory2.createProductB();
// 业务处理
a1.shareMethod();
a1.doSomething();
a2.shareMethod();
a2.doSomething();
b1.shareMethod();
b1.doSomething();
b2.shareMethod();
b2.doSomething();
}
}
网友评论