工厂模式（Factory Pattern）是 Java 中常见的设计模式之一，用于通过工厂类创建对象，而不是直接使用构造函数。
工厂模式可以将对象的创建和使用分离，使得代码更加灵活、可扩展和易维护。常见的工厂模式有三种实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。
简单工厂模式
简单工厂模式（Simple Factory Pattern）是最简单的工厂模式，它通过一个工厂类来创建对象，而不需要直接使用构造函数。具体实现如下：
public class SimpleFactory {
public static Product createProduct(String type) {
if (type.equals("A")) {
return new ConcreteProductA();
} else if (type.equals("B")) {
return new ConcreteProductB();
}
return null;
}
}
public interface Product {
void doSomething();
}
public class ConcreteProductA implements Product {
@Override
public void doSomething() {
System.out.println("ConcreteProductA do something");
}
}
public class ConcreteProductB implements Product {
@Override
public void doSomething() {
System.out.println("ConcreteProductB do something");
}
}
在这个示例中，我们定义了一个工厂类 SimpleFactory 和两个产品类 ConcreteProductA 和 ConcreteProductB，它们都实现了同一个产品接口 Product。SimpleFactory 类提供一个静态方法 createProduct(String type) 来创建产品对象，根据不同的参数类型来创建不同的产品对象。通过这种方式，我们可以在不暴露产品类的构造函数的情况下创建产品对象。
工厂方法模式
工厂方法模式（Factory Method Pattern）是一个稍微复杂一些的工厂模式，它将工厂抽象成一个接口或抽象类，每个具体工厂类只负责创建特定的产品，而不是像简单工厂模式那样负责创建所有产品。具体实现如下：
public interface Factory {
Product createProduct();
}
public class ConcreteFactoryA implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
public class ConcreteFactoryB implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
在这个示例中，我们定义了一个工厂接口 Factory 和两个具体工厂类 ConcreteFactoryA 和 ConcreteFactoryB，它们都实现了工厂接口，并负责创建特定的产品对象。这里的关键是将工厂抽象成一个接口或抽象类，每个具体工厂类负责创建特定的产品对象，从而使得代码更加灵活和易扩展。
抽象工厂模式
抽象工厂模式（Abstract Factory Pattern）是工厂模式的高级形式，它提供一个接口或抽象类来定义一系列相关或依赖对象的工厂，而不需要指定具体类。具体实现如下：
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
public interface ProductA {
void doSomething();
}
public interface ProductB {
void doSomething();
}
public class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
public class ConcreteFactory2 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
public class ConcreteProductA1 implements ProductA {
@Override
public void doSomething() {
System.out.println("ConcreteProductA1 do something");
}
}
public class ConcreteProductA2 implements ProductA {
@Override
public void doSomething() {
System.out.println("ConcreteProductA2 do something");
}
}
public class ConcreteProductB1 implements ProductB {
@Override
public void doSomething() {
System.out.println("ConcreteProductB1 do something");
}
}
public class ConcreteProductB2 implements ProductB {
@Override
public void doSomething() {
System.out.println("ConcreteProductB2 do something");
}
}
在这个示例中，我们定义了一个抽象工厂接口 AbstractFactory 和四个产品接口 ProductA、ProductB、ConcreteProductA1 和 ConcreteProductB1。AbstractFactory 接口定义了两个工厂方法 createProductA() 和 createProductB()，每个具体工厂类负责创建一系列相关或依赖对象的工厂。例如，ConcreteFactory1 负责创建 ConcreteProductA1 和 ConcreteProductB1，而 ConcreteFactory2 负责创建 ConcreteProductA2 和 ConcreteProductB2。这样我们就可以以一种通用的方式来创建一系列相关的对象。
网友评论