每天早上八点,准时推送干货
昨天我们说了关于Java中的单例模式,以及Spring中单例模式的应用,今天了不起就和大家来聊一下关于工厂模式的相关内容。
Java中的工厂模式(Factory Pattern)是一种创建型设计模式,它提供了一种创建对象的最佳方式,而不需要在代码中显式指定所要创建的具体类。工厂模式的主要目的是将对象的创建与使用分离,从而减少类之间的耦合度,并使得软件结构更加灵活、可扩展。
工厂模式主要分为三种类型:简单工厂模式(Simple Factory Pattern)、工厂方法模式(Factory Method Pattern)和抽象工厂模式(Abstract Factory Pattern)。
简单工厂模式(Static Factory Method)
简单工厂模式并不属于GoF的23种设计模式之一,但它常被用作引入工厂模式概念的起点。简单工厂模式通过一个工厂类来创建具体的产品实例,通常使用静态方法来实现。
优点:
缺点:
工厂方法模式(Factory Method)
工厂方法模式定义了一个创建对象的接口,但让子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类中进行。
抽象产品类(Product)
public interface Product {
void use();
}
具体产品类(ConcreteProductA, ConcreteProductB)
public class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("Using ConcreteProductA");
}
}
public class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("Using ConcreteProductB");
}
}
抽象工厂类(Creator)
public abstract class Creator {
public abstract Product factoryMethod();
// 模板方法
public void someOperation() {
Product product = factoryMethod();
product.use();
}
}
具体工厂类(ConcreteCreatorA, ConcreteCreatorB)
public class ConcreteCreatorA extends Creator {
@Override
public Product factoryMethod() {
return new ConcreteProductA();
}
}
public class ConcreteCreatorB extends Creator {
@Override
public Product factoryMethod() {
return new ConcreteProductB();
}
}
客户端代码
public class Client {
public static void main(String[] args) {
Creator creatorA = new ConcreteCreatorA();
creatorA.someOperation(); // 输出: Using ConcreteProductA
Creator creatorB = new ConcreteCreatorB();
creatorB.someOperation(); // 输出: Using ConcreteProductB
}
}
优点:
缺点:
抽象工厂模式提供一个接口,用于创建相关或依赖对象的家族,而不需要明确指定具体类。
抽象产品类(AbstractProductA, AbstractProductB)
public interface AbstractProductA {
void use();
}
public interface AbstractProductB {
void anotherMethod();
}
具体产品类(ConcreteProductA1, ConcreteProductA2, ConcreteProductB1, ConcreteProductB2)
public class ConcreteProductA1 implements AbstractProductA {
@Override
public void use() {
System.out.println("Using ConcreteProductA1");
}
}
public class ConcreteProductA2 implements AbstractProductA {
@Override
public void use() {
System.out.println("Using ConcreteProductA2");
}
}
// 同理实现 ConcreteProductB1 和 ConcreteProductB2
抽象工厂类(AbstractFactory)
public interface AbstractFactory {
AbstractProductA createProductA();
AbstractProductB createProductB();
}
具体工厂类(ConcreteFactory1, ConcreteFactory2)
public class ConcreteFactory1 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB1();
}
}
// 同理实现 ConcreteFactory2
客户端代码
public class Client {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
AbstractProductA productA1 = factory1.createProductA();
productA1.use(); // 输出: Using ConcreteProductA1
AbstractProductB productB1 = factory1.createProductB();
// 假设有 anotherMethod 的实现
// productB1.anotherMethod();
// 可以根据需要使用 ConcreteFactory2 来创建不同的产品族
}
}
优点:
缺点:
你对工厂模式了解了吗?