之前的文章我們介紹了一下用 IDEA 編輯器創建一個 Java 項目並輸出 HelloWorld，本章我們來看一下 Java 中的變量和基本數據類型。
在這之前我們先來看一下 Java 中的關鍵字，這些關鍵字不能被用作變量名稱。
| 類別 | 關鍵字 | 說明 |
|---|---|---|
| 訪問控制 | private | 私有的 |
| protected | 受保護的 | |
| public | 公共的 | |
| 類、方法和變量修飾符 | abstract | 聲明抽象 |
| class | 類 | |
| extends | 擴充,繼承 | |
| final | 最終值,不可改變的 | |
| implements | 實現（接口） | |
| interface | 接口 | |
| native | 本地，原生方法（非 Java 實現） | |
| new | 新,創建 | |
| static | 靜態 | |
| strictfp | 嚴格,精准 | |
| synchronized | 線程,同步 | |
| transient | 短暫 | |
| volatile | 易失 | |
| 程序控制語句 | break | 跳出循環 |
| case | 定義一個值以供 switch 選擇 | |
| continue | 繼續 | |
| default | 默認 | |
| do | 運行 | |
| else | 否則 | |
| for | 循環 | |
| if | 如果 | |
| instanceof | 實例 | |
| return | 返回 | |
| switch | 根據值選擇執行 | |
| while | 循環 | |
| 錯誤處理 | assert | 斷言表達式是否為真 |
| catch | 捕捉異常 | |
| finally | 有沒有異常都執行 | |
| throw | 拋出一個異常對象 | |
| throws | 聲明一個異常可能被拋出 | |
| try | 捕獲異常 | |
| 包相關 | import | 引入 |
| package | 包 | |
| 基本類型 | boolean | 布爾型 |
| byte | 字節型 | |
| char | 字符型 | |
| double | 雙精度浮點 | |
| float | 單精度浮點 | |
| int | 整型 | |
| long | 長整型 | |
| short | 短整型 | |
| 變量引用 | super | 父類,超類 |
| this | 本類 | |
| void | 無返回值 | |
| 保留關鍵字 | goto | 是關鍵字，但不能使用 |
| const | 是關鍵字，但不能使用 | |
| null | 空 |
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。