Java 设计模式简介
Java 设计模式是一套被广泛应用于面向对象软件设计的可复用解决方案。它提供了一系列经过验证的设计思想和方法，可以帮助我们解决常见的软件设计问题，并提高软件的可维护性、可扩展性和可重用性。
Java 设计模式通常被分为三类：创建型模式、结构型模式和行为型模式。其中，创建型模式主要用于处理对象的创建过程，结构型模式主要用于处理对象的组合和关系，行为型模式主要用于处理对象之间的通信和协作。
下面，我们将介绍基于 Java 的工厂模式，并举例说明它们的实际场景和运用。
Java 创建型模式
工厂模式（Factory Pattern）
工厂模式是一种常见的创建型模式，它通过定义一个工厂类来创建对象，将对象的创建过程与使用过程分离。工厂模式通常分为简单工厂模式、工厂方法模式和抽象工厂模式三种形式。
实际场景
在一个订单系统中，我们需要根据用户的订单类型来创建不同的订单对象，比如普通订单、团购订单、促销订单等。这时，我们可以使用工厂模式来创建订单对象，将订单的创建过程封装在工厂类中，根据不同的订单类型返回不同的订单对象。
简单工厂模式 - 代码示例：
// 订单工厂类
class OrderFactory {
public static Order createOrder(String type) {
switch (type) {
case "normal":
return new NormalOrder();
case "group":
return new GroupOrder();
case "promotion":
return new PromotionOrder();
default:
throw new IllegalArgumentException("Invalid order type: " + type);
}
}
}
// 订单接口
interface Order {
void process();
}
// 普通订单类
class NormalOrder implements Order {
public void process() {
System.out.println("Processing normal order...");
}
}
// 团购订单类
class GroupOrder implements Order {
public void process() {
System.out.println("Processing group order...");
}
}
// 促销订单类
class PromotionOrder implements Order {
public void process() {
System.out.println("Processing promotion order...");
}
}
// 客户端代码
class Client {
public static void main(String[] args) {
// 创建普通订单对象
Order normalOrder = OrderFactory.createOrder("normal");
normalOrder.process(); // 输出 "Processing normal order..."
// 创建团购订单对象
Order groupOrder = OrderFactory.createOrder("group");
groupOrder.process(); // 输出 "Processing group order..."
// 创建促销订单对象
Order promotionOrder = OrderFactory.createOrder("promotion");
promotionOrder.process(); // 输出 "Processing promotion order..."
// 创建一个无效的订单类型，会抛出 IllegalArgumentException 异常
Order invalidOrder = OrderFactory.createOrder("invalid");
}
}
工厂方法模式：
// 订单工厂接口
interface OrderFactory {
Order createOrder();
}
// 普通订单工厂实现类
class NormalOrderFactory implements OrderFactory {
public Order createOrder() {
return new NormalOrder();
}
}
// 团购订单工厂实现类
class GroupOrderFactory implements OrderFactory {
public Order createOrder() {
return new GroupOrder();
}
}
// 促销订单工厂实现类
class PromotionOrderFactory implements OrderFactory {
public Order createOrder() {
return new PromotionOrder();
}
}
// 客户端代码
class Client {
public static void main(String[] args) {
// 创建普通订单工厂对象
OrderFactory normalFactory = new NormalOrderFactory();
// 使用普通订单工厂对象创建普通订单对象
Order normalOrder = normalFactory.createOrder();
normalOrder.process(); // 输出 "Processing normal order..."
// 创建团购订单工厂对象
OrderFactory groupFactory = new GroupOrderFactory();
// 使用团购订单工厂对象创建团购订单对象
Order groupOrder = groupFactory.createOrder();
groupOrder.process(); // 输出 "Processing group order..."
// 创建促销订单工厂对象
OrderFactory promotionFactory = new PromotionOrderFactory();
// 使用促销订单工厂对象创建促销订单对象
Order promotionOrder = promotionFactory.createOrder();
promotionOrder.process(); // 输出 "Processing promotion order..."
}
}
抽象工厂模式：
// 订单工厂接口
interface OrderFactory {
NormalOrder createNormalOrder();
GroupOrder createGroupOrder();
PromotionOrder createPromotionOrder();
}
// 订单工厂实现类
class ConcreteOrderFactory implements OrderFactory {
public NormalOrder createNormalOrder() {
return new ConcreteNormalOrder();
}
public GroupOrder createGroupOrder() {
return new ConcreteGroupOrder();
}
public PromotionOrder createPromotionOrder() {
return new ConcretePromotionOrder();
}
}
// 普通订单接口
interface NormalOrder {
void process();
}
// 团购订单接口
interface GroupOrder {
void process();
}
// 促销订单接口
interface PromotionOrder {
void process();
}
// 具体普通订单类
class ConcreteNormalOrder implements NormalOrder {
public void process() {
System.out.println("Processing concrete normal order...");
}
}
// 具体团购订单类
class ConcreteGroupOrder implements GroupOrder {
public void process() {
System.out.println("Processing concrete group order...");
}
}
// 具体促销订单类
class ConcretePromotionOrder implements PromotionOrder {
public void process() {
System.out.println("Processing concrete promotion order...");
}
}
// 客户端代码
class Client {
public static void main(String[] args) {
// 创建具体订单工厂对象
OrderFactory factory = new ConcreteOrderFactory();
// 使用具体订单工厂对象创建具体普通订单对象
NormalOrder normalOrder = factory.createNormalOrder();
normalOrder.process(); // 输出 "Processing concrete normal order..."
// 使用具体订单工厂对象创建具体团购订单对象
GroupOrder groupOrder = factory.createGroupOrder();
groupOrder.process(); // 输出 "Processing concrete group order..."
// 使用具体订单工厂对象创建具体促销订单对象
PromotionOrder promotionOrder = factory.createPromotionOrder();
promotionOrder.process(); // 输出 "Processing concrete promotion order..."
}
}
总结
工厂模式是一种创建型模式，它提供了一种创建对象的最佳方式，将对象的创建和使用分离开来，从而降低了系统的耦合度。
工厂模式的优点在于：
- 将对象的创建和使用分离，降低了系统的耦合度，客户端代码只需要关心抽象产品类和工厂类，而无需关心具体产品类的实现及其创建过程。
- 可以通过工厂方法来控制对象的创建过程，从而灵活地适应不同的需求。
- 可以将对象的创建过程集中在一个工厂类中，便于统一管理和维护。
工厂模式的缺点在于：
- 增加了系统的复杂度，引入了新的类和接口，增加了代码量和理解难度。
- 工厂类需要知道所有具体产品类的实现细节，当具体产品类发生变化时，可能需要修改工厂类的代码。
- 工厂模式可能会导致系统中类的数量增加，增加了系统的维护成本。
总的来说，工厂模式是一种非常常用的设计模式，它可以方便地创建对象，降低系统的耦合度，提高代码的可维护性。在实际开发中，可以根据具体情况选择不同的工厂模式来解决问题，比如简单工厂模式、工厂方法模式、抽象工厂模式等。
