Builder模式的应用

因为AI，所以deepseek

想要实现的效果，

根据第一个operateTarget参数，决定后面targetData、targetDataII可以放入的参数值

//根据operateTarget参数，决定后面targetData、targetDataII可以放入的参数值
operateTarget   0x01   0x02     0x03    0x04    0x05
targetData      1-6    20|0f    20|0f   20|0f   20|0f
targetDataII    00      00      00      00      1-60

于是，有了这样的答案：

public class TankTestParams {
    private final int operateTarget;//都是十进制数，
    private final int targetData;//都是十进制数
    private final int targetDataII;//都应该是十进制数

    private TankTestParams(Builder builder) {
        this.operateTarget = builder.operateTarget;
        this.targetData = builder.targetData;
        this.targetDataII = builder.targetDataII;
        validate();
    }

    private void validate() {
        switch (operateTarget) {
            case 0x01:
                validateForType1();
                break;
            case 0x02:
            case 0x03:
            case 0x04:
                validateForType2_4();
                break;
            case 0x05:
                validateForType5();
                break;
            default:
                throw new IllegalArgumentException("无效的操作目标");
        }
    }

    private void validateForType1() {
        if (targetData < 1 || targetData > 6) {
            throw new IllegalArgumentException("targetData超出范围 1-6");
        }
        if (targetDataII != 0x00) {
            throw new IllegalArgumentException("targetDataII必须为0");
        }
    }

    private void validateForType2_4() {
        if (targetData != 0x20 && targetData != 0x0f) {
            throw new IllegalArgumentException("targetData必须为0x20或0x0f");
        }
        if (targetDataII != 0x00) {
            throw new IllegalArgumentException("targetDataII必须为0");
        }
    }

    private void validateForType5() {
        if (targetData != 0x20 && targetData != 0x0f) {
            throw new IllegalArgumentException("targetData必须为0x20或0x0f");
        }
        if (targetDataII < 1 || targetDataII > 60) {
            throw new IllegalArgumentException("targetDataII超出范围 1-60");
        }
    }

    // Builder模式
    public static class Builder {
        private final int operateTarget;
        private int targetData = 0;
        private int targetDataII = 0;

        public Builder(int operateTarget) {
            this.operateTarget = operateTarget;
        }

        /**
         * 十六进制->十进制
         * 20    -> 32
         * 0f    -> 15
         * @param targetData
         * @return
         */
        public Builder targetData(int targetData) {
            this.targetData = targetData;
            return this;
        }

        public Builder targetDataII(int targetDataII) {
            this.targetDataII = targetDataII;
            return this;
        }

        public TankTestParams build() {
            return new TankTestParams(this);
        }
    }

    // Getters
    public int getOperateTarget() { return operateTarget; }
    public int getTargetData() { return targetData; }
    public int getTargetDataII() { return targetDataII; }
}


/*
// 使用方法
public static String testing4Tank(TankTestParams params) {
    // 直接使用已验证的参数
    return executeTest(params.getOperateTarget(),
            params.getTargetData(),
            params.getTargetDataII());
}

// 调用示例
String result = testing4Tank(
        new TankTestParams.Builder(0x01)
                .targetData(3)
                .targetDataII(0x00)
                .build()
);
//一旦传入的数据不符合，就会抛出异常提示


 */