1️⃣类定义
public final class Byte extends Number implements Comparable<Byte>
- 类被声明为final的,表示不能被继承;
- 继承了Number抽象类,可以用于数字类型的一系列转换;
- 实现了Comparable接口,可以用于比较
2️⃣属性
/**
* byte的最小值，也就是-2的7次方
*/
public static final byte MIN_VALUE = -128;
/**
* byte的最大值，也即2的7次方减1
*/
public static final byte MAX_VALUE = 127;
/**
* @SuppressWarnings("unchecked")表示对警告保持静默
* 获取Byte的原始class对象
*/
@SuppressWarnings("unchecked")
public static final Class<Byte> TYPE = (Class<Byte>) Class.getPrimitiveClass("byte");
/**
* Byte对象中具体的byte值，定义为final
*/
private final byte value;
/**
* 用于表示二进制补码二进制形式的字节值的位数(定义了Byte的大小，为8个位，即一个字节)
*/
public static final int SIZE = 8;
/**
* 用于表示二进制补码二进制形式的字节值的字节数(给出了字节，即SIZE/Byte.SIZE = 1;占一个字节)
*/
public static final int BYTES = SIZE / Byte.SIZE;
/**
* 序列化
*/
private static final long serialVersionUID = -7183698231559129828L;
3️⃣构造器
public Byte(byte value) {
this.value = value;
}
/**
* 参数为字符串形式传入的value必须是byte类型的值，字符串s必须是可以转换为数字的字符串，不然会报错
*/
public Byte(String s) throws NumberFormatException {
this.value = parseByte(s, 10);
}
4️⃣内部类
/**
* Byte对象的缓存类
*/
private static class ByteCache {
private ByteCache(){}
/**
* 缓存数组
*/
static final Byte cache[] = new Byte[-(-128) + 127 + 1];
// 缓存初始化，范围是-128到127
static {
for(int i = 0; i < cache.length; i++)
cache[i] = new Byte((byte)(i - 128));
}
}
定义了一个Byte的缓存值，将-128~127写入到一个cache数组，当在这个区间的时候，JVM会直接使用缓存值，但是当超过这个区间的话，会发生溢出的现象，128会变为-128，会从最小值继续循环计算
5️⃣方法
① toString : 注意两次toString调用的Integer.toString()方法不是一个toString();
/**
* 静态toString,底层调用Integer.toString(也是一个静态方法)
* 将byte强转为int值在传入一个默认的基数10()
*/
public static String toString(byte b) {
return Integer.toString((int)b, 10);
}
/**
* 这里是先把byte升级为int，然后用Integer的toString静态方法
*/
public String toString() {
return Integer.toString((int)value);
}
② valueOf
/**
* 封装基础byte到Byte对象，其实就是从缓存数组中取出对应的值
* 在这里使用到了上边定义的内部类
*/
public static Byte valueOf(byte b) {
final int offset = 128;
return ByteCache.cache[(int)b + offset];
}
/**
* 重载方法 : 将字符串根据指定的基数包装成Byte对象
*/
public static Byte valueOf(String s, int radix)
throws NumberFormatException {
return valueOf(parseByte(s, radix));
}
/**
* 重载方法 : 将字符串根据十进制包装成Byte对象实际调用的是valueOf(String s, int radix)
* 这个重载方法,默认的基数为10
*/
public static Byte valueOf(String s) throws NumberFormatException {
return valueOf(s, 10);
}
③ parseByte
/**
* 将字符串根据指定的基数格式化成基础byte,字符串可以包含数组和字母基数最大为36;
* 另外需要注意的是这个方法将在源码中被多次调用
*/
public static byte parseByte(String s, int radix)
throws NumberFormatException {
// 调用了Integer的格式化方法
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;
}
/**
* 重载的方法实际调用的是parseByte(String s, int radix),传入的基数默认为10
*/
public static byte parseByte(String s) throws NumberFormatException {
return parseByte(s, 10);
}
④ decode
/**
* 将2进制或者是8进制或者是16进制的字符串转成封装成Byte对象
*/
public static Byte decode(String nm) throws NumberFormatException {
// 调用Integer.decode()进行处理
int i = Integer.decode(nm);
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException(
"Value " + i + " out of range from input " + nm);
// 将处理结果的值进行强转调用valueOf(byte b);
return valueOf((byte)i);
}
⑤ 来自于继承类的方法
/**
* 获取Byte对象的byte值，继承自Number方法
*/
public byte byteValue() {
return value;
}
/**
* 将当前对象强转成short，继承自Number方法
*/
public short shortValue() {
return (short) value;
}
/**
* 将当前对象强转成int，继承自Number方法
*/
public int intValue() {
return (int) value;
}
/**
* 将当前对象强转成long，继承自Number方法
*/
public long longValue() {
return (long) value;
}
/**
* 将当前对象强转成float，继承自Number方法
*/
public float floatValue() {
return (float) value;
}
/**
* 将当前对象强转成double，继承自Number方法
*/
public double doubleValue() {
return (double) value;
}
⑥ hashCode
/**
* 重写Object中的hashCode,实际调用的是hashCode(byte value)
*/
@Override
public int hashCode() {
return Byte.hashCode(value);
}
/**
* hashCode，静态，byte的hashCode就是它的值
*/
public static int hashCode(byte value) {
return (int)value;
}
⑦ equals : 这个方法就不进行过多的介绍了,实际就行进行类型以及值的判断
public boolean equals(Object obj) {
if (obj instanceof Byte) {
return value == ((Byte)obj).byteValue();
}
return false;
}
⑧ compareTo与compare
/**
* 比较当前对象与指定Byte,实际调用的是compare(byte x, byte y)
*/
public int compareTo(Byte anotherByte) {
return compare(this.value, anotherByte.value);
}
/**
* 比较两个byte
*/
public static int compare(byte x, byte y) {
return x - y;
}
⑨ 转换方法
/**
* 将指定byte转换为无符号int
*/
public static int toUnsignedInt(byte x) {
return ((int) x) & 0xff;
}
/**
* 将指定byte专为无符号long
*/
public static long toUnsignedLong(byte x) {
return ((long) x) & 0xffL;
}
6️⃣总结
- 声明了一个ByteCache内部类用来作为Byte的缓存值
- parseByte(String s, int radix)方法的两个参数,radix参数代表基数radix传入的是几，s就是几进制数，解析完结果是十进制数
- 定义了SIZE和BYTES两个常量来value的字节数和位数;
网友评论