Java中如果新增，到账，支出都用一个接口，如何让走了新增审核后走到账，不会让新增界面出现具体代码怎么写

以下是一个简单的示例代码，展示了如何使用状态机实现上述功能：

// 定义状态枚举类型
enum State {
    NEW, // 新增
    PENDING_APPROVAL, // 待审核
    PENDING_PAYMENT, // 待到账
    PENDING_EXPENSE, // 待支出
    COMPLETED // 已完成
}

// 定义操作接口
interface Operation {
    void execute();
}

// 定义新增操作类
class NewOperation implements Operation {
    private State nextState;

    public NewOperation(State nextState) {
        this.nextState = nextState;
    }

    @Override
    public void execute() {
        // 执行新增操作
        // ...

        // 设置下一个状态
        state = nextState;
    }
}

// 定义审核操作类
class ApprovalOperation implements Operation {
    private State nextState;

    public ApprovalOperation(State nextState) {
        this.nextState = nextState;
    }

    @Override
    public void execute() {
        // 执行审核操作
        // ...

        // 设置下一个状态
        state = nextState;
    }
}

// 定义到账操作类
class PaymentOperation implements Operation {
    private State nextState;

    public PaymentOperation(State nextState) {
        this.nextState = nextState;
    }

    @Override
    public void execute() {
        // 执行到账操作
        // ...

        // 设置下一个状态
        state = nextState;
    }
}

// 定义支出操作类
class ExpenseOperation implements Operation {
    private State nextState;

    public ExpenseOperation(State nextState) {
        this.nextState = nextState;
    }

    @Override
    public void execute() {
        // 执行支出操作
        // ...

        // 设置下一个状态
        state = nextState;
    }
}

// 定义状态机类
class StateMachine {
    private State state;

    public StateMachine() {
        this.state = State.NEW;
    }

    public void execute(Operation operation) {
        switch (state) {
            case NEW:
                if (operation instanceof NewOperation) {
                    operation.execute();
                } else {
                    throw new IllegalStateException("Invalid operation");
                }
                break;
            case PENDING_APPROVAL:
                if (operation instanceof ApprovalOperation) {
                    operation.execute();
                } else {
                    throw new IllegalStateException("Invalid operation");
                }
                break;
            case PENDING_PAYMENT:
                if (operation instanceof PaymentOperation) {
                    operation.execute();
                } else {
                    throw new IllegalStateException("Invalid operation");
                }
                break;
            case PENDING_EXPENSE:
                if (operation instanceof ExpenseOperation) {
                    operation.execute();
                } else {
                    throw new IllegalStateException("Invalid operation");
                }
                break;
            case COMPLETED:
                throw new IllegalStateException("Operation already completed");
        }
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        StateMachine stateMachine = new StateMachine();

        // 执行新增操作
        stateMachine.execute(new NewOperation(State.PENDING_APPROVAL));

        // 执行审核操作
        stateMachine.execute(new ApprovalOperation(State.PENDING_PAYMENT));

        // 执行到账操作
        stateMachine.execute(new PaymentOperation(State.PENDING_EXPENSE));

        // 执行支出操作
        stateMachine.execute(new ExpenseOperation(State.COMPLETED));
    }
}

在上述代码中，使用了状态机来管理操作的状态转移，每个操作都对应着一个操作类，并且每个操作类都包含了下一个状态。当执行一个操作时，状态机会根据当前状态来判断操作是否合法，并且执行操作并更新状态。需要注意的是，上述代码只是一个简单的示例，实际应用中需要根据具体业务逻辑进行修改和完善。