实现自定义二进制数类加法运算的教程

public class Octet {

    int[] x = new int[8]; // 存储8位二进制数的数组

    // 构造函数：接受一个8位二进制字符串
    Octet(String s){
        if (s.length() != 8) {
            System.out.println("Too few or too many characters");
            // 实际应用中，这里应抛出IllegalArgumentException
            return;
        }
        for (int i = 0; i < 8; i++) {
            // 将字符串从左到右的位映射到数组的从右到左（低位到高位）
            if (s.charAt(i) == '1') {
                x[7 - i] = 1;
            } else {
                x[7 - i] = 0;
            }
        }
    }

    // 将Octet对象转换为二进制字符串
    String octetToString() {
        StringBuilder result = new StringBuilder();
        for (int i = 7; i >= 0; i--) { // 从高位到低位构建字符串
            result.append(x[i]);
        }
        return result.toString();
    }

    // 待实现的加法方法
    // Octet sum(Octet y){ ... }
}

public class Octet {

    int[] x = new int[8];

    Octet(String s){
        if (s.length() != 8) {
            // 抛出异常而非打印错误，更符合API设计规范
            throw new IllegalArgumentException("Binary string must be exactly 8 characters long.");
        }
        for (int i = 0; i < 8; i++) {
            if (s.charAt(i) == '1') {
                x[7 - i] = 1;
            } else if (s.charAt(i) == '0') {
                x[7 - i] = 0;
            } else {
                throw new IllegalArgumentException("Binary string contains non-binary characters.");
            }
        }
    }

    String octetToString() {
        StringBuilder result = new StringBuilder();
        for (int i = 7; i >= 0; i--) { // 从高位到低位构建字符串
            result.append(x[i]);
        }
        return result.toString();
    }

    /**
     * 将当前Octet对象与另一个Octet对象相加，并返回一个新的Octet对象。
     * @param y 另一个Octet对象
     * @return 两个Octet对象之和，以新的Octet对象形式返回。
     * @throws ArithmeticException 如果和超出了8位二进制数的表示范围。
     */
    Octet sum(Octet y){
        // 1. 将当前Octet和参数Octet转换为十进制整数
        // Integer.parseInt(String s, int radix) 方法用于将指定基数的字符串转换为整数
        int o1 = Integer.parseInt(this.octetToString(), 2); // 'this' 指当前对象
        int o2 = Integer.parseInt(y.octetToString(), 2);

        // 2. 执行十进制加法
        int sumDecimal = o1 + o2;

        // 3. 将十进制和转换为二进制字符串
        String binarySum = Integer.toBinaryString(sumDecimal);

        // 4. 处理结果位数
        // 检查是否溢出（超过8位）
        if (binarySum.length() > 8) {
            // 抛出异常，表示结果无法用8位Octet表示
            throw new ArithmeticException("Sum of octets exceeds 8 bits: " + binarySum);
        }

        // 如果结果位数少于8位，则在前面补零
        StringBuilder paddedBinarySum = new StringBuilder(binarySum);
        while (paddedBinarySum.length() < 8) {
            paddedBinarySum.insert(0, "0"); // 在开头插入'0'
        }

        // 5. 构造并返回新的Octet对象
        return new Octet(paddedBinarySum.toString());
    }

    // 示例：添加一个main方法进行测试
    public static void main(String[] args) {
        Octet octet1 = new Octet("00000001"); // 1
        Octet octet2 = new Octet("00000010"); // 2
        Octet octet3 = new Octet("11111111"); // 255
        Octet octet4 = new Octet("00000001"); // 1

        try {
            Octet result1 = octet1.sum(octet2);
            System.out.println("00000001 + 00000010 = " + result1.octetToString()); // 00000011 (3)

            Octet result2 = octet3.sum(octet4);
            System.out.println("11111111 + 00000001 = " + result2.octetToString()); // 00000000 (0, 溢出后取低8位)
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage()); // 预期会捕获溢出错误
        }

        Octet octet5 = new Octet("00000101"); // 5
        Octet octet6 = new Octet("00000011"); // 3
        Octet result3 = octet5.sum(octet6);
        System.out.println("00000101 + 00000011 = " + result3.octetToString()); // 00001000 (8)
    }
}