设计模式在项目中的使用

场景一（工厂模式-创建型模式）

根据id创建对应的对象，对对象进行crud操作

场景二（状态模式-行为型模式）

案例，电梯系统，三个状态：关闭、打开、运行

抽象类：

public abstract class ElevatorState {
    public abstract void openDoor();
    public abstract void closeDoor();
    public abstract void run();
}

实现类一：电梯门关闭状态类

public class DoorClosedState extends ElevatorState {
    public void openDoor() {
        System.out.println("Opening door...");
        // 切换到门打开状态
        context.setState(new DoorOpenState());
    }
    
    public void closeDoor() {
        System.out.println("Door is already closed.");
    }
    
    public void run() {
        System.out.println("Running elevator...");
        // 切换到运行状态
        context.setState(new RunningState());
    }
}

实现类二：电梯门打开状态类

public class DoorOpenState extends ElevatorState {
    public void openDoor() {
        System.out.println("Door is already open.");
    }
    
    public void closeDoor() {
        System.out.println("Closing door...");
        // 切换到门关闭状态
        context.setState(new DoorClosedState());
    }
    
    public void run() {
        System.out.println("Cannot run when door is open.");
    }
}

实现类三：电梯运行状态类

public class RunningState extends ElevatorState {
    public void openDoor() {
        System.out.println("Cannot open door while running.");
    }
    
    public void closeDoor() {
        System.out.println("Cannot close door while running.");
    }
    
    public void run() {
        System.out.println("Elevator is already running.");
    }
}

电梯类：

public class Elevator {
    private ElevatorState currentState;
    
    public Elevator() {
        // 初始状态为门关闭状态
        this.currentState = new DoorClosedState();
    }
    
    public void setState(ElevatorState state) {
        this.currentState = state;
    }
    
    public void openDoor() {
        currentState.openDoor();
    }
    
    public void closeDoor() {
        currentState.closeDoor();
    }
    
    public void run() {
        currentState.run();
    }
}

测试类：

public class Main {
    public static void main(String[] args) {
        Elevator elevator = new Elevator();
        
        elevator.openDoor();  // 输出："Opening door..."
        elevator.closeDoor(); // 输出："Closing door..."
        elevator.run();       // 输出："Running elevator..."
        
        elevator.openDoor();  // 输出："Opening door..."
        elevator.run();       // 输出："Cannot run when door is open."
        
        elevator.closeDoor(); // 输出："Closing door..."
        elevator.closeDoor(); // 输出："Door is already closed."
    }
}

场景三（策略模式-行为型模式）

案例：有一个电商平台，针对不同的用户类型（如普通用户、VIP用户、企业用户），提供不同的折扣策略。在这种情况下，可以使用策略模式来实现不同用户类型的折扣计算

抽象策略接口-计算折扣

public interface DiscountStrategy {
    double calculateDiscount(double originalPrice);
}

普通用户、VIP用户、企业用户策略类：

public class NormalDiscountStrategy implements DiscountStrategy {
    @Override
    public double calculateDiscount(double originalPrice) {
        // 普通用户折扣计算逻辑
        return originalPrice * 0.9;
    }
}

public class VipDiscountStrategy implements DiscountStrategy {
    @Override
    public double calculateDiscount(double originalPrice) {
        // VIP用户折扣计算逻辑
        return originalPrice * 0.8;
    }
}

public class EnterpriseDiscountStrategy implements DiscountStrategy {
    @Override
    public double calculateDiscount(double originalPrice) {
        // 企业用户折扣计算逻辑
        return originalPrice * 0.7;
    }
}

订单类-使用折扣：

public class Order {
    private DiscountStrategy discountStrategy;

    public void setDiscountStrategy(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }

    public double calculateTotalPrice(double originalPrice) {
        double discountPrice = discountStrategy.calculateDiscount(originalPrice);
        return discountPrice;
    }
}

测试类

public class Main {
    public static void main(String[] args) {
        Order order = new Order();
        
        // 普通用户
        order.setDiscountStrategy(new NormalDiscountStrategy());
        double totalPrice = order.calculateTotalPrice(100);
        System.out.println("普通用户折扣后的总价：" + totalPrice);

        // VIP用户
        order.setDiscountStrategy(new VipDiscountStrategy());
        totalPrice = order.calculateTotalPrice(100);
        System.out.println("VIP用户折扣后的总价：" + totalPrice);

        // 企业用户
        order.setDiscountStrategy(new EnterpriseDiscountStrategy());
        totalPrice = order.calculateTotalPrice(100);
        System.out.println("企业用户折扣后的总价：" + totalPrice);
    }
}

场景四（外观模式-结构型模式）

子系统1,2,3

// 子系统1
class Subsystem1 {
    public void operation1() {
        System.out.println("Subsystem1 operation");
    }
}

// 子系统2
class Subsystem2 {
    public void operation2() {
        System.out.println("Subsystem2 operation");
    }
}

// 子系统3
class Subsystem3 {
    public void operation3() {
        System.out.println("Subsystem3 operation");
    }
}

外观类：

// 外观类
class Facade {
    private Subsystem1 subsystem1;
    private Subsystem2 subsystem2;
    private Subsystem3 subsystem3;

    public Facade() {
        subsystem1 = new Subsystem1();
        subsystem2 = new Subsystem2();
        subsystem3 = new Subsystem3();
    }

    public void operation() {
        subsystem1.operation1();
        subsystem2.operation2();
        subsystem3.operation3();
    }
}

测试类：

// 客户端
public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.operation();
    }
}