基本型別

在java里有八種基本型別及每一種型別都對應了一種包裝類

• 在了解基本資料型別之前需要說一下，java的所有型別的位元組大小都和平臺沒有關系，
• 所有整型沒有無符號概念，

short（短整型）

1. short 占用 2 個位元組, 表示的資料范圍是 -32768~32767
2. 因為范圍比較小，不是必須的話，不推薦使用，
   使用示例

short value = 10; 
System.out.println(value);

注意事項

short a = 10;
short b = 20;
short c = a + b;
System.out.println(c);

當運行這段代碼的時候會出現報錯，

即使short 和 short 都是相同型別, 但是會出現編譯報錯. 原因是, 雖然 a 和 b 都是 short變數, 但是計算 a + b 會先將 a 和 b 都提升成 int, 再進行計算, 得到的結果也是 int, 這是賦給 c, 就會出現上述錯誤

正確的寫法

short a = 10; 
short b = 20; 
short c = (short)(a + b); 
System.out.println(c);

給a+b的運算式強制轉換為short型別則不會報錯，

byte（位元組型別）

1. 位元組型別也屬于整型的一種，不過它的位元組大小是1，取值范圍是-128~127

使用示例

byte value = 10; 
System.out.println(value);

注意事項

1. byte型別和short型別都是低于4個位元組，在運算時均會發生數值提示的現象，使用時需要更加注意
2. 因為范圍比較小，不是必須的話，不推薦使用，

int( 整型)

使用示例

int num = 10; // 定義一個整型變數
System.out.println(num) ;

1. 在java中int型別就是4個位元組，跟系統無關，
2. 由于在java中是沒有無符號整型概念的，所以int的取值范圍是 -2^31 ~ 2^31-1，

以下代碼可以查看int的資料范圍，

public static void main(String[] args) {
     System.out.println(Integer.MAX_VALUE); // int 的最大值
     System.out.println(Integer.MIN_VALUE); // int 的最小值
 }

運行截圖

如果運算的結果超出了int的取值范圍，則資料就會溢位

public static void main(String[] args) {
    System.out.println(Integer.MAX_VALUE+1); // int 的最大值加1會溢位
    System.out.println(Integer.MIN_VALUE-1); // int 的最小值-1會溢位
}

運行截圖
有細心的讀者會發現，int所表示的最大值加1溢位后變成了最小值，而最小值減1后變成了最大值，我們可以把型別范圍表示看成一個圓形

中間的是分界線，如果超過了最大值則就變成了最小值，這種概念可以應用與所有的整型型別，

long(長整型)

對于int能表示21億，這樣的數字對于當前大資料時代來說，是很容易溢位的，針對這種情況, 我們就需要使用更大范圍的資料型別來表示了. Java 中提供了 long 型別.

使用示例

long num = 10L; // 定義一個長整型變數, 初始值寫作 10l 也可以(小寫的 L, 不是數字1). 
System.out.println(num) ;

1. 需要注意的是初始化設定的值為 10L ，表示一個長整型的數字，10l 也可以.
2. 使用 10 初始化也可以, 10 的型別是 int, 10L 的型別是 long, 使用 10L 或者 10l 更好一些.（這里推薦用大寫的L，因為有些字體小寫的l可能容易被看成數字1）
3. java中long占8個位元組，取值范圍在 -2^63 ~ 2^63-1

使用以下代碼查看 Java 中的長整型資料范圍

public static void main(String[] args) {
    System.out.println(Long.MAX_VALUE);
    System.out.println(Long.MIN_VALUE);
}

運行結果
這個資料范圍遠超過 int 的表示范圍. 足夠絕大部分的工程場景使用.

double（雙精度浮點型）

1. 在java中小數默認是double型別，

使用示例

double num = 1.0;//定義一個浮點型變數
System.out.println(num)

浮點型和整型有什么不一樣呢？來看下面一段代碼，

public static void main(String[] args) {
    int a = 1;
    int b = 2;
    System.out.println(a / b);
}

如果站在數學角度來講，得到的應該是0.5，可運行結果得到的是0，
運行截圖

因為a和b是int型別變數，所以得到的結果也會是int型別的值，而int是無法儲存小數的，如果想要得到小數，那我們就需要把int改成double，

public static void main(String[] args) {
    double a = 1.0;
    double b = 2.0;
    System.out.println(a / b);
}

運行截圖

來看一段有趣的代碼

public static void main(String[] args) {
   double a = 1.1;
   double b = 1.1;
   System.out.println(a * b);
}

運行截圖

理論來講，得出的結果應該是1.21，為什么后面還多了個2？這是因為Java 中的 double 雖然也是 8 個位元組, 但是浮點數的記憶體布局和整數差別很大, 不能單純的用 2 ^ n 的形式表示資料范圍，Java 的 double 型別的記憶體布局遵守IEEE 754 標準(和C語言一樣), 嘗試使用有限的記憶體空間表示可能無限的小數, 勢必會存在一定的精度誤差，關于IEEE 754標準，有興趣的讀者可以去度娘了解一下，這里就不多介紹了，

float（單精度浮點型）

1. float 型別在 Java 中占4個位元組, 同樣遵守 IEEE 754 標準. 由于表示的資料精度范圍較小, 一般在工程上用到浮點數都優先考慮 double, 不太推薦使用 float.

使用示例

float num = 1.0f;    // 寫作 1.0F 也可以
System.out.println(num);

初始化需要注意在值需要加一個大寫的F或者小寫的f來表示這是一個float型別的小數，因為在java中小數是默認是double型的，不加f的話就相當于把一個double型別的值賦給float型別，則會發生精度丟失的錯誤，

char（字符型別）

1. char型別不能存盤負數， 取值范圍在是~65535
2. Java 中使用 Unicode 表示字符. 因此一個char占用2個位元組, 表示的字符種類更多, 包括中文
3. Java 中使用 單引號 + 單個字母 的形式表示字符字面值.

使用示例

public static void main(String[] args) {
    char a = 'A';
    char b = 'B';
    char c = 65;//對應Unicode表上的字符'A'
    char d = '中';
    System.out.println(a);
    System.out.println(b);
    System.out.println(c);
    System.out.println(d);
}

運行結果

boolean（布爾型別）

使用示例

boolean value = true; 
System.out.println(value);

1. boolean 型別的變數只有兩種取值, true 表示真, false 表示假.
2. Java 的 boolean 型別和 int 不能相互轉換, 不存在 1 表示 true, 0 表示 false 這樣的用法.
3. boolean 型別有些 JVM 的實作是占 1 個位元組, 有些是占 1 個位元位, 這個沒有明確規定.

小結

1. 不同型別的資料混合運算, 范圍小的會提升成范圍大的.
2. 對于 short, byte 這種比 4 個位元組小的型別, 會先提升成 4 個位元組的 int , 再運算
3. 更推薦在代碼中避免不同型別混用的情況, 來規避型別轉換和型別提升的問題

基本資料型別介紹到這，最后附上一張資料型別概況圖，關于參考資料型別，會在以后的博客中講，

算術運算子

四則運算規則比較簡單，這里我就講比較容易出錯的取余和除法運算子，

除 /

除法在進行運算的時候，會根據型別不同得出不同結果，

public static void main(String[] args) {
        System.out.println(12 / 5);
        System.out.println(12 / (float)5);
}

運行截圖

從運行結果我們可以看到，兩個數值一樣型別不一樣得到的結果不一樣，需要注意除法有兩種規則，

1. 如果兩個運算元都是整型則執行整型運算
2. 如果有一個運算元是浮點型則執行浮點型運算

需要注意，除數不能為0否則編譯會報錯

取余 %

在java中取余運算子是可以對小數取余的

需要注意跟除法一樣，不能對0進行取余否則會報錯，報錯原因跟除法相同，

這里有道負數取余的例子

System.out.println(10%3);
System.out.println(10%-3);
System.out.println(-10%3);
System.out.println(-10%-3);

運行結果

決議

1. 10取余3商3余1
2. 10取余-3商-3余1
3. -10取余3商-3余-1
4. -10取余-3商3余-1

賦值及復合賦值運算子

使用方式

int a = 10;//賦值
a += 1;//等價與a=a+1;
a -= 1;//等價與a=a-1;
a *= 1;//等價與a=a*1;
a /= 1;//等價與a=a/1;
a %= 1;//等價與a=a%1;

自增自減運算子

使用方式

int a = 10;
int b = 0;
a--;//等價與a = a-1;
a++;//等價與a = a+1;
b = ++a;//前置++
b = a++;//后置++
b = --a;//后置--
b = a--;//后置++

自增自減運算子需要區分是否作為單獨一條陳述句，或者是作為賦值陳述句

上面代碼我們看到，兩個相同的值，在做自增時，如果是后置++則先賦值然后自增，如果是前置++則先自增后賦值，
如果不取自增運算的運算式的回傳值, 則前置自增和后置自增沒有區別.

//單獨一條陳述句時，此時前置和后置++等價
a++;
++a;

自減運算子同理

關系運算子

使用方式

int a = 10; 
int b = 20; 
System.out.println(a == b); 
System.out.println(a != b); 
System.out.println(a < b); 
System.out.println(a > b); 
System.out.println(a <= b); 
System.out.println(a >= b);

注意事項

1. 關系運算子的運算式回傳的是boolean型別的值
2. 關系運算式的等于是兩個=號
   

邏輯運算子

短路與、短路或也稱邏輯與邏輯或

邏輯與 &&

• 規則: 兩個運算元都為 true, 結果為 true, 否則結果為 false.

使用方式

（運算式1） && （運算式2）
如果運算式1和運算式2都為true，則邏輯與的結果為true，否則為false

邏輯或 ||

• 規則: 兩個運算元都為 false, 結果為 false, 否則結果為 true

使用方式

（運算式1） || （運算式2）
如果運算式1和運算式2都為false，則邏輯或的結果為false，否則為true

關于&& 和 || 短路求值的屬性

作為"&&“和”||"運算子的運算元運算式，這些運算式在進行求值時，只要最終的結果已經可以確定是真或假，求值程序便告終止，這稱之為短路求值

我們都知道, 計算 10 / 0 會導致程式拋出例外. 但是上面的代碼卻能正常運行, 說明 10 / 0 并沒有真正被求值.

結論:

1. 對于 && , 如果左側運算式值為 false, 則運算式的整體的值一定是 false, 無需計算右側運算式.
2. 對于 ||, 如果左側運算式值為 true, 則運算式的整體的值一定是 true, 無需計算右側運算式.

邏輯非 ！

• 規則: 運算元為 true, 結果為 false; 運算元為 false, 結果為 true(這是個單目運算子, 只有一個運算元)

使用示例

位運算子

Java 中對資料的操作的最小單位不是位元組, 而是二進制位.

位操作表示 按二進制位運算. 計算機中都是使用二進制來表示資料的(01構成的序列), 按位運算就是在按照二進制位的每一位依次進行計算.

按位與 &

• 規則：如果兩個二進制位都是 1, 則結果為 1, 否則結果為 0

代碼示例

int a = 10; 
int b = 20; 
System.out.println(a & b);

運算程序

0000 0000 0000 0000 0000 0000 0000 1010 //10的二進制
0000 0000 0000 0000 0000 0000 0001 0100 //20的二進制
0000 0000 0000 0000 0000 0000 0000 0000 //按位與后 得到結果0

運算結果

按位或 |

• 規則: 如果兩個二進制位都是 0, 則結果為 0, 否則結果為 1.

代碼示例

int a = 10; 
int b = 20; 
System.out.println(a | b);

運算程序

0000 0000 0000 0000 0000 0000 0000 1010 //10的二進制
0000 0000 0000 0000 0000 0000 0001 0100 //20的二進制
0000 0000 0000 0000 0000 0000 0001 1110 //按位或后得到結果為30

運算結果

邏輯 & 和 | (不推薦使用)

• & 和 | 如果運算元為 boolean 的時候, 也表示邏輯運算. 但是和 && 以及 || 相比, 它們不支持短路求值.

代碼示例

System.out.println(10 > 20 & 10 / 0 == 0); // 程式拋出例外
System.out.println(10 < 20 | 10 / 0 == 0); // 程式拋出例外

使用&當邏輯運算時，不管運算式1是否為假它都會執行運算式2，

使用 | 當邏輯運算時，不管運算式1是否為真它都會執行運算式2，

總體來說盡量不使用邏輯& 和 邏輯 | 用作邏輯運算，

按位異或 ^

• 規則：如果兩個數字的二進制位相同, 則結果為 0, 相異則結果為 1.

代碼示例

int a = 8; 
int b = 13; 
System.out.println(a ^ b);

運算程序

0000 0000 0000 0000 0000 0000 0000 1000 //8的二進制
0000 0000 0000 0000 0000 0000 0000 1101 //13的二進制
0000 0000 0000 0000 0000 0000 0000 0101 //按位異或后得到結果為5

運行結果

按位異或的4個特點

1. 0異或任何數＝任何數
2. 1異或任何數 = 任何數取反
3. 任何數異或自己 ＝ 0
4. a異或b得到c，c可以通過異或b得到a或者異或a得到b，

按位取反 ~

• 規則：如果該位為 0 則轉為 1, 如果該位為 1 則轉為 0
• 需要注意按位取反是對整數的補碼進行取反

代碼示例

int a = 2;
System.out.printf("%d\n", ~a);//列印的是原碼

運算程序

0000 0000 0000 0000 0000 0000 0000 0010   //2的補碼
1111 1111 1111 1111 1111 1111 1111 1101   //按位取反得到補碼
1111 1111 1111 1111 1111 1111 1111 1100   //補碼減一得到反碼
1000 0000 0000 0000 0000 0000 0000 0011   //反碼按位取反得到原碼，十進制的-3

運算結果

如果有讀者不清楚原碼、反碼、補碼的話，可以去看我另一篇博客鏈接

移位運算

• 移位運算子有三個，都是按照補碼二進制位來運算
  

左移位運算 <<

• 規則：二進制向左移位，二進制左邊丟棄，右邊補0

代碼示例

int a = 10;
System.out.println(a << 1);

運算程序

運算結果

關于 << 位運算，左移一位有乘2的效果，

右移位運算 >>

• 規則：右邊丟棄, 左邊補符號位(正數補0, 負數補1)

代碼示例

int a = 10;
System.out.println(a >> 1);

運算程序

運算結果

關于 >> 運算子，右移1位有除2的效果，

無符號右移 >>>

• 規則: 右邊位丟棄, 左邊位補0（不區分有沒有符號）

代碼示例

int a = -1;
System.out.println(a >>> 1);

運算程序

運算結果

條件運算子 ：？

• 條件運算子只有一個: 運算式1 ? 運算式2 : 運算式3 當 運算式1 的值為 true 時, 整個運算式的值為運算式2的值; 當 運算式1 的值為 false 時, 整個運算式的值為 運算式3 的值
• 是 Java 中唯一的一個 三目運算子, 是條件判斷陳述句的簡化寫法

代碼示例

int a = 10; 
int b = 20; 
int max = a > b ? a : b;
System.out.println(max);

運行截圖

運算子優先級

先看一段代碼

System.out.println(1 + 2 * 3); 

結果為 7, 說明先計算了 2*3 , 再計算 1+

另外一個例子

System.out.println(10 < 20 && 20 < 30); 

此時明顯是先計算的 10 < 20 和 20 < 30, 再計算 &&. 否則 20 && 20 這樣的操作是語法上有誤的(&& 的運算元只能是boolean).

結論

• 運算子之間是有優先級的. 具體的規則我們不必記憶. 在可能存在歧義的代碼中加上括號即可.

最后附上一張運算子優先級圖

運算子小結

1. % 操作再 Java 中也能針對 double 來計算.
2. 需要區分清楚 前置自增 和 后置自增之間的區別.
3. 由于 Java 是強型別語言, 因此對于型別檢查較嚴格, 因此像 && 之類的運算運算元必須是 boolean.
4. 要區分清楚 & 和 | 什么時候是表示按位運算, 什么時候表示邏輯運算.

整體來看, Java 的運算子的基本規則和 C 語言基本一致，