之前的文章我們介紹了一下用 IDEA 編輯器建立一個 Java 專案並輸出 HelloWorld，本章我們來看一下 Java 中的變數和基本資料型別。

在這之前我們先來看一下 Java 中的關鍵字，這些關鍵字不能被用作變數名稱。

Java註釋

類似於 C/C++、Java 也支援單行以及多行註釋。註釋中的字元將被 Java 編譯器忽略。

 1 package com.demo;
 2 /** 這是第一個Java程式
 3  * 這是一個多行註釋的示例
 4  */
 5 public class HelloWorld {
 6     public static void main(String[] args) {
 7         // 這是單行註釋的示例
 8         /* 這個也是單行註釋的示例 */
 9         System.out.println("Hello World");
10     }
11 }

Java 基本資料型別

Java語言提供了八種基本型別。六種數字型別（四個整數型，兩個浮點型），一種字元型別，還有一種布林型。

int 

int 資料型別是32位、有符號的以二進位制補碼錶示的整數，佔4個位元組；

• 最小值 -2,147,483,648（-2^31），
• 最大值 2,147,483,647（2^31 - 1），
• 整數直接量預設為 int 型，不能超範圍，否則會編譯錯誤，
• 兩個整數相除，結果還是整數，小數位無條件捨棄，
• 運算時超出範圍會發生溢位

 1 package com.demo;
 2 
 3 public class HelloWorld {
 4     public static void main(String[] args) {
 5         // int a = "123"; 編譯錯誤
 6         // int a = 123.123; 編譯錯誤
 7         // int a = 2147483648; 編譯錯誤，超出最大值 2147483647
 8         // int a = -2147483649; //編譯錯誤，超出最大值 -2147483648
 9         int a = 1;  // 宣告變數 a 為整數 1
10         int b = 2147483647;
11         int c;
12         c = 1 + b;
13         System.out.println(c); // -2147483648，運算超出範圍發生溢位
14         c = 2 + b;
15         System.out.println(c); // -2147483647，運算超出範圍發生溢位
16     }
17 }

long 

long 資料型別是 64 位、有符號的以二進位制補碼錶示的整數，8個位元組；

• 最小值是 -9,223,372,036,854,775,808（-2^63）
• 最大值是 9,223,372,036,854,775,807（2^63 -1）
• 長整型直接biang為在數字後面加 l 或 L
• 算數運算時有可能超範圍，建議在第一個數字後加 l 或 L
• System.currentTimeMillis( ) 用於獲取自 1970.1.1 零時至此時此刻所經歷的毫秒數，用 long 儲存。

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         // long a = "123"; 編譯錯誤
 4         // long a = 123.123; 編譯錯誤
 5         // long a = 9223372036854775808L; //編譯錯誤，超出最大值 9223372036854775807
 6         // long a = -9223372036854775809L; //編譯錯誤，超出最大值 -9223372036854775808
 7         long a = 100L;  // 宣告變數 a 為長整數 100
 8         long b = 9223372036854775807L;
 9         long c;
10         c = 1 + b;
11         System.out.println(c); // -9223372036854775808，運算超出範圍發生溢位
12         c = 2 + b;
13         System.out.println(c); // -9223372036854775807，運算超出範圍發生溢位
14         long d = System.currentTimeMillis();
15         System.out.println(d); // 當前時間毫秒數 1558516383355
16     }
17 }

byte

byte 資料型別是8位、有符號的，以二進位制補碼錶示的整數；佔1個位元組

• 最小值是 -128（-2^7）；
• 最大值是 127（2^7-1）；
• 預設值是 0；
• byte 型別用在大型陣列中節約空間，主要代替整數，因為 byte 變數佔用的空間只有 int 型別的四分之一；
• byte型別運算的時候自動轉換為int型別

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         // byte a = "123"; 編譯錯誤
 4         // byte a = 123.123; 編譯錯誤
 5         // byte a = 128; 編譯錯誤，超出最大值 127
 6         // byte a = -129; //編譯錯誤，超出最大值 -128
 7         byte a = 1;  // 宣告變數 a 為byte 1
 8         byte b = 127;
 9         // b = 1 + b;
10         // System.out.println(b); // 編譯錯誤，byte 參與運算自動轉為 int
11 
12         // 可以轉換為 byte 型資料
13         b = (byte) (1 + b);
14         System.out.println(b); // -128，超出運算範圍發生溢位
15     }
16 }

short

short 資料型別是 16 位、有符號的以二進位制補碼錶示的整數，佔2個位元組

• 最小值是 -32768（-2^15）；
• 最大值是 32767（2^15 - 1）；
• 預設值是 0
• short 資料型別也可以像 byte 那樣節省空間。一個 short 變數是int型變數所佔空間的二分之一；
• short 型別運算的時候自動轉換為int型別

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         // short a = "123"; 編譯錯誤
 4         // short a = 123.123; 編譯錯誤
 5         // short a = 32768; 編譯錯誤，超出最大值 32767
 6         // short a = -32769; //編譯錯誤，超出最大值 -32768
 7         short a = 1;  // 宣告變數 a 為short 1
 8         short b = 32767;
 9         // b = 1 + b;
10         // System.out.println(b); // 編譯錯誤，short 參與運算自動轉為 int
11 
12         // 可以轉換為 short 型資料
13         b = (short) (1 + b);
14         System.out.println(b); // -32768，超出運算範圍發生溢位
15     }
16 }

double，float

double 浮點型資料，資料型別是雙精度、64 位

float 浮點型資料，資料型別是單精度、32位

• 浮點數的預設型別為 double 型別；
• 表示 float 型資料的直接量需要加 f 或 F 字尾。
• double 型別的精度值是 float 型別的兩倍
• 大多數場合使用 double 表示浮點型
• float 在儲存大型浮點陣列的時候可節省記憶體空間
• 浮點數運算時，可能會發生攝入誤差
• 浮點數不能用來表示精確的值，如貨幣

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         // float a = "123"; 編譯錯誤
 4         // double a = "123"; 編譯錯誤
 5         float a = 5.0F;
 6         a = a - 4.3F;
 7         System.out.println(a); // 0.6999998
 8 
 9         double b = 5.0;
10         b = b - 4.3;
11         System.out.println(b); // 0.7000000000000002
12     }

boolean 

布林型，只能取值為 true 或 false，佔一個位元組，預設為 false

1 public class HelloWorld {
2     public static void main(String[] args) {
3         // boolean a = "111"; // 編譯錯誤
4         boolean a = true;
5         System.out.println(a); // true
6         boolean b = false;
7         System.out.println(b); // false
8     }
9 }

char

char型別是一個單一的 16 位 Unicode 字元；

• 最小值是 \u0000（即為0）；
• 最大值是 \uffff（即為65,535）；
• char 資料型別可以儲存任何字元；
• 任意單字元需加單引號 ' ' 

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         // char a = "123"; 編譯錯誤
 4         // char a = 123.123; 編譯錯誤
 5         // char a = 65536; 編譯錯誤，超出最大值 65535
 6         // char a = -1; //編譯錯誤，超出最小值 0
 7         // char a = '197'; //編譯錯誤 因為有單引號，表示是字元，只允許放單個字元。
 8         // char a = 'a' + b; //編譯錯誤 因為b是一個賦值的變數。
 9         // char a = '中' + '國' + '國' + '國'; //報錯 int轉char有損失。因為結果已經超出char型別的範圍。
10         // char a = '中' + "國"; //報編譯錯誤 String無法轉換為char。
11         char a='1';  //任意單個字元，加單引號。
12         char a='中'; //任意單箇中文字，加單引號。
13         char a = 'a' + 'b'; //Ã  char型別相加，提升為int型別，輸出對應的字元。
14         int a = 'a' + 'b'; //195 195沒有超出int範圍，直接輸出195。
15         char a = 197; //Ã 輸出字元編碼表中對應的字元。
16         char a = 'a' + 1; //b 提升為int，計算結果98對應的字元是b。
17         char a = '中' + '國';//42282。
18         int a = '中' + '國' + '國' + '國'; //86820
19         char a = '中' + 1; //丮 //1是int，結果提升為int，輸出對應的字元。
20 
21         System.out.println('中' + "國"); //中國 沒有變數附值的過程。String與任何字元用“+”相連，轉換為String。
22     }
23 }

不同的基本型別可以直接相互轉換

• 自動轉換（隱式轉換）：從小型別到到型別可以自動完成，型別的大小關係：byte -> short -> int -> long -> float -> double，其中 char -> int 單獨。
  
• 強行轉換：從大型別到小型別需要強制轉換符：（需要轉換的型別）變數。但這樣轉換可能會造成精度損失或者溢位。

在上面的示例程式碼中已經演示過強轉了，這裡就不在舉例了。

隱含強制型別轉換

• 1. 整數的預設型別是 int。

• 2. 浮點型不存在這種情況，因為在定義 float 型別時必須在數字後面跟上 F 或者 f。

&n