摘要：在中存在兩種類型基本類型和引用類型。值得注意的是，基本類型的值的狀態不會被共享。浮點類型和它們的值中的浮點類型遵循標準的定義。布爾類型和它們的值類型表示兩個邏輯量，和。

眾所周知，Java是一門靜態類型的語言，這意味著所有的變量和表達式的類型會在編譯時確定。同時，Java 還是一門強類型的語言，因此變量的值或表達式的結果的類型都會受到限制（比如一個聲明為 String 的變量不的值不可能是一個數值 1），類型之間的運算也會被限制，這有助于在編譯時發現絕大多數的錯誤。

在 Java中存在兩種類型：基本類型和引用類型。

PrimitiveType:
    {Annotation} NumericType
    {Annotation} boolean
    
NumericType:
    IntegralType
    FloatingPointType
    
IntegralType:
    (one of)
    byte short int long char

FloatingPointType:
    (one of)
    float double

Java Language Specification (Java SE 8 Edition)  §4.2 Primitive Types and Values

值得注意的是，基本類型的值的狀態不會被共享。

比如下面這個例子:

int i = 0;
int j = i;
i += 1;
System.out.println(j);

AtomicInteger i = new AtomicInteger(0);
AtomicInteger j = i;
i.addAndGet(1);
System.out.println(j);

上述代碼將輸出:

0
1

整數類型 (IntegralType) 包含了以下五種類型:

比較運算符: <、<=、>、>= 、==、!= ，其結果為 boolean 類型；

數值運算符:

一元運算符: + 、-

乘法運算符: *、/、%

加法運算符: + 、-

自增運算符: ++, 分為前綴自增 (++i) 和后綴自增 (i++)

自減運算符: --, 分為前綴自減 (--i) 和后綴自減 (i--)

位移運算符:

左移運算符: <<

有符號右移: >>

無符號右移: >>>

按位互補運算符: ~

整數按位運算符: &、^、|

條件運算符: ? :

類型轉換運算符: cast

字符串拼接運算符: +

這里面加號出現了好幾次，包括 一元運算符、加法運算符、自增運算符、字符串拼接運算符，后三者運算符就如它們的字面意思般，很好理解。

那么 一元運算符 是什么意思呢？

讓我們來看看下面這份代碼:

static void is (short i) {
    System.out.println("short");
}

static void is (int i) {
    System.out.println("int");
}

static void is (long i) {
    System.out.println("long");
}

static void main (String[] args) {
    short i = 5;
    int j = 10;
    is(i);
    is(+i);
    is(-i);
    is(j);
    is(+j);
    is(-j);
}

上述代碼將輸出:

short
int
int
int
int
int

很顯然，第 17~19 行的調用執行的是參數類型為 int 的方法，然而第 20~21 行的調用執行的并不是參數類型為 long 的方法。

我在 JSL § 15.15.3 Unary Plus Operator + 中并未看出一元運算符的具體影響，根據實驗結果只能推測一元運算符會將低于 int 的數值類型提升到 int 類型 (你可以聲明一個 byte h = 0，is(+h) 仍然會調用參數類型為 int 的方法)，而且對于 + 和 - 都是提升類型的作用，并不是直覺意義上的一個升一個降。

關于這個 一元運算符 的用法其實并不是很多，有下列幾種：

// 如果方法接受的是 int 類型的話，僅僅用來明確這是個正數還是負數。
func(+1);
func(-1);

// 輸出字符的代碼值時的小技巧
// 因為字符類型 char 是低于 int 的整數類型
System.out.println(+"c"); // 99

對于移位運算符以外的整數運算而言，如果兩個操作數中至少有一個 long ，那么這次運算將會按 64位精度進行計算，并且其計算結果也是 long 類型，此時如果另一個操作數不是 long，那么會將它提升到 long 類型再計算；如果兩個操作數都不是 long，那么會按 32位精度進行計算，并且計算結果為 int，如果任何一個操作數不是 int， 那么都將提升到 int 類型后再計算。

整數運算符會在以下情況拋出異常：

涉及到對引用類型拆箱時，如果是空引用，那么會拋出 NullPointerException；

如果右操作數為零，那么整數除法運算符和整數取余運算符都會拋出 ArithmeticException；

在自增和自減的時候，如果涉及到拆箱裝箱且內存不足，會拋出 OutOfMemoryError

來看看規范中給出的示例代碼:

class Test {
    public static void main (String[] args) {
        int i = 1000000;
        System.out.println(i * i);
        long l = i;
        System.out.println(l * l);
        System.out.println(20296 / (l - i));
    }
}

上述代碼將輸出:

-727379968
1000000000000
ArithmeticException

對于 int 來說，1000000^2 太大了，而由于之前的運算規則，i * i 只能保存結果的低32位，十進制下也就是 -727379968。

Java 中的浮點類型遵循 IEEE 754 標準的定義。

IEEE 754-1985 - Wikiwand
IEEE 754_百度百科

在 IEEE 754 標準中，定義了 32位精度的 float、64位精度的 double，還有正負數、正負0、正負無窮和特殊的 NaN。

NaN 用于表示無效操作的結果，比如 0.0 / 0.0 (0 / 0 才適用整數運算中的 右操作數為0 的異常規則)，你可以在 Float.NaN 和 Double.NaN 中找到。

NaN 是無序的，因此

如果一次運算中一個或兩個操作數都是 NaN，則比較運算符 (<、<=、>、>=) 都會返回 false

如果操作數是 NaN，則相等運算符 (==) 返回 false

如果 x 或 y 是 NaN，則 (x < y) == !(x >= y) 將返回 false

如果任一操作數是 NaN, 則不等式運算符 != 將返回 true

當且僅當 x 為 NaN 時，x != x 將返回 true

比較運算符: <、<=、>、>= 、==、!= ，其結果為 boolean 類型；

數值運算符:

一元運算符: + 、-

乘法運算符: *、/、%

加法運算符: + 、-

自增運算符: ++, 分為前綴自增 (++i) 和后綴自增 (i++)

自減運算符: --, 分為前綴自減 (--i) 和后綴自減 (i--)

條件運算符: ? :

類型轉換運算符: cast

字符串拼接運算符: +

如果一次計算中，至少有一個二元運算符的操作數是浮點類型的，那么該操作就是一個浮點運算，即使另一個操作數是整數。

System.out.println(10 * 0.1); // 1.0

對于浮點運算而言，如果兩個操作數中至少有一個 double，那么這次運算將會按 64位精度進行計算，并且其計算結果也是 double 類型，此時如果另一個操作數不是 double，那么會將它提升到 double 類型再計算；如果兩個操作數都不是 double，那么會按 32位精度進行計算，并且計算結果為 float，如果任何一個操作數不是 float， 那么都將提升到 float 類型后再計算。

浮點運算有溢出 (overflows) 和下溢 (underflows)，其中溢出將產生有符號的無窮大，而下溢則產生一個非標準化 (denormalized) 的值或是一個有符號的0。

數學上無法確定結果的浮點運算將產生 NaN。

所有 NaN 參與的浮點運算都會產生 NaN。

在下列情況中，浮點運算會拋出異常：

計算時需要拆箱，而又是個空引用時，會拋出 NullPointerException；

自增自減的情況下，如果需要拆箱裝箱且內存不夠時，會拋出 OutOfMemoryError。

接下來看看規范中給出的示例代碼:

class Test {
    public static void main(String[] args) {
        // 溢出
        double d = 1e308;
        System.out.print("溢出產生了無窮大: ");
        System.out.println(d + "*10==" + d*10);
        // 漸變下溢 (gradual underflow)
        d = 1e-305 * Math.PI;
        System.out.print("漸變下溢: " + d + "
   ");
        for (int i = 0; i < 4; i++)
            System.out.print(" " + (d /= 100000) + "
");
        System.out.println();
        // 產生 NaN
        System.out.print("0.0/0.0 產生的不是數字: ");
        d = 0.0/0.0;
        System.out.println(d);
        // 產生不精確結果的四舍五入:
        System.out.print("單精度下的不精確結果:");
        for (int i = 0; i < 100; i++) {
            float z = 1.0f / i;
            if (z * i != 1.0f)
                System.out.print(" " + i);
        }
        System.out.println();
        // 另一個產生不精確結果的四舍五入:
        System.out.print("雙精度下的不精確結果:");
        for (int i = 0; i < 100; i++) {
            double z = 1.0 / i;
            if (z * i != 1.0)
                System.out.print(" " + i);
        }
        System.out.println();
        // 轉換到整數時發生的結果階段:
        System.out.print("強制轉換到整數: ");
        d = 12345.6;
        System.out.println((int)d + " " + (int)(-d));
    }
}

上述代碼將輸出

溢出產生了無窮大: 1.0e + 308 * 10 == Infinity
漸變下溢: 3.141592653589793E-305
 3.1415926535898E-310
 3.141592653E-315
 3.142E-320 0.0
 0.0 / 0.0 產生的不是數字：NaN
單精度下的不精確結果：0 41 47 55 61 82 83 94 97
雙精度下的不精確結果：0 49 98
強制轉換到整數：12345 -12345

值得注意的是，在 漸變下溢 的例子中，我們可以看到精度逐漸喪失。

boolean 類型表示兩個邏輯量，true 和 false。

布爾運算符是：

關系運算符 ==和!= （

邏輯補足運算符 !

邏輯運算符& ， ^ 和 |

條件運算符和條件運算符&& 和 ||

條件運算符? :

字符串連接運算符 + ，當給定一個String操作數和一個 boolean 操作數時，它將把 boolean 操作符轉換為一個String （ "true"或"false" ），然后產生一個新創建的String，其值為兩個字符串的連接結果。

布爾表達式決定了幾種語句中的控制流：

if 語句

while 語句

do 語句

for 語句

一個boolean表達式還決定在 ? : 運算符中使用哪個子表達式的值作為結果 。

只有Boolean表達式和Boolean表達式可以在控制流程語句中使用。

通過表達式 x!=0 ，可以將整數或浮點表達式 x 轉換為 boolean 值，這遵循了 C 語言約定，即任何非零值為true 。

通過表達式 obj!=null ，可以將對象引用 obj 轉換為boolean值，這同樣遵循了 C 語言約定（除null之外的任何引用為true 。

參考資料: Java Language Specification (Java SE 8 Edition) § 4.2