Java中的工厂设计模式是一种创建型设计模式，它提供了一种将对象的创建逻辑抽象出来的方法，使得客户端代码不需要直接实例化具体的类，而是通过一个共同的接口来创建对象。这样可以降低代码之间的耦合性，提高代码的可维护性和可扩展性。
在工厂设计模式中，通常有三种主要的类型：简单工厂模式、工厂方法模式和抽象工厂模式。下面分别介绍这三种类型的工厂模式：
- 简单工厂模式（Simple Factory Pattern）： 简单工厂模式也称为静态工厂模式，它通过一个工厂类来封装对象的创建逻辑，客户端通过传递不同的参数给工厂类来获取不同类型的对象。简单工厂模式适用于创建单一类型的对象。
示例代码：
// 产品接口
interface Product {
void produce();
}
// 具体产品类A
class ConcreteProductA implements Product {
public void produce() {
System.out.println("Producing Product A");
}
}
// 具体产品类B
class ConcreteProductB implements Product {
public void produce() {
System.out.println("Producing Product B");
}
}
// 简单工厂类
class SimpleFactory {
public Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
}
throw new IllegalArgumentException("Invalid product type");
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
SimpleFactory factory = new SimpleFactory();
Product productA = factory.createProduct("A");
Product productB = factory.createProduct("B");
productA.produce();
productB.produce();
}
}
- 工厂方法模式（Factory Method Pattern）： 工厂方法模式通过定义一个接口来创建对象，每个具体的产品类都实现这个接口，并提供了自己的工厂方法来创建对象。客户端通过调用具体产品类的工厂方法来获取对象，从而将对象的创建延迟到具体的产品类中。
示例代码：
// 产品接口
interface Product {
void produce();
}
// 具体产品类A
class ConcreteProductA implements Product {
public void produce() {
System.out.println("Producing Product A");
}
}
// 具体产品类B
class ConcreteProductB implements Product {
public void produce() {
System.out.println("Producing Product B");
}
}
// 工厂接口
interface Factory {
Product createProduct();
}
// 具体工厂类A
class ConcreteFactoryA implements Factory {
public Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂类B
class ConcreteFactoryB implements Factory {
public Product createProduct() {
return new ConcreteProductB();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.produce();
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.produce();
}
}
- 抽象工厂模式（Abstract Factory Pattern）： 抽象工厂模式通过提供一个接口来创建一组相关或相互依赖的对象，每个具体的工厂类都实现这个接口，并负责创建一组相关的产品。客户端通过调用具体工厂类的方法来获取相应的产品组，从而将产品的创建和客户端的使用分离。
示例代码：
// 产品接口A
interface ProductA {
void produce();
}
// 具体产品类A1
class ConcreteProductA1 implements ProductA {
public void produce() {
System.out.println("Producing Product A1");
}
}
// 具体产品类A2
class ConcreteProductA2 implements ProductA {
public void produce() {
System.out.println("Producing Product A2");
}
}
// 产品接口B
interface ProductB {
void produce();
}
// 具体产品类B1
class ConcreteProductB1 implements ProductB {
public void produce() {
System.out.println("Producing Product B1");
}
}
// 具体产品类B2
class ConcreteProductB2 implements ProductB {
public void produce() {
System.out.println("Producing Product B2");
}
}
// 抽象工厂接口
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// 具体工厂类1
class ConcreteFactory1 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA1();
}
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂类2
class ConcreteFactory2 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA2();
}
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.produce();
productB1.produce();
AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.produce();
productB2.produce();
}
}
以上是三种常见的工厂设计模式的示例代码。工厂设计模式在实际开发中经常被使用，特别是在需要创建复杂对象或者遵循开闭原则的场景下，它可以帮助我们更好地组织和管理对象的创建过程。
