05.Java 基本數據類型的定義及使用

基本數據類型介紹

Java 中定義了 3 類 8 種基本數據類型

• 數值型：byte、short、int、long、float、double
• 字符型（文本型）：char
• 布爾型：boolean

數據類型分類如下：

其中：

• 引用數據類型：4 個字節，其代表對象的地址
• 字符型（char）：2 個字節
• 布爾型（boolean）：1 bit（1 位 ）
• 數值型：
  • 整數類型：
    1. byte：1 個字節
    2. short：2 個字節
    3. int：4 個字節
    4. long：8 個字節
  • 浮點類型：
    1. float：4 個字節
    2. double：8 個字節

整型變量/常量

整型用於沒有小數部分的數值，其允許是負數。

一個字節表示范圍是 2 的 8 次方（即 256 個數：-128 ~ 127）。
兩個字節表示范圍是 2 的 16 次方（-32768 ~ 32767），范圍大約在正負 3 萬之間。
三個字節表示范圍是 2 的 24 次方。
四個字節表示范圍是 2 的 32 次方，范圍大約在正負 21 億之間。

Java 語言的整型常量默認為 int 型，聲明 long 型常量可以后加 ‘l’ 或 ‘L’

假如定義的數據類型變量值超出范圍，會報錯。

byte age = 300;  // 報錯，因為 byte 的范圍是 -128~127（2 的 8 次方）
byte age1 = 30;   // 正常
short salary = 300000000;  // 報錯，short 數據類型的表數范圍是 2 個字節(2 的 16 次方)
short salary1 = 30000;     // 正常
int pop = 20000000000;     // 報錯（200億），int 表數范圍是 4 個字節，范圍大約在正負21億之間
int pop1 = 2000000000;     // 正常（20億），
// 定義 long 長整型常量
long one = 74000000000;    // 報錯，因為整型常量默認是 int 類型，所以此處超出范圍了
long one1 = 74000000000L;   // 在數值后面加上一個 L / l 字母，就代表這是一個 long 類型常量
long one2 = 74000000000l;   // 最好是加 L，方便辨別

Java 語言整型常量的四種表現形式

1. 十進制整數，如：99，-500,0
2. 八進制整數，要求以 0 開頭，如 015
3. 十六進制數，要求 0x 或 0X 開頭，如：0x15
4. 二進制數，要求 0b 或 0B 開頭，如：0b01110011

// 測試整型常量
int a = 15;
int b = 015;  // 這是八進制數
int c = 0x15;  // 這是十六進制
int d = 0b011101;  // 這是二進制
int e = 0B011101;  // 這是二進制
System.out.println(a);   // 結果為 15
System.out.println(b);   // 結果為 13
System.out.println(c);   // 結果為 21
System.out.println(d);   // 結果為 29
System.out.println(e);   // 結果為 29

浮點型變量/常量

帶小數的數據在 Java 中稱為浮點型。
浮點數據類型分兩種：float、double
float 占 4 個字節，double 占 8 個字節。
浮點型常量的默認類型是 double。
浮點數存在舍入誤差，數字不能精確表示。如果需要進行不產生舍入誤差的精確數字計算，需要使用 BigDecimal 類

float 稱為單精度類型，尾數可精確到 7 位有效數字，多數情況，float 類型的精度很難滿足需求。
double 稱為雙精度類型，數值精度約是 float類型 的兩倍。絕大部分應用程序都采用 double 類型。

Java 浮點類型常量的兩種表現形式：

• 十進制數形式，如：3.14、314.0、0.314
• 科學計數法形式，如：314e2、314E2、314E-2

科學計數法示例：

double f = 314e2; // 314*10^2 -->> 31400.0
double f2 = 314e-2; // 314*10^(-2) -->> 3.14

flaot 類型賦值時需要添加后綴 F/f

// 浮點型若未聲明，默認是 double。
// float 加 F/f 進行聲明，才能放進 float 類型中。float 和 double 的字節數不同，所以報錯
float a = 3.14;   // 報錯，定義 float，需要加 F/f 進行聲明
float a1 = 3.14F; // 正常
float a2 = 3.14f; // 正常

注意點

浮點類型float、double 的數據不適合在不容許舍入誤差的金融計算領域，如果需要進行不產生舍入誤差的精確數字計算，需要使用 BigDecimal 類。
float 類型后綴為 F/f，沒有 F/f 則默認為 double 類型。
可在浮點數值后添加 D/d 后綴，以明確其為 double 類型。

float f = 3.14F;
double d1 = 3.14;
double d2 = 3.14D;

浮點數比較（錯誤示范）

浮點數是不精確的，不能用於數值比較

// 浮點數是不精確的，不能用於數值比較
// 此處結果為 false
float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d);   // 結果為 false。利用 == ，對兩個變量進行數值比較

浮點數運算比較驗證

// 浮點數運算比較驗證，此處輸出結果為 d1==d2 ,由此說明浮點數是不精確的。
float d1 = 423432143f;
float d2 = d1 + 1;   // 在原來的基礎上加個 1
if(d1==d2){
  System.out.println("d1==d2"); // 輸出結果為 d1==d2
}else{
  System.out.println("d1 != d2"); 
}

數值之間如何計算？

java.math 包中有兩個類：BigInteger 和 BigDecimal
這兩個類可以處理任意長度的數值。
BigInteger實現任意精度的整數運算，BigDecimal實現任意精度的浮點數運算。

代碼示例：使用 BigDecimal 進行浮點數的比較

import java.math.BigDecimal;
public class testNumericalJ {
    public static void main(String[] args){
        // 使用精確浮點運算，推薦 BigDecimal
        BigDecimal bd = BigDecimal.valueOf(1.0);  // 定義了 bd 值為 1.0  ，即 bd = 1.0
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        // 兩者對比，上方 subtract 詞義是 減，進行了 5 次減 0.1 的操作。
        System.out.println(bd);  // 輸出結果為 0.5
        System.out.println(1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1); // 輸出結果為 0.5000000000000001

        // 定義 bd2，bd3，做比較驗證
        BigDecimal bd2 = BigDecimal.valueOf(0.1);    // 定義 bd2 初值為 0.1
        BigDecimal bd3 = BigDecimal.valueOf(1.0/10); // 定義 bd3 初值為 1.0/10
        // 比較 bd2 和 bd3
        System.out.println(bd2.equals(bd3));         // 輸出結果為 true
    }
}

字符型變量/常量

字符型在內存中占兩個字節，在 Java 中使用單引號來表示字符常量。
例如：單引號包裹的 'A' 表示一個字符，而雙引號包裹的 "A" 表示含有一個字符的字符串
char 類型用來表示在 Unicode 編碼表中的字符。
Unicode 編碼被設計用來處理各種語言的文字，其占 2 個字節，可允許 65536 個字符。
多個字母，如 'abc'，這種就需要用 String 類型來進行聲明，無法使用 char 進行聲明。char 只適用於單個字符或數字
String 即字符序列。

可以用單引號包裹表示字符型，也可以用 Unicode 編碼去表示字符型

示例：字符型舉例

char a = 'T';
char b = '中';
char c = '\u0061';  // 表示字符 a

Unicode 具有從 0 到 65535 之間的編碼，其通常從 ‘\u0000’ 到 ‘\uFFFF’ 之間的十六進制數來表示（前綴為 u 則說明是 Unicode）

轉義字符 '\'

Java 語言中允許使用轉義字符 '' 來將其后的字符轉變為其他的含義
常見轉義字符的含義和 Unicode 值如圖：

代碼示例：轉義字符

// 轉義字符
public class testPrimitiveDateType2 {
    public static void main(String[] args){
        // 轉義字符
        // 遇到符號 + 時，a 和 b 會自動轉化為數字
        System.out.println('a'+'b');  // 結果為 195
        // 通過在前方增加一個空字符串，讓語句識別為字符串拼接，最終獲得結果為 ab
        System.out.println(""+'a'+'b');  // 結果為 ab
        // 在 a 和 b 之間換行，使用 \n 換行符
        System.out.println(""+'a'+'\n'+'b');  // 一行輸出 a，后一行輸出 b
        // 在 a 和 b 之間增加一個 \t 制表符長度
        System.out.println(""+'a'+'\t'+'b');  // 輸出結果為 a  b，中間有一段為制表符占位
        // 在 a 和 b 之間增加一個單引號 '
        System.out.println(""+'a'+'\''+'b');  // 輸出結果為 a'b，使用 \ 來對單引號 ' 進行轉義輸出
    }
}

boolean 類型變量/常量

boolean 類型有兩個常量值：true 、false
在內存中占一位（不是一個字節）
不可以使用 0 或 非0 的整數來代替 true 和 false，這點與 C 語言有所不同
boolean 類型用來判斷邏輯條件，一般用於程序流程控制。

代碼示例：boolean 類型

// 測試布爾類型，測試結果為 “這里是 flag 是 true 的打印”
boolean flag;
flag = true; // 或者 flag = false
if (flag){
    System.out.println("這里是 flag 是 true 的打印");  // 打印這個結果
}else{
    System.out.println("這里是 flag 是 false 的打印");
}

細節代碼記錄：第一時間我誤判了

// 說出程序執行結果

boolean man = false;

if (man=true){
    System.out.println("男性");
}else{
    System.out.println("女性");
}

// 打印結果為男性，因為 if 判斷語句中對 man 進行了重新賦值。值由 false 變為了 true

至此，基本數據類型結束