Java 提供了两种主要的转换方式：隐式转换（自动类型提升）和显式转换（强制类型转换），它们的处理方式在符号扩展方面有根本性的不同。

隐式转换（自动类型提升）

当你在表达式中使用一个 byte 类型的值，并且它的目标类型是 long 时，Java 会自动进行转换。

语法：

long longValue = byteValue; // 直接赋值
longValue = someLongCalculation + byteValue; // 在表达式中使用

核心特点：符号扩展

这是隐式转换最关键的一点，因为 Java 是一种强类型的语言，它需要保持数值的符号不变。

• 如果原始的 byte 值是正数（最高位为 0），它在转换为 long 时，会在高位（左侧）填充 0。
• 如果原始的 byte 值是负数（最高位为 1），它在转换为 long 时，会在高位（左侧）填充 1。

这个过程叫做符号扩展，确保了数值在转换前后其代数意义（正负）保持不变。

示例代码：

public class ByteToLongImplicit {
    public static void main(String[] args) {
        byte positiveByte = 10;    // 二进制: 00001010
        byte negativeByte = -10;   // 二进制: 11110110 (补码表示)
        // 隐式转换
        long positiveLong = positiveByte;
        long negativeLong = negativeByte;
        System.out.println("原始 byte (正数): " + positiveByte);
        System.out.println("隐式转换后 long: " + positiveLong);
        System.out.println("原始 byte 的二进制: " + Integer.toBinaryString(positiveByte & 0xFF)); // 显示8位
        System.out.println("转换后 long 的二进制: " + Long.toBinaryString(positiveLong));
        System.out.println("-----------------------------------");
        System.out.println("原始 byte (负数): " + negativeByte);
        System.out.println("隐式转换后 long: " + negativeLong);
        System.out.println("原始 byte 的二进制: " + Integer.toBinaryString(negativeByte & 0xFF)); // 显示8位
        System.out.println("转换后 long 的二进制: " + Long.toBinaryString(negativeLong));
    }
}

输出结果：

原始 byte (正数): 10
隐式转换后 long: 10
原始 byte 的二进制: 00001010
转换后 long 的二进制: 1010  // 高位自动补0
-----------------------------------
原始 byte (负数): -10
隐式转换后 long: -10
原始 byte 的二进制: 11110110
转换后 long 的二进制: 11111111111111111111111111110110 // 高位自动补1，保持负数

从输出可以看出，负数 -10 转换为 long 后，其 64 位表示的高 56 位都是 1,这就是符号扩展。

显式转换（强制类型转换）

显式转换通常用于当你想将一个 long 类型的值截断为 byte 类型时，语法是 (目标类型)值。

语法：

long someLong = 130L;
byte byteValue = (byte) someLong; // 将 long 强制转换为 byte

如何用于 byte 转 long？

虽然 (byte)longValue 是将 long 转为 byte，但如果你想把一个 byte 当作一个无符号的值来处理，并放入 long 中,显式转换的思路就派上用场了。

核心特点：处理无符号值

byte 类型本身是有符号的，范围是 -128 到 127，但有时我们想把它当作一个 0 到 255 的无符号值来处理，这时,隐式转换会因为符号扩展而出问题。

byte b = (byte) 200; 的值是 -56，如果我们直接隐式转换，long l = b; 得到的会是 -56，而不是我们期望的 200。

要得到 200，我们需要一个中间步骤：先将 byte 提升到 int，并在这个过程中丢弃符号位，然后再将 int 赋给 long。

使用 & 运算符（推荐）

这是最常用、最安全、最清晰的方法，通过与 0xFF（二进制 11111111）进行按位与运算，可以有效地将 byte 的 8 位“复制”到 int 的低 8 位，并将高 24 位清零，从而得到一个 0-255 之间的 int 值，之后再赋给 long，高位自然就是 0 了。

public class ByteToLongExplicit {
    public static void main(String[] args) {
        byte signedByte = -10; // 这个值在内存中是 11110110
        // 我们想把它当作无符号的 246 来处理
        // 隐式转换（得到的是 -10）
        long implicitResult = signedByte;
        System.out.println("隐式转换结果 (有符号): " + implicitResult); // 输出: -10
        // 显式转换（得到的是 246）
        // 1. signedByte & 0xFF: 先将 byte 提升到 int，并与 0xFF (255) 做与运算
        //    结果是一个 0-255 之间的 int 值 246
        // 2. (long) ... : 再将这个 int 值赋给 long
        long explicitResult = (long) (signedByte & 0xFF);
        System.out.println("显式转换结果 (无符号): " + explicitResult); // 输出: 246
    }
}

使用 Byte.toUnsignedLong() (Java 8+)

Java 8 引入了一个专门的方法来处理这种情况，这是最符合语义、最推荐的方式。

public class ByteToLongUnsigned {
    public static void main(String[] args) {
        byte signedByte = -10;
        // 使用 JDK 提供的专门方法
        long unsignedValue = Byte.toUnsignedLong(signedByte);
        System.out.println("Byte.toUnsignedLong() 结果: " + unsignedValue); // 输出: 246
    }
}

总结与选择

何时使用哪种？

• 绝大多数情况下，你都应该使用隐式转换 long l = b;。 这是最自然的方式，因为它保持了 byte 原本的数学意义，如果你在处理有符号的数学运算，或者从文件/网络中读取数据时,这是正确的选择。

• 当你明确地将 byte 作为一个 8 位的无符号字节（网络协议、文件格式、位掩码）来处理时，才需要使用显式转换。 这时，请优先使用 Byte.toUnsignedLong(b)，因为它代码意图最明确，次选是 b & 0xFF，它在 Java 8 之前是标准做法,至今仍然有效。