设计模式之抽象工厂模式(6):最复杂的工厂模式变种
文章目录
场景
场景:
(1)就是我们现在要生产的不是一个一个产品,而是一个一个的产品组合
(2)比如说我们有产品AB,现在第一种产品组合是A1+B1,第二种产品组合是A2+B2,第三种产品组合是A3+B3
(3)就是要对工厂模式进行进一步的增强
内容
1.不使用抽象工厂模式
1.1 类图

1.2 代码
public class NonPattern {
public static void main(String[] args) {
//第一种产品组合:A1+B1
ProductA firstProductA1 = new ProductA1();
ProductB firstProductB1 = new ProductB1();
firstProductA1.excute();
firstProductB1.excute();
//第二种产品组合:A2+B2
ProductA secondProductA2 = new ProductA2();
ProductB secondProductB2 = new ProductB2();
secondProductA2.excute();
secondProductB2.excute();
//第三种产品组合:A3+B3
ProductA thirdProductA3 = new ProductA3();
ProductB thirdProductB3 = new ProductB3();
thirdProductA3.excute();
thirdProductB3.excute();
}
//======================产品抽象接口===================
public interface ProductA{
void excute();
};
public interface ProductB{
void excute();
};
//======================产品实体===================
public static class ProductA1 implements ProductA{
public void excute() {
System.out.println("产品A1的功能逻辑");
}
}
public static class ProductA2 implements ProductA{
public void excute() {
System.out.println("产品A2的功能逻辑");
}
}
public static class ProductA3 implements ProductA{
public void excute() {
System.out.println("产品A3的功能逻辑");
}
}
public static class ProductB1 implements ProductB{
public void excute() {
System.out.println("产品B1的功能逻辑");
}
}
public static class ProductB2 implements ProductB{
public void excute() {
System.out.println("产品B2的功能逻辑");
}
}
public static class ProductB3 implements ProductB{
public void excute() {
System.out.println("产品B3的功能逻辑");
}
}
}
2.使用抽象工厂模式
- 在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
- 抽象工厂模式就是在工厂模式下再抽象封装一层。
2.1 类图

2.2 代码
public class AbstractFactoryPattern2 {
public static void main(String[] args) {
// 产品组1:产品A1+产品B1
ProductA firstProductA = Product1Factory.getInstance().createProductA();
ProductB firstProductB = Product1Factory.getInstance().createProductB();
firstProductA.excute();
firstProductB.excute();
// 产品A2+产品B2
ProductA secondProductA = Product2Factory.getInstance().createProductA();
ProductB secondProductB = Product2Factory.getInstance().createProductB();
secondProductA.excute();
secondProductB.excute();
// 产品A3+产品B3
ProductA thirdProductA = Product3Factory.getInstance().createProductA();
ProductB thirdProductB = Product3Factory.getInstance().createProductB();
thirdProductA.excute();
thirdProductB.excute();
}
//======================工厂模式======================
//我们需要创建3个组合,那么我们创建3个不同工厂,如果组合需要改变,我们叫工厂里面改变对应的 商品即可
public interface Factory{
ProductA createProductA();
ProductB createProductB();
}
public static class Product1Factory implements Factory{
private static final Product1Factory instance = new Product1Factory();
public static Factory getInstance(){
return instance;
}
public ProductA createProductA() {
return new ProductA1();
}
public ProductB createProductB() {
return new ProductB1();
}
}
public static class Product2Factory implements Factory{
private static final Product2Factory instance = new Product2Factory();
public static Factory getInstance() {
return instance;
}
public ProductA createProductA() {
return new ProductA2();
}
public ProductB createProductB() {
return new ProductB2();
}
}
public static class Product3Factory implements Factory{
private static final Product3Factory instance = new Product3Factory();
public static Factory getInstance() {
return instance;
}
public ProductA createProductA() {
return new ProductA3();
}
public ProductB createProductB() {
return new ProductB3();
}
}
//=====================产品实体==================
public interface ProductA{
void excute();
};
public interface ProductB{
void excute();
};
public interface ProductC{
void excute();
};
public static class ProductA1 implements ProductA {
public void excute() {
System.out.println("产品A1的功能逻辑");
}
}
public static class ProductA2 implements ProductA {
public void excute() {
System.out.println("产品A2的功能逻辑");
}
}
public static class ProductA3 implements ProductA {
public void excute() {
System.out.println("产品A3的功能逻辑");
}
}
public static class ProductB1 implements ProductB {
public void excute() {
System.out.println("产品B1的功能逻辑");
}
}
public static class ProductB2 implements ProductB {
public void excute() {
System.out.println("产品B2的功能逻辑");
}
}
public static class ProductB3 implements ProductB {
public void excute() {
System.out.println("产品B3的功能逻辑");
}
}
}
3.总结
3.1 不使用设计模式对比
- 调整产品组合的这个行为,如果你手动创建产品组合的代码,有1000个地方,A1+B1一旦要调整,可能产品组合1位:A1+A3 就是要对1000个地方的代码,手动一点一点的去修改,组合的逻辑不可维护,不可扩展
3.2 使用设计模式对比
- 哪怕你有1000个地方定义了产品组合,要调整组合的逻辑,只要修改一个工厂就可以了。
- 如果需要改动产品:A1+B1的组合 为:A1+B3 我们只需要找到:产品组1(Factory1) 把之前的B1改为B3即可。客户端调用不需要变动。
- 哪怕你有100个地方定义了产品组合,要调整组合的逻辑,只要修改一个工厂就可以了。
3.3 工厂模式自己的特点
优点:1、当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
缺点:1、产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的Factory里加代码,又要在具体的里面加代码。

评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论