使用java开发请假流程，请使用责任链模式

以下是使用Java语言实现请假流程的责任链模式的示例代码：

首先，需要定义一个请假信息类 LeaveRequest，用于存储请假相关的信息：

public class LeaveRequest {
    private String name;
    private int days;
    private String reason;

    public LeaveRequest(String name, int days, String reason) {
        this.name = name;
        this.days = days;
        this.reason = reason;
    }

    public String getName() {
        return name;
    }

    public int getDays() {
        return days;
    }

    public String getReason() {
        return reason;
    }
}

然后，需要定义一个抽象的请假处理器类 LeaveHandler，用于定义处理请假请求的接口和提供处理请求的方法：

public abstract class LeaveHandler {
    protected LeaveHandler nextHandler;

    public LeaveHandler setNextHandler(LeaveHandler handler) {
        this.nextHandler = handler;
        return nextHandler;
    }

    protected abstract void handleRequest(LeaveRequest request);

    protected void printRequest(LeaveRequest request, String handlerName) {
        System.out.println(handlerName + " handles request from " + request.getName() + ": " + 
                request.getDays() + " days" + ", reason: " + request.getReason());
    }
}

接下来，需要定义具体的请假处理器类，包括组长、经理和总经理，它们分别继承于抽象的请假处理器类：

public class GroupLeader extends LeaveHandler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() <= 2) {
            printRequest(request, "GroupLeader");
            System.out.println("Leave request approved by GroupLeader");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("Leave request rejected.");
        }
    }
}

public class Manager extends LeaveHandler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() > 2 && request.getDays() <= 5) {
            printRequest(request, "Manager");
            System.out.println("Leave request approved by Manager");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("Leave request rejected.");
        }
    }
}

public class CEO extends LeaveHandler {
    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getDays() > 5) {
            printRequest(request, "CEO");
            System.out.println("Leave request approved by CEO");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("Leave request rejected.");
        }
    }
}

最后，可以使用一个请假管理器类 LeaveManager 来调用责任链模式处理请假请求。请假管理器类中包含了责任链模式的处理器链：

public class LeaveManager {
    private LeaveHandler handlerChain;

    public LeaveManager() {
        handlerChain = new GroupLeader();
        handlerChain.setNextHandler(new Manager())
                .setNextHandler(new CEO());
    }

    public void handleRequest(LeaveRequest request) {
        handlerChain.handleRequest(request);
    }
}

这样，就可以使用 LeaveManager 来处理请假请求了：

public class LeaveProcess {
    public static void main(String[] args) {
        LeaveManager manager = new LeaveManager();

        LeaveRequest request1 = new LeaveRequest("Alice", 1, "have a fever");
        manager.handleRequest(request1);

        LeaveRequest request2 = new LeaveRequest("Bob", 4, "attend a conference");
        manager.handleRequest(request2);

        LeaveRequest request3 = new LeaveRequest("Cathy", 10, "go on a vacation");
        manager.handleRequest(request3);
    }
}

输出：

GroupLeader handles request from Alice: 1 days, reason: have a fever
Leave request approved by GroupLeader
GroupLeader handles request from Bob: 4 days, reason: attend a conference
Manager handles request from Bob: 4 days, reason: attend a conference
Leave request approved by Manager
CEO handles request from Cathy: 10 days, reason: go on a vacation
Leave request approved by CEO