类图
定义
定义一个用于创建对象的接口,让子类决定实例化哪一个类。工程方法使一个类的实例化延迟到其子类
优缺点
- 良好的封装性,代码结构清晰。调用者只需知道产品类名,不必知道创建对的过程,降低了模块间的耦合
- 扩展性优秀。在新增产品的情况下,适当修改具体工厂类或扩展一个工厂类即可
- 屏蔽产品类。产品类的实现如何变化,调用者无需关心,它只关心接口
- 典型的解耦框架。符合迪米特法则,我不需要的不要去交流;符合依赖倒置原则,只依赖产品类的抽象;符合里氏替换原则,使用产品子类替换产品父类
使用场景
- 需要生成对象的地方
- 需要灵活,可扩展的框架时
- 可以使用在异构环境中
- 可以使用在测试驱动开发的框架下
扩展
简单工厂模式:将原来的抽象工厂中的创建方法改成静态方法
注意事项
工厂方法模式最好是与其他模式(如模板方法模式,单例模式,原型模式等)混合,如此可以变化出无穷的设计
工厂模式介绍
分类
- 简单工厂模式(Simple Factory)(静态工厂方法模式)
- 工厂方法模式(Factory Method)
- 抽象工厂模式(Abstract Factory)
其中,简单工厂模式一般被看为是工厂方法模式的特例。
区别
工厂方法模式:
一个抽象产品类,可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
一个抽象工厂对应一个抽象产品。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式:
多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
一个抽象工厂对应多个抽象产品。
每个具体工厂类可以创建多个具体产品类的实例。
区别:
工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。
源码
抽象产品类
public abstract class Product {
/**
* 业务逻辑处理
*/
public void method1() {
System.out.println("Product->method1");
}
/**
* 抽象方法
*/
public abstract void method2();
}
具体产品类1
public class ConcreteProduct1 extends Product {
@Override
public void method2() {
// 具体逻辑处理
System.out.println("ConcreteProduct1->method2");
}
}
具体产品类2
public class ConcreteProduct2 extends Product {
@Override
public void method2() {
// 具体逻辑处理
System.out.println("ConcreteProduct2->method2");
}
}
简单工厂模式工厂类
public class SimpleFactory {
public Product createProduct(int type) {
switch (type) {
case 1:
return new ConcreteProduct1();
case 2:
return new ConcreteProduct2();
default:
return null;
}
}
}
场景类
public class Client {
public static void main(String args[]) {
// 简单工厂模式
SimpleFactory simpleFactory = new SimpleFactory();
Product simpleProduct1 = simpleFactory.createProduct(1);
Product simpleProduct2 = simpleFactory.createProduct(2);
simpleProduct1.method2();
simpleProduct2.method2();
}
}
简单工厂模式违背了高内聚的单一职责原则,不利于工程维护。
工厂方法模式 抽象工厂类
public abstract class AbsFactory {
public abstract Product createProduct();
}
生产产品1的实体工厂类
public class ConcreteFactory1 extends AbsFactory {
@Override
public Product createProduct() {
return new ConcreteProduct1();
}
}
生产产品2的实体工厂类
public class ConcreteFactory2 extends AbsFactory {
@Override
public Product createProduct() {
return new ConcreteProduct2();
}
}
场景类
public class Client {
public static void main(String args[]) {
// 工厂方法模式
AbsFactory factory1 = new ConcreteFactory1();
AbsFactory factory2 = new ConcreteFactory2();
Product normalProduct1 = factory1.createProduct();
Product normalProduct2 = factory2.createProduct();
normalProduct1.method2();
normalProduct2.method2();
}
}
优化后的工厂方法模式 抽象工厂类
public abstract class Factory {
public abstract Product createProduct(Class<? extends Product> c);
}
实体工厂类
public class ConcreteFactory extends Factory {
/**
* 利用反射机制,生产产品,这样写结合了抽象工厂模式的优点,又保留了工厂方法模式的优点,让子类决定实例化
*
* @return 产品
*/
@Override
public Product createProduct(Class<? extends Product> c) {
Product product = null;
try {
product = (Product) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
// 异常处理
e.printStackTrace();
}
return product;
}
}
场景类
public class Client {
public static void main(String args[]) {
// 优化工厂方法模式,新建工厂类
Factory creator = new ConcreteFactory();
// 生产产品1
Product product1 = creator.createProduct(ConcreteProduct1.class);
// 生产产品2
Product product2 = creator.createProduct(ConcreteProduct2.class);
// 执行产品方法
product1.method1();
product1.method2();
product2.method2();
}
}
优化后的形式可以减少工厂类的创建。