Octet类概述
在java中，当我们需要处理特定数据结构，例如8位二进制数时，通常会定义一个自定义类。以下是一个表示8位二进制数的octet类骨架，它使用一个int数组来存储二进制位，并提供了从字符串构造以及转换为字符串的方法：
public class Octet {
int[] x = new int[8];
// 构造函数：接受一个8位二进制字符串
public Octet(String s) {
if (s.length() != 8) {
throw new IllegalArgumentException("Input string must be 8 characters long.");
}
for (int i = 0; i < 8; i++) {
char bitChar = s.charAt(i);
if (bitChar == '1') {
x[7 - i] = 1; // 存储时按低位到高位
} else if (bitChar == '0') {
x[7 - i] = 0;
} else {
throw new IllegalArgumentException("Input string must contain only '0' or '1'.");
}
}
}
// 将Octet对象转换为二进制字符串
public String octetToString() {
StringBuilder result = new StringBuilder();
for (int i = 7; i >= 0; i--) { // 从高位到低位构建字符串
result.append(x[i]);
}
return result.toString();
}
// 省略其他可能的方法
}注意： 原始代码中的构造函数在输入长度不匹配时使用了System.out.println并直接返回，这可能导致x数组未完全初始化或状态不确定。在生产环境中，建议抛出异常（如IllegalArgumentException）来明确指示错误。上述代码已对此进行优化。同时，octetToString方法也调整为从高位到低位构建字符串，以符合通常的二进制表示习惯。
实现自定义对象加法的挑战
为Octet类实现一个sum方法，使其能够与另一个Octet对象相加并返回一个新的Octet对象，是一个常见的需求。直接对int[]数组进行位操作进行加法虽然可行，但较为复杂，需要处理进位等逻辑。将Octet对象直接转换为字符串进行拼接或尝试直接进行整数加法都会遇到类型不匹配的问题。
解决方案：十进制中转法
最直观且易于实现的方法是利用Java内置的整数转换能力：
- 将两个Octet对象分别转换为它们的十进制整数表示。
- 对这两个十进制整数进行标准的加法运算。
- 将加法结果（十进制整数）转换回8位二进制字符串。
- 使用这个二进制字符串构造一个新的Octet对象并返回。
sum方法的实现步骤详解
下面我们将详细分解sum方法的实现过程。
立即学习“Java免费学习笔记（深入）”；
1. Octet到十进制整数转换
Java的Integer.parseInt(String s, int radix)方法非常适合将指定进制的字符串转换为十进制整数。我们需要先调用octetToString()方法获取二进制字符串，然后指定基数2进行转换。
// 获取当前Octet对象的十进制值 int o1Decimal = Integer.parseInt(this.octetToString(), 2); // 获取参数Octet对象的十进制值 int o2Decimal = Integer.parseInt(y.octetToString(), 2);
这里的this.octetToString()表示当前Octet实例的二进制字符串，y.octetToString()表示传入的Octet参数的二进制字符串。
2. 执行十进制加法
这一步非常简单，就是标准的整数加法：
int sumDecimal = o1Decimal + o2Decimal;
3. 十进制和到二进制字符串转换
使用Integer.toBinaryString(int i)方法可以将十进制整数转换为其二进制字符串表示。
String binarySum = Integer.toBinaryString(sumDecimal);
4. 结果处理与规范化
这是关键的一步，因为Integer.toBinaryString()方法不会自动补齐前导零，并且如果和超过8位，我们需要进行溢出处理。
-
溢出检查： 一个8位二进制数能表示的最大十进制值是255（即11111111）。如果sumDecimal超过这个范围，或者binarySum的长度大于8，则表示发生了溢出，结果不再是一个有效的Octet。在这种情况下，通常应该抛出一个运行时异常来明确指出这个问题。
if (binarySum.length() > 8) { throw new ArithmeticException("Sum of octets exceeds 8-bit capacity."); } -
补齐前导零： 如果binarySum的长度小于8，我们需要在前面补齐相应数量的零，以确保它始终是8位。StringBuilder是处理字符串拼接和修改的有效工具。
StringBuilder resultBuilder = new StringBuilder(binarySum); while (resultBuilder.length() < 8) { resultBuilder.insert(0, "0"); // 在开头插入'0' } String paddedBinarySum = resultBuilder.toString();
5. 构建新的Octet对象并返回
最后，使用处理好的8位二进制字符串构造一个新的Octet实例并将其返回。
return new Octet(paddedBinarySum);
完整的sum方法实现
将以上步骤整合到Octet类中，形成完整的sum方法：
public class Octet {
int[] x = new int[8];
// 构造函数
public Octet(String s) {
if (s.length() != 8) {
throw new IllegalArgumentException("Input string must be 8 characters long.");
}
for (int i = 0; i < 8; i++) {
char bitChar = s.charAt(i);
if (bitChar == '1') {
x[7 - i] = 1;
} else if (bitChar == '0') {
x[7 - i] = 0;
} else {
throw new IllegalArgumentException("Input string must contain only '0' or '1'.");
}
}
}
// 将Octet对象转换为二进制字符串
public String octetToString() {
StringBuilder result = new StringBuilder();
for (int i = 7; i >= 0; i--) {
result.append(x[i]);
}
return result.toString();
}
// 实现两个Octet对象的加法
public Octet sum(Octet y) {
// 1. 将当前Octet和参数Octet转换为十进制整数
int thisDecimal = Integer.parseInt(this.octetToString(), 2);
int otherDecimal = Integer.parseInt(y.octetToString(), 2);
// 2. 执行十进制加法
int sumDecimal = thisDecimal + otherDecimal;
// 3. 将十进制和转换为二进制字符串
String binarySum = Integer.toBinaryString(sumDecimal);
// 4. 结果处理与规范化
// 检查是否溢出8位
if (binarySum.length() > 8) {
throw new ArithmeticException("Sum of octets exceeds 8-bit capacity. Result: " + binarySum);
}
// 补齐前导零，确保结果是8位
StringBuilder resultBuilder = new StringBuilder(binarySum);
while (resultBuilder.length() < 8) {
resultBuilder.insert(0, "0"); // 在开头插入'0'
}
String paddedBinarySum = resultBuilder.toString();
// 5. 构建新的Octet对象并返回
return new Octet(paddedBinarySum);
}
// 示例：重写toString方法以便于打印
@Override
public String toString() {
return octetToString();
}
public static void main(String[] args) {
try {
Octet oct1 = new Octet("00000001"); // 1
Octet oct2 = new Octet("00000010"); // 2
Octet sum1 = oct1.sum(oct2);
System.out.println("00000001 + 00000010 = " + sum1); // 期望: 00000011 (3)
Octet oct3 = new Octet("11111110"); // 254
Octet oct4 = new Octet("00000001"); // 1
Octet sum2 = oct3.sum(oct4);
System.out.println("11111110 + 00000001 = " + sum2); // 期望: 11111111 (255)
Octet oct5 = new Octet("11111111"); // 255
Octet oct6 = new Octet("00000001"); // 1
// 这将抛出异常，因为 255 + 1 = 256，超出了8位二进制表示范围
Octet sum3 = oct5.sum(oct6);
System.out.println("11111111 + 00000001 = " + sum3);
} catch (IllegalArgumentException e) {
System.err.println("Error creating Octet: " + e.getMessage());
} catch (ArithmeticException e) {
System.err.println("Error during Octet sum: " + e.getMessage());
}
}
}注意事项
-
溢出处理： 上述实现中，当两个Octet的和超过8位二进制所能表示的最大值（255）时，会抛出ArithmeticException。根据实际需求，你也可以选择其他处理方式，例如：
- 返回一个特殊的“溢出”Octet对象。
- 截断结果，只保留低8位（但这会丢失高位信息）。
- 返回一个能够表示更大范围的数值类型（例如，如果需要16位结果，可以返回一个DoubleOctet类）。
- 性能考量： 对于频繁的加法操作，这种十进制中转的方法可能不是最高效的。如果对性能有极高要求，或者需要处理非常大的二进制数，直接在位数组上实现二进制加法（包括进位逻辑）会更高效。然而，对于8位这种小范围的二进制数，当前方法足够简洁和高效。
- 错误处理： 在Octet类的构造函数中，对输入字符串的长度和内容进行严格校验并抛出IllegalArgumentException是良好的编程实践，可以避免后续操作中出现不可预期的行为。
通过以上方法，我们成功地为自定义的Octet类实现了可靠且易于理解的加法运算，使其能够像基本数据类型一样进行操作，并返回符合预期的结果。
