Byte源码解析

说明：

Byte类在一个对象中包含一个基本类型byte的值。 类型为Byte的对象包含一个单一字段，其类型为byte 。此外，该类还提供了一些将byte转换为String和String转换为byte ，以及在处理byte时有用的其他常量和方法。

类图结构：

源码解析：

public final class Byte extends Number implements Comparable<Byte> {

/**
* byte 数据类型是8位、有符号的，以二进制补码表示的整数：最小值  -2^7
 */
public static final byte   MIN_VALUE = -128;

/**
* byte 数据类型是8位、有符号的，以二进制补码表示的整数：最大值 2^7-1。 
 */
public static final byte   MAX_VALUE = 127;

/**
 * The {@code Class} instance representing the primitive type
 * {@code byte}.
 */
@SuppressWarnings("unchecked")
public static final Class<Byte>     TYPE = (Class<Byte>) Class.getPrimitiveClass("byte");

/**
 * 返回一个新的 String对象，代表指定的 byte 。
 */
public static String toString(byte b) {
    return Integer.toString((int)b, 10);
}

/**
 * ByteCache 是Byte的一个内部类，它包含了byte可能值的Byte数组，范围是[-128,127]，并将这范围内的256个值缓存起来。
 */
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));
    }
}

/**
 * 将byte值转化成包装类型Byte
 */
public static Byte valueOf(byte b) {
    final int offset = 128;
    return ByteCache.cache[(int)b + offset];
}

/**  
 * 将字符串参数解析为第二个参数指定的基数中的带符号的byte。          
 */
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;
}

/**
 * 将字符串参数解析为带符号的十进制byte。
 */
public static byte parseByte(String s) throws NumberFormatException {
    return parseByte(s, 10);
}

/**
 * 返回一个 Byte对象，该对象保存从指定的String中 String的值，并使用第二个参数给出的基数进行解析。
 */
public static Byte valueOf(String s, int radix)
    throws NumberFormatException {
    return valueOf(parseByte(s, radix));
}

/**
 * 返回一个 Byte物体保持由指定的给定的值String 。
 */
public static Byte valueOf(String s) throws NumberFormatException {
    return valueOf(s, 10);
}

/**
 * 将 String解码成Byte。
 */
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);
}


private final byte value;

/**
 * 构造一个新分配的 Byte对象，该对象表示指定的 byte值。
 */
public Byte(byte value) {
    this.value = value;
}

/**
 * 构造一个新分配 Byte对象，表示 byte由指示值 String参数。
 */
public Byte(String s) throws NumberFormatException {
    this.value = parseByte(s, 10);
}

/**
 * 将 Byte的值作为byte。
 */
public byte byteValue() {
    return value;
}

/**
 * 返回当前Byte对象对应的byte强转成short。
 */
public short shortValue() {
    return (short)value;
}

/**
 * 返回当前Byte对象对应的byte强转成int。
 */
public int intValue() {
    return (int)value;
}

/**
 * 返回当前Byte对象对应的byte强转成long。
 */
public long longValue() {
    return (long)value;
}

 /**
 * 返回当前Byte对象对应的byte强转成float。
 */
public float floatValue() {
    return (float)value;
}

/**
 * 返回当前Byte对象对应的byte强转成double。
 */
public double doubleValue() {
    return (double)value;
}

public String toString() {
    return Integer.toString((int)value);
}

/**
 * 返回这个Byte的哈希码; 等于调用intValue()的结果。
 */
@Override
public int hashCode() {
    return Byte.hashCode(value);
}

/**
 * 返回一个byte值的哈希码; 兼容Byte.hashCode() 。
 */
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;
}

/**
 * 数字比较两个 Byte对象。
 */
public int compareTo(Byte anotherByte) {
    return compare(this.value, anotherByte.value);
}

/**
 * 数值比较两个byte值。
 */
public static int compare(byte x, byte y) {
    return x - y;
}

/**
 * 将byte x转成无符号整型。先将x转化成int,再和0xffL按位与，如何x是证书，则取x本身；如果是负数，则取它与最低8位的值。
 * @since 1.8
 */
public static int toUnsignedInt(byte x) {
    return ((int) x) & 0xff;
}

/**
 * 将byte x转成无符号long型。
 * @since 1.8
 */
public static long toUnsignedLong(byte x) {
// 先将x转化成int,再和0xffL按位与，如何x是证书，则取x本身；如果是负数，则取它与最低8位的值。
    return ((long) x) & 0xffL;
}

}