JDK源码分析：Byte.java

　　Byte是基本数据类型byte的包装类。

　　1）声明部分：

public final class Byte extends Number implements Comparable<Byte>

　　实现Comparable<T>接口，实现该接口方法如下：

public int compareTo(Byte anotherByte) {
    return compare(this.value, anotherByte.value);
}
public static int compare(byte x, byte y) {
    return x - y;
}

　　继承Number.java，方法如下：

public abstract int intValue();
public abstract float floatValue();
public abstract long longValue();
public abstract double doubleValue();
public byte byteValue() {
    return (byte)intValue();
}
public short shortValue() {
    return (short)intValue();
}

　　其中前4个是抽象方法，Byte.java不是抽象类，所以必须实现父类的4个抽象方法；后2个方法实现调用第一个方法。Number提供了包装类型之间的强类型转换（JDK目前已经实现了自动拆箱和装箱操作）。

　　2）属性部分

//min value
public static final byte   MIN_VALUE = -128; 
//max value
public static final byte   MAX_VALUE = 127;
//The {@code Class} instance representing the primitive type
public static final Class<Byte>     TYPE = (Class<Byte>) Class.getPrimitiveClass("byte");
//The value of the {@code Byte}.
private final byte value;
//The number of bits used to represent a {@code byte} value in two's complement binary form.
public static final int SIZE = 8;
//The number of bytes used to represent a {@code byte} value in two's complement binary form.
public static final int BYTES = SIZE / Byte.SIZE;

　　3）私有内部静态类

//Byte Cache -128~127
private static class ByteCache {
    private ByteCache(){}  

    static final Byte cache[] = new Byte[-(-128) + 127 + 1];  

    static {
        for(int i = 0; i < cache.length; i++)
            cache[i] = new Byte((byte)(i - 128));
    }
}

　　含有静态模块，class加载的时候，执行静态模块，初始化cache[]。

　　4）Byte的声明

　　构造方法重载：

//构造方法重载1
public Byte(byte value) {
    this.value = value;
}
//构造方法重载2
public Byte(String s) throws NumberFormatException {
    this.value = parseByte(s, 10);
}

　　类型转换为Byte的方法,除了构造方法和自动装箱外：　

public static Byte valueOf(byte b) {
    final int offset = 128;
    return ByteCache.cache[(int)b + offset];
}
public static byte parseByte(String s, int radix)
    throws NumberFormatException {
    int i = Integer.parseInt(s, radix);
    if (i < MIN_VALUE || i > MAX_VALUE)
        throw new NumberFormatException(
            "Value out of range. Value:\"" + s + "\" Radix:" + radix);
    return (byte)i;
}
public static byte parseByte(String s) throws NumberFormatException {
    return parseByte(s, 10);
}
public static Byte valueOf(String s, int radix)
    throws NumberFormatException {
    return valueOf(parseByte(s, radix));
}
public static Byte valueOf(String s) throws NumberFormatException {
    return valueOf(s, 10);
}

　　观察这几个方法，public static Byte valueOf(byte b)和public static byte parseByte(String s, int radix)是核心。第2个方法转换为byte；第一个方法转换为Byte，Byte根据byte的值，从缓存中获取Byte对象。

　　例子：

//构造方法重载
byte byte1 = 1;
Byte b1 = new Byte(byte1);
Byte b2 = new Byte("1");
Byte b3 = byte1;//自动装箱
out(b1==b2);//fasle
out(b1==b3);//fasle
//初始化方法，除构造方法和自动装箱
Byte b4 = Byte.parseByte("1",10);//最终byte自动装箱
Byte b5 = Byte.parseByte("1");//同上
Byte b6 = Byte.valueOf("1",10);//最终取ByteCache
Byte b7 = Byte.valueOf("1");//同上
Byte b8 = Byte.valueOf(byte1);//同上
out(b4==b2);//fasle
out(b4==b1);//fasle
out(b4==b3);//true
out(b4==b5);//true
out(b6==b7);//true
out(b6==b8);//true

　　从例子可以得出结论：采用自动装箱会默认根据byte值去获取ByteCache，而使用构造方法重载不会去获取ByteCache，而是生成一个新的对象，所以byte声明的时候，要采用直接装箱，或者除了new一个对象以外的方法。
　　5）其他方法：

public static String toString(byte b) {
    return Integer.toString((int)b, 10);
}
public String toString() {
    return Integer.toString((int)value);
}  

//decode 解码，将（2,8,16）进制转换为十进制
public static Byte decode(String nm) throws NumberFormatException {
    int i = Integer.decode(nm);
    if (i < MIN_VALUE || i > MAX_VALUE)
        throw new NumberFormatException(
                "Value " + i + " out of range from input " + nm);
    return valueOf((byte)i);
}  

@Override
public int hashCode() {
    return Byte.hashCode(value);
}
public static int hashCode(byte value) {
    return (int)value;
}
public boolean equals(Object obj) {
    if (obj instanceof Byte) {
        return value == ((Byte)obj).byteValue();
    }
    return false;
}  

public static int toUnsignedInt(byte x) {
    return ((int) x) & 0xff;
}
public static long toUnsignedLong(byte x) {
    return ((long) x) & 0xffL;
}

　　例子：

//其他方法
Byte.toString(byte1);//1
b8.toString();//1
b8.hashCode();//1
Byte.decode("0x8");//8
b4.equals(b2);//true
byte byte2 = -1;
Byte.toUnsignedInt(byte1);//1
Byte.toUnsignedLong(byte1);//1
Byte.toUnsignedInt(byte2);//255 强转为int的-1，-1的二进制补码：1111,1111,1111,1111,1111,1111,1111,1111，进行& 0xff，截取byte表示8位以外的其他高位。
Byte.toUnsignedLong(byte2);//255