工厂模式 与 抽象工厂模式 的区别

工厂模式：

// 抽象产品接口
interface Product {void showInfo();
}// 具体产品A
class ConcreteProductA implements Product {@Overridepublic void showInfo() {System.out.println("This is Product A");}
}// 具体产品B
class ConcreteProductB implements Product {@Overridepublic void showInfo() {System.out.println("This is Product B");}
}// 抽象工厂类
abstract class Creator {abstract Product createProduct();
}// 具体工厂A，生产产品A
class ConcreteCreatorA extends Creator {@OverrideProduct createProduct() {return new ConcreteProductA();}
}// 具体工厂B，生产产品B
class ConcreteCreatorB extends Creator {@OverrideProduct createProduct() {return new ConcreteProductB();}
}public class FactoryMethodExample {public static void main(String[] args) {Creator creatorA = new ConcreteCreatorA();Product productA = creatorA.createProduct();productA.showInfo();Creator creatorB = new ConcreteCreatorB();Product productB = creatorB.createProduct();productB.showInfo();}
}

在这个示例中，Product 是抽象产品接口，ConcreteProductA 和 ConcreteProductB 是具体的产品类。Creator 是抽象工厂类，ConcreteCreatorA 和 ConcreteCreatorB 是具体的工厂类，分别生产不同的产品。在场景类中，通过具体的工厂来创建不同的产品，而无需直接涉及具体产品的实现类。这就是工厂方法模式的正确用法。

抽象工厂模式：

// 抽象产品接口
interface ProductA {void showInfo();
}// 具体产品A1
class ConcreteProductA1 implements ProductA {@Overridepublic void showInfo() {System.out.println("This is Product A1");}
}// 具体产品A2
class ConcreteProductA2 implements ProductA {@Overridepublic void showInfo() {System.out.println("This is Product A2");}
}// 抽象产品接口
interface ProductB {void showInfo();
}// 具体产品B1
class ConcreteProductB1 implements ProductB {@Overridepublic void showInfo() {System.out.println("This is Product B1");}
}// 具体产品B2
class ConcreteProductB2 implements ProductB {@Overridepublic void showInfo() {System.out.println("This is Product B2");}
}// 抽象工厂接口
interface AbstractFactory {ProductA createProductA();ProductB createProductB();
}// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {@Overridepublic ProductA createProductA() {return new ConcreteProductA1();}@Overridepublic ProductB createProductB() {return new ConcreteProductB1();}
}// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {@Overridepublic ProductA createProductA() {return new ConcreteProductA2();}@Overridepublic ProductB createProductB() {return new ConcreteProductB2();}
}public class AbstractFactoryExample {public static void main(String[] args) {AbstractFactory factory1 = new ConcreteFactory1();ProductA productA1 = factory1.createProductA();ProductB productB1 = factory1.createProductB();productA1.showInfo();productB1.showInfo();AbstractFactory factory2 = new ConcreteFactory2();ProductA productA2 = factory2.createProductA();ProductB productB2 = factory2.createProductB();productA2.showInfo();productB2.showInfo();}
}

在这个示例中，AbstractFactory 是抽象工厂接口，ConcreteFactory1 和 ConcreteFactory2 是具体工厂类，分别生产不同系列的产品。每个具体工厂类实现了创建一组相关产品的方法。这就是抽象工厂模式的示例。

区别：

抽象工厂模式（Abstract Factory Pattern）和工厂方法模式（Factory Method Pattern）是两种不同的设计模式，它们都属于创建型模式，用于创建对象。它们之间的区别在于抽象程度和用途。

1. 抽象工厂模式：

   • 抽象工厂模式用于创建一组相关或相互依赖的对象，这些对象通常属于不同的产品族。
   • 它包含一个抽象工厂接口，该接口声明了一组用于创建不同类型产品的抽象方法。每个具体工厂类实现了这些方法以创建特定产品族的对象。
   • 抽象工厂模式强调创建一组对象，通常涉及多个产品接口和多个产品实现类。

2. 工厂方法模式：

   • 工厂方法模式用于创建单一对象，但是通过子类来决定实例化哪个类。
   • 它包含一个抽象工厂基类（接口或抽象类），该基类声明了一个用于创建对象的抽象方法。每个具体工厂子类实现这个方法以返回特定的产品对象。
   • 工厂方法模式强调创建单一对象，每个工厂子类负责创建一种产品。

总结：

       抽象工厂模式关注于一组相互关联的产品，而工厂方法模式关注于单一产品。抽象工厂模式的实现可能比较复杂，涉及多个产品族，而工厂方法模式通常相对简单，每个子类只负责一个产品。选择哪个模式取决于需求的复杂性和结构的设计。

       抽象工厂模式在工厂模式的基础上扩展了一个维度，不仅关注单一产品的创建，还关注一组相关或相互依赖的产品族的创建。这些产品族通常在业务逻辑上有关联，它们可能共同构成一个完整的功能。

缺点总结：

在抽象工厂模式中，如果你想要增加一个新的产品，比如产品C，你需要在抽象工厂接口（或抽象类）中添加一个新的方法来创建该产品。然后，所有的具体工厂类都必须实现这个新方法，为产品C提供实现。这会导致两个问题：

1. 修改抽象类或接口： 在这个例子中，你需要在AbstractCreator中增加一个createProductC()方法，并且ConcreteFactory1 和ConcreteFactory2都必须实现这个方法。这违反了开闭原则，即系统应该对扩展开放，对修改关闭。

2. 影响已有代码： 增加新方法会影响到所有已经实现了该抽象工厂的具体工厂类，即ConcreteFactory1 和ConcreteFactory2。这可能会导致许多现有的代码需要修改，因此它们与这个变化产生了依赖关系，即所谓的“有毒代码”。

这种情况下，每次需要增加一个新的产品时，都会引发一系列的修改，从而导致系统的脆弱性和不稳定性。这就是抽象工厂模式的一个局限性，特别是当产品族的变化比较频繁时，扩展性不如其他设计模式。

这也是为什么有时候推荐使用工厂方法模式，因为它对于新增产品更具有弹性，不会对已有的代码造成较大的影响。但抽象工厂模式的优势在于它能够同时创建一组相关的产品，适用于需要创建一组具有特定关联性的对象的情况。

但是也有优点，在添加新的产品族时，只需要新增对应的产品接口和实现，而不需要修改已有的工厂类和产品类。这符合开闭原则，允许易于扩展而不影响现有代码。