Java工厂模式详解
今天，让我们一起深入研究Java中的一项关键设计模式——工厂模式。工厂模式是一种创建型设计模式，它提供了一种灵活的方式来创建对象，使得整个系统更加可维护和扩展。
Java工厂模式详解
什么是工厂模式？
工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，但由子类决定要实例化的类是哪一个。这种模式的核心思想是将对象的实例化延迟到其子类。
工厂模式的优势
- 代码解耦： 将对象的创建和使用分离，降低了系统的耦合度。
- 易于扩展： 当需要添加新的产品时，只需添加相应的具体产品类和对应的具体工厂类，而不需要修改现有代码。
- 符合开闭原则： 对扩展开放，对修改关闭。
简单工厂模式
定义
简单工厂模式并不是GoF（Gang of Four）提出的23种设计模式之一，但它是工厂模式的一个简化版本。在简单工厂模式中，一个工厂类负责创建多个产品类的对象。
示例代码
// 产品接口
interface Product {
void produce();
}
// 具体产品A
class ConcreteProductA implements Product {
public void produce() {
System.out.println("Product A");
}
}
// 具体产品B
class ConcreteProductB implements Product {
public void produce() {
System.out.println("Product B");
}
}
// 简单工厂类
class SimpleFactory {
public static Product createProduct(String productType) {
switch (productType) {
case "A":
return new ConcreteProductA();
case "B":
return new ConcreteProductB();
default:
throw new IllegalArgumentException("Invalid product type");
}
}
}
// 使用示例
public class Main {
public static void main(String[] args) {
Product productA = SimpleFactory.createProduct("A");
productA.produce(); // Output: Product A
Product productB = SimpleFactory.createProduct("B");
productB.produce(); // Output: Product B
}
}工厂方法模式
定义
工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法使一个类的实例化延迟到其子类。
示例代码
// 产品接口
interface Product {
void produce();
}
// 具体产品A
class ConcreteProductA implements Product {
public void produce() {
System.out.println("Product A");
}
}
// 具体产品B
class ConcreteProductB implements Product {
public void produce() {
System.out.println("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 Main {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.produce(); // Output: Product A
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.produce(); //
Output: Product B
}
}抽象工厂模式
定义
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
示例代码
// 产品A接口
interface ProductA {
void produce();
}
// 产品B接口
interface ProductB {
void produce();
}
// 具体产品A1
class ConcreteProductA1 implements ProductA {
public void produce() {
System.out.println("Product A1");
}
}
// 具体产品A2
class ConcreteProductA2 implements ProductA {
public void produce() {
System.out.println("Product A2");
}
}
// 具体产品B1
class ConcreteProductB1 implements ProductB {
public void produce() {
System.out.println("Product B1");
}
}
// 具体产品B2
class ConcreteProductB2 implements ProductB {
public void produce() {
System.out.println("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 Main {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
productA1.produce(); // Output: Product A1
ProductB productB1 = factory1.createProductB();
productB1.produce(); // Output: Product B1
AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
productA2.produce(); // Output: Product A2
ProductB productB2 = factory2.createProductB();
productB2.produce(); // Output: Product B2
}
}Java工厂模式的应用场景
- 当一个类不知道它所必须创建的对象的类时。
- 当一个类希望由它的子类来指定它所创建的对象时。
- 当类将创建对象的职责委托给多个帮助子类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化时。
结尾总结
通过本文对Java工厂模式的详细解析，我们深入了解了简单工厂模式、工厂方法模式和抽象工厂模式的定义、UML类图以及示例代码。工厂模式是一种重要的设计模式，能够帮助我们更好地组织代码结构，提高代码的可维护性和可扩展性。
