滨州福康环保科技有限公司

条件匹配设计模式是一种在软件开发中常用的设计模式，它通过定义一系列条件和相应的处理逻辑，来实现根据不同条件执行不同操作的目的。这种模式的核心思想是将条件判断与具体操作分离，使得代码更加清晰、可维护和可扩展。条件匹配设计模式通常包括以下几种常见的实现方式：

1. 简单工厂模式（Simple Factory Pattern）

简单工厂模式是一种创建型设计模式，它通过一个工厂类来根据不同的条件创建不同的对象实例。工厂类通常包含一个静态方法，该方法根据传入的参数决定返回哪个具体的产品对象。

案例： 假设我们有一个图形绘制系统，需要根据用户选择的图形类型绘制不同的图形（如圆形、矩形、三角形）。我们可以使用简单工厂模式来实现：

interface Shape {
    void draw();
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

class Triangle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制三角形");
    }
}

class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        } else if (shapeType.equalsIgnoreCase("TRIANGLE")) {
            return new Triangle();
        }
        return null;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("CIRCLE");
        circle.draw();

        Shape rectangle = ShapeFactory.getShape("RECTANGLE");
        rectangle.draw();

        Shape triangle = ShapeFactory.getShape("TRIANGLE");
        triangle.draw();
    }
}

2. 策略模式（Strategy Pattern）

策略模式是一种行为型设计模式，它允许在运行时选择算法或策略。策略模式将不同的算法封装在独立的策略类中，使得它们可以互换使用。通过这种方式，策略模式可以避免大量的条件判断语句。

案例： 假设我们有一个支付系统，支持多种支付方式（如信用卡支付、支付宝支付、微信支付）。我们可以使用策略模式来实现：

interface PaymentStrategy {
    void pay(int amount);
}

class CreditCardStrategy implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("使用信用卡支付" + amount + "元");
    }
}

class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("使用支付宝支付" + amount + "元");
    }
}

class WeChatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("使用微信支付" + amount + "元");
    }
}

class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}

public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        cart.setPaymentStrategy(new CreditCardStrategy());
        cart.checkout(100);

        cart.setPaymentStrategy(new AlipayStrategy());
        cart.checkout(200);

        cart.setPaymentStrategy(new WeChatPayStrategy());
        cart.checkout(300);
    }
}

3. 状态模式（State Pattern）

状态模式是一种行为型设计模式，它允许对象在内部状态改变时改变它的行为。状态模式将不同状态下的行为封装在独立的状态类中，使得状态转换和行为处理更加清晰。

案例： 假设我们有一个电梯控制系统，电梯有多种状态（如开门状态、关门状态、运行状态）。我们可以使用状态模式来实现：

interface ElevatorState {
    void openDoor();
    void closeDoor();
    void move();
}

class OpenState implements ElevatorState {
    @Override
    public void openDoor() {
        System.out.println("门已经打开");
    }

    @Override
    public void closeDoor() {
        System.out.println("关闭门");
    }

    @Override
    public void move() {
        System.out.println("门未关闭，无法移动");
    }
}

class CloseState implements ElevatorState {
    @Override
    public void openDoor() {
        System.out.println("打开门");
    }

    @Override
    public void closeDoor() {
        System.out.println("门已经关闭");
    }

    @Override
    public void move() {
        System.out.println("电梯开始移动");
    }
}

class Elevator {
    private ElevatorState state;

    public void setState(ElevatorState state) {
        this.state = state;
    }

    public void openDoor() {
        state.openDoor();
    }

    public void closeDoor() {
        state.closeDoor();
    }

    public void move() {
        state.move();
    }
}

public class Main {
    public static void main(String[] args) {
        Elevator elevator = new Elevator();

        elevator.setState(new OpenState());
        elevator.openDoor();
        elevator.move();

        elevator.setState(new CloseState());
        elevator.closeDoor();
        elevator.move();
    }
}

4. 责任链模式（Chain of Responsibility Pattern）

责任链模式是一种行为型设计模式，它允许多个对象有机会处理请求，从而避免请求的发送者和接收者之间的耦合。责任链模式将处理请求的对象链接成一条链，请求沿着这条链传递，直到有一个对象处理它为止。

案例： 假设我们有一个请假审批系统，不同级别的领导可以审批不同天数的请假申请。我们可以使用责任链模式来实现：

abstract class Approver {
    protected Approver nextApprover;

    public void setNextApprover(Approver nextApprover) {
        this.nextApprover = nextApprover;
    }

    public abstract void processRequest(LeaveRequest request);
}

class Manager extends Approver {
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getDays() <= 3) {
            System.out.println("经理审批通过请假申请");
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        }
    }
}

class Director extends Approver {
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getDays() <= 7) {
            System.out.println("总监审批通过请假申请");
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        }
    }
}

class CEO extends Approver {
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getDays() > 7) {
            System.out.println("CEO审批通过请假申请");
        }
    }
}

class LeaveRequest {
    private int days;

    public LeaveRequest(int days) {
        this.days = days;
    }

    public int getDays() {
        return days;
    }
}

public class Main {
    public static void main(String[] args) {
        Approver manager = new Manager();
        Approver director = new Director();
        Approver ceo = new CEO();

        manager.setNextApprover(director);
        director.setNextApprover(ceo);

        LeaveRequest request1 = new LeaveRequest(2);
        manager.processRequest(request1);

        LeaveRequest request2 = new LeaveRequest(5);
        manager.processRequest(request2);

        LeaveRequest request3 = new LeaveRequest(10);
        manager.processRequest(request3);
    }
}

总结

条件匹配设计模式通过将条件判断与具体操作分离，使得代码更加清晰、可维护和可扩展。常见的实现方式包括简单工厂模式、策略模式、状态模式和责任链模式。每种模式都有其适用的场景和优势，开发者可以根据具体需求选择合适的模式来解决问题。