工厂模式和抽象工厂是创建型设计模式，它们都旨在解决对象的创建过程，并提供了一种灵活、可扩展的方式来创建相关的对象。
一、工厂模式（Factory Pattern）
工厂模式是简单工厂模式的一种形式，它定义了一个用于创建对象的接口，但是具体创建哪个类的实例由子类决定。工厂模式包含以下角色：
1、抽象产品（Product）：定义了产品的公共接口，也可以是一个抽象类。
2、具体产品（Concrete Product）：实现了抽象产品接口的具体类。
3、工厂（Factory）：定义了一个用于创建产品的工厂方法。
下面以一个简单的示例来演示如何使用Java实现工厂模式。
代码语言：javascript复制// 抽象产品
interface Product {
void use();
}
// 具体产品A
class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("使用产品A");
}
}
// 具体产品B
class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("使用产品B");
}
}
// 工厂
class Factory {
public static Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
} else {
throw new IllegalArgumentException("Unsupported product type: " type);
}
}
}
// 使用工厂创建产品
public class FactoryPatternExample {
public static void main(String[] args) {
Product productA = Factory.createProduct("A");
productA.use();
Product productB = Factory.createProduct("B");
productB.use();
}
}
上述示例中，抽象产品Product定义了产品的公共接口，具体产品ConcreteProductA和ConcreteProductB实现了该接口。工厂Factory负责根据参数创建对应的具体产品，并返回抽象产品。在FactoryPatternExample类中，我们通过工厂创建了两个具体产品并使用。
工厂模式的优点在于客户端代码只需要知道产品的抽象接口，而无需关心具体产品的实现细节。这样可以降低代码的耦合性，提高代码的可维护性和可扩展性。
二、抽象工厂（Abstract Factory）
抽象工厂是一个超级工厂，它可以创建一组相关或依赖的对象。抽象工厂允许客户端使用抽象接口来创建一组对象，而不需要知道具体的实现类。抽象工厂包含以下角色：
1、抽象工厂（Abstract Factory）：定义了创建一组产品的接口。
2、具体工厂（Concrete Factory）：实现了抽象工厂接口，用于创建一组具体产品。每个具体工厂负责创建一组相关的产品。
3、抽象产品（Abstract Product）：定义了产品的公共接口。
4、具体产品（Concrete Product）：实现了抽象产品接口的具体类。
下面以一个简单的示例来演示如何使用Java实现抽象工厂。
代码语言：javascript复制// 抽象产品A
interface ProductA {
void useA();
}
// 具体产品A1
class ConcreteProductA1 implements ProductA {
@Override
public void useA() {
System.out.println("使用产品A1");
}
}
// 具体产品A2
class ConcreteProductA2 implements ProductA {
@Override
public void useA() {
System.out.println("使用产品A2");
}
}
// 抽象产品B
interface ProductB {
void useB();
}
// 具体产品B1
class ConcreteProductB1 implements ProductB {
@Override
public void useB() {
System.out.println("使用产品B1");
}
}
// 具体产品B2
class ConcreteProductB2 implements ProductB {
@Override
public void useB() {
System.out.println("使用产品B2");
}
}
// 抽象工厂
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
// 使用抽象工厂创建产品
public class AbstractFactoryPatternExample {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
productA1.useA();
ProductB productB1 = factory1.createProductB();
productB1.useB();
AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
productA2.useA();
ProductB productB2 = factory2.createProductB();
productB2.useB();
}
}
上述示例中，抽象产品ProductA和ProductB定义了产品的公共接口，具体产品ConcreteProductA1、ConcreteProductA2、ConcreteProductB1和ConcreteProductB2实现了这些接口。抽象工厂AbstractFactory定义了创建一组产品的方法，具体工厂ConcreteFactory1和ConcreteFactory2分别实现了抽象工厂接口，并负责创建一组相关的产品。
在 AbstractFactoryPatternExample类中，我们使用具体工厂1创建了产品A1和产品B1，使用具体工厂2创建了产品A2和产品B2。
抽象工厂模式使得客户端代码与具体产品的实现相分离，客户端只需要使用抽象接口和抽象工厂来创建产品。这种设计使得系统更具有灵活性，可以方便地切换不同的产品组合。
工厂模式和抽象工厂都是用于对象的创建过程，通过封装和抽象来解耦客户端代码与具体产品的实现。工厂模式适用于单个产品族的情况，而抽象工厂适用于多个相关产品族的情况。在实际开发中，我们可以根据需求选择合适的设计模式来实现灵活、可扩展的对象创建机制。
