詳細解析java中Byte類別的源碼--步驟詳情

今天來剖析java.lang.Byte類別的源碼，直奔主題 

首先

public final class Byte extends Number implements Comparable<Byte> {
public static final byte   MIN_VALUE = -128;
public static final byte   MAX_VALUE = 127;
public static final int SIZE = 8;
public static final int BYTES = SIZE / Byte.SIZE;
    @SuppressWarnings("unchecked")
    public static final Class<Byte>     TYPE = (Class<Byte>) Class.getPrimitiveClass("byte");

第一句Byte類別被final修飾，不能被繼承，繼承了Number類，可以用於數字類型的一系列轉換實現了Comparable接口，可以用於比較 
第二句和第三句定義了最小值和最大值 
第四句定義了Byte的大小，為8個位，即一個字節 
第五句給出了字節，即SIZE/Byte.SIZE = 1;佔一個字節 
被註解為對警告保持靜默的這句話是取得該類別的原始類別

    public Byte(byte value) {
        this.value = value;
    }
    public Byte(String s) throws NumberFormatException {
        this.value = parseByte(s, 10);
    }

Byte類別的兩個建構器，這裡有限制，傳入的value必須是byte類型的值，字串s必須是可以轉換為數字的字串，不然會報錯

    public static String toString(byte b) {
        return Integer.toString((int)b, 10);
    }
    public String toString() {
        return Integer.toString((int)value);
    }
    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));
        }
    }

• 接下來是toString方法，將byte型別轉換成字串，裡面用到了Integer類別中的方法 

下面ByteCache方法是定義了一個Byte的快取值，將-128~127寫入到一個cache數組，當在這個區間的時候，JVM會直接使用快取值，但是當超過這個區間的話，會發生溢出的現象，就像上一篇提到的那樣，128會變成-128，會從最小值繼續循環計算

parseByte將字串類型解析為byte類型，radix是基數，radix是幾，s就是幾進制數，解析完結果是十進制數

    public static Byte valueOf(byte b) {
        final int offset = 128;
        return ByteCache.cache[(int)b + offset];
    }
    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);
    }

將傳入參數的值轉換為Byte類型，這裡就是直接從緩存裡面取，掛參數radix的方法是先將字串解析成十進制然後再進行valueOf

    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);
    }

這是一個解碼轉碼方法，以前的方法不是這樣寫的，現在是直接呼叫了Integer類別的decode方法，然後再判斷是否小於最小值或大於最大值，然後再轉換成byte類型返回，這下子真的應了那句話「java裡面不存在byte類型」了

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

這些是強制類型轉換的一些方法，特變簡單，但是還是寫上了

    @Override
    public int hashCode() {
        return Byte.hashCode(value);
    }
    public static int hashCode(byte value) {
        return (int)value;
    }

第一個hashCode是重寫了Object的hasnCode方法，用於兩個值進行比較，hashCode方法經常和equals方法進行區別，尤其是面試的時候，這個現在不詳細講解， hashCode方法大多被用在集合那一塊

    public boolean equals(Object obj) {
        if (obj instanceof Byte) {
            return value == ((Byte)obj).byteValue();
        }
        return false;
    }

equals方法，現在是進行值得比較。

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

比較方法，如果x > y，回傳一個正數，如果x = y，回傳0。如果x < y，回傳負數

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

將byte型別轉換為無符號的int型別與long型別

private static final long serialVersionUID = -7183698231559129828L;

• 序列化的時候用到的，現在不多講解，我也搞不太明白序列化的過程。 。 。 。

#相關文章：

#java int轉byte和long轉byte

解析java 中的Buffer原始碼

#

以上是詳細解析java中Byte類別的源碼--步驟詳情的詳細內容。更多資訊請關注PHP中文網其他相關文章！