Java基礎知識（變數、資料型別、運算子）

一、變數的定義和使用
變數的定義： 定義出一個符號，這個符號在某個範圍內，就代表一個變化的值。
變數的賦值：為了一個符號，賦予一個明確的值

int w;  //定義變數w
w=5;    //給w賦值，當前值為5

變數的定義+初始化：

int w=7;  //定義w且值為7

變數的使用：

int w = 7;
int h = 2;
System.out.println(w * h); // 使用 w、h 這兩個變數。列印 14

總結：

1. 變數必須先定義，才能被使用。
2. 變數如果先被賦值或者初始化，才能被使用。

變數形態

二、資料型別
1.整形變數

int 變數名 =初始值;
//例：
int num=10;

注：在Java中，一個int變數佔4個位元組，和作業系統 沒有直接關係。表示的範圍是 -2^31 到 2^31-1,也就是-21億到+21億。

2.長整型變數

long 變數名=初始值;

//例：
long num=10L;

注：Java中long佔8個位元組，表示的資料範圍 -2^63到 2^63-1

3.雙精度浮點型變數

double 變數名=初始值;
//例：
double num=10.0;

舉例1：

 int a=1;
 int b=2;
 Syestem.out.println(a/b);
 //執行結果： 0

在 Java中，int除以int的值仍然是int（會捨棄掉小數部分）
如果要得到0.5，需要使用double型別計算。

 double a=1;
 double b=2;
 Syestem.out.println(a/b);
 //執行結果： 0.5

舉例2

double num=1.1;
Syestem.out.println(num * num);
//執行結果：1.2100000000000002

注：

1. Java 中的 double 雖然也是 8 個位元組, 但是浮點數的記憶體佈局和整數差別很大, 不能單純的用 2 ^ n 的形式表示資料範圍.
2. Java 的 double 型別的記憶體佈局遵守 IEEE 754 標準((-1)^S *M 2^E), 嘗試使用有限的記憶體空間表示可能無限的小數, 勢必會存在一定的精度誤差.

4.單精度浮點型變數

float 變數名=初始值;
//例：
float num=10.0f;

5.字元型別變數

char 變數名=初始值;
//例：
char ch='A';

注：

1. Java 中使用 單引號 + 單個字母 的形式表示字元字面值.
2. 計算機中的字元本質上是一個整數. 在 C 語言中使用 ASCII 表示字元, 而 Java 中使用 Unicode 表示字元，因此一個字元佔用兩個位元組，表示的字元種類更多，包括中文。

使用一個字元表示漢字：

char ch='啊';

6.位元組型別變數

byte 變數名=初始值;
//例：
byte value=0；

注：

1. 位元組型別表示的也是整數. 只佔一個位元組, 表示範圍較小 ( -128 -> +127 )
2. 位元組型別和字元型別互不相干.

7.短整型變數

short 變數名=初始值;
//例：
short value=0；

注：

1. short 佔用 2 個位元組, 表示的資料範圍是 -32768 -> +32767
2. 這個表示範圍比較小，一般不推薦使用

8.布林型別變數

boolean 變數名=初始值;
//例：
boolean value=true;

注：

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

9.字串型別變數
注：String型別不是基本資料型別，而是引用資料型別

String 變數名="初始值";
//例：
String name="zhangsan";

注：

1. Java 使用 雙引號 + 若干字元 的方式表示字串字面值.
2. 和上面的型別不同, String 不是基本型別, 而是引用型別(後面重點解釋).
3. 字串中的一些特定的不太方便的直接表示的字元需要轉義。

字串的 + 操作。表示字串拼接：

String a = "hello";
String b = "world";
String c = a + b;
System.out.println(c);
//執行結果： helloworld

還可以用字串和整數進行拼接：

String str = "result = ";
int a = 10;
int b = 20;
String result = str + a + b;
System.out.println(result);
// 執行結果：  result = 1020

變數的命名規則：

1. 一個變數名只能包含數字, 字母, 下劃線
2. 數字不能開頭.
3. 變數名是大小寫敏感的. 即 num 和 Num 是兩個不同的變數

三、變數的作用域
也就是該變數能生效的範圍，一般是變數定義所在的程式碼塊（大括號）
舉例1：

class Test {
    public static void main(String[] args) {
       {
            int x = 10;
            System.out.println(x);   // 編譯通過;
       }
        System.out.println(x); // 編譯失敗, 找不到變數 x. 
   }
}

舉例2：

class Test {
    public static void main(String[] args) {
       {
            int x = 10; // 這裡定義了一個變數 x，型別是 int，值是 10
            System.out.println(x); // 會列印 10
       }
        
       {
            double x = 20.0; // 這裡又定義了一個變數 x，型別是 double，值是20.0
                                        // 和上面的變數完全無關，只是用到的符號（變數名）相同

四、字面值和常量
1.字面值

10 // int 字面值常量(十進位制)
010     // int 字面值常量(八進位制) 由數字 0 開頭. 010 也就是十進位制的 8
0x10    // int 字面值常量(十六進位制) 由數字 0x 開頭. 0x10 也就是十進位制的 16
10L     // long 字面值常量. 也可以寫作 10l (小寫的L)
1.0     // double 字面值常量. 也可以寫作 1.0d 或者 1.0D
1.5e2   // double 字面值常量. 科學計數法表示. 相當於 1.5 * 10^2
1.0f    // float 字面值常量, 也可以寫作 1.0F
true    // boolen 字面值常量, 同樣的還有 false
'a'     // char 字面值常量, 單引號中只能有一個字元
"abc"   // String 字面值常量, 雙引號中可以有多個字元.

2.final關鍵字修飾的常量

final int a = 10;
a = 20;   
// 編譯出錯. 提示 無法為最終變數a分配值

五、型別轉換
Java是一個強型別程式語言，當不同型別的變數之間相互賦值的時候，會有較強的校驗。
舉例1：int 和long/double相互賦值

int a = 10;
long b = 20; 
a = b;         // 編譯出錯, 提示可能會損失精度. 
b = a;         // 編譯通過. 
int a = 10;
double b = 1.0; 
a = b;             // 編譯出錯, 提示可能會損失精度.
b = a;             //編譯通過。

long 表示的範圍更大, 可以將 int 賦值給 long, 但是不能將 long 賦值給 int.
double 表示的範圍更大, 可以將 int 賦值給 double, 但是不能將 double 賦值給 int.
結論: 不同數字型別的變數之間賦值，表示範圍更小的型別能隱式轉換為範圍大的型別，反之則不行。

舉例2：int 和boolean相互賦值

int a = 10;
boolean b = true; 
b = a;               // 編譯出錯, 提示不相容的型別
a=b;                 // 編譯出錯, 提示不相容的型別

結論: int 和 boolean 是毫不相干的兩種型別, 不能相互賦值.

舉例3： int字面常量給byte賦值

byte a = 100;     // 編譯通過
byte b=256;       //編譯報錯，提示從int轉換到byte可能會有損失

注意: byte 表示的資料範圍是 -128 -> +127, 256 已經超過範圍, 而 100 還在範圍之內.
結論: 使用字面值常量賦值的時候, Java 會自動進行一些檢查校驗, 判定賦值是否合理.

使用強制型別轉換

int a = 0;
double b = 10.5; 
a = (int)b;
int a = 10;
boolean b = false;
b = (boolean)a;          // 編譯出錯, 提示不相容的型別

結論:
使用 (型別) 的方式可以將 double 型別強制轉成 int.
但是

1. 強制型別轉換可能會導致精度丟失. 如剛才的例子中, 賦值之後, 10.5 就變成 10 了, 小數點後面的部
   分被忽略.
2. 強制型別轉換不是一定能成功, 互不相干的型別之間無法強轉.型別轉換

小結：

1. 不同數字型別的變數之間賦值, 表示範圍更小的型別能隱式轉換成範圍較大的型別.
2. 如果需要把範圍大的型別賦值給範圍小的, 需要強制型別轉換, 但是可能精度丟失.
3. 將一個字面值常量進行賦值的時候, Java 會自動針對數字範圍進行檢查.

六、數值提升
舉例1：int和long混合運算

int a = 10;
long b = 20;
int c = a + b; // 編譯出錯, 提示將 long 轉成 int 會丟失精度
long d = a + b;//編譯通過

結論: 當 int 和 long 混合運算的時候, int 會提升成 long, 得到的結果仍然是 long 型別, 需要使用 long 型別的變數來接收結果. 如果非要用 int 來接收結果, 就需要使用強制型別轉換.

舉例2：byte和byte的運算

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
// 編譯報錯： 錯誤: 不相容的型別: 從int轉換到byte可能會有損失

結論: byte 和 byte 都是相同型別, 但是出現編譯報錯. 原因是, 雖然 a 和 b 都是 byte, 但是計算 a + b 會先將 a 和 b 都提升成 int, 再進行計算, 得到的結果也是 int, 這是賦給 c, 就會出現上述錯誤.
由於計算機的 CPU 通常是按照 4 個位元組為單位從記憶體中讀寫資料. 為了硬體上實現方便, 諸如 byte 和
short 這種低於 4 個位元組的型別, 會先提升成 int, 再參與計算。
正確的寫法：

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

型別提升小結:

1. 不同型別的資料混合運算, 範圍小的會提升成範圍大的.
2. 對於 short, byte 這種比 4 個位元組小的型別, 會先提升成 4 個位元組的 int , 再運算.

七、int和String之間的相互轉換
int 轉String

int num = 10;
// 方法1
String str1 = num + "";  
// 方法2
String str2 = String.valueOf(num);

String轉int

String str = "100";
int num = Integer.ParseInt(str);

八、列印輸出
基本語法：

System.out.println(msg);          // 輸出一個字串, 帶換行
System.out.print(msg);           // 輸出一個字串, 不帶換行
System.out.printf(format, msg); // 格式化輸出
System.out.println(format,msg);//完全等同於 printf

注：

1. println 輸出的內容自帶 %n, print 不帶 %n
2. printf 的格式化輸出方式和 C 語言的 printf 是基本一致的.

九、運算子
1.賦值運算子 =

為一個變數進行賦值操作

int a=10;
a=20;

2.算術運算子
• 基本四則運算子： + -* / %
•增量賦值運算子 ： += -= *= /= %=
•自增/自減運算子 ： ++ - -

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

結論:

1. 如果不取自增運算的表示式的返回值, 則前置自增和後置自增沒有區別.
2. 如果取表示式的返回值, 則前置自增的返回值是自增之後的值, 後置自增的返回值是自增之前的值.

3.關係運算子
關係運算子主要有六個: == != < > <= >=

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);

注意: 關係運算子的表示式返回值都是 boolean 型別.

4.邏輯運算子
邏輯運算子主要有三個:&& || !

注意: 邏輯運算子的運算元(運算元往往是關係運算子的結果)和返回值都是 boolean .
注意: 邏輯運算子的運算元(運算元往往是關係運算子的結果)和返回值都是 boolean .

邏輯與 &&
規則: 兩個運算元都為true，結果為true，否則結果為false。

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

邏輯或 ||
規則：兩個運算元都為false，結果為false，否則結果為true。

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

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

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

短路求值

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

&和|(不推薦使用)
& 和 | 如果運算元為 boolean 的時候, 也表示邏輯運算，但是和&&以及||相比，它們不支援短路求值。

System.out.println(10 > 20 & 10 / 0 == 0);// 程式丟擲異常
System.out.println(10 < 20 |0==0);// 程式丟擲異常

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

位運算子主要有四個:& | ~ ^

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

按位與 &：如果兩個二進位制位都是1，則結果為1，否則為0.

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

按位或 | :如果兩個二進位制位都是0，則結果為0，否則為1.

按位取反 ~：如果該位為0則轉為1，如果該位位1則轉為0.

按位異或 ^:如果兩個數字的二進位制位相同，則相同為0，則相異結果為1.

6.移位運算
移位運算子有三個: << >> >>>

都是按照二進位制位來運算.

左移<<:最左側位不要了，最右側補0.
右移>>:最右側位不要了，最左側補符號位（正數補0，負數補1）
無符號右移>>>>:最右側位不要了，最左側補0.
注：

1. 左移 1 位, 相當於原數字 * 2. 左移 N 位, 相當於原數字 * 2 的N次方.
2. 右移 1 位, 相當於原數字 / 2. 右移 N 位, 相當於原數字 / 2 的N次方.
3. 由於計算機計算移位效率高於計算乘除, 當某個程式碼正好乘除 2 的N次方的時候可以用移位運算代
   替.
4. 移動負數位或者移位位數過大都沒有意義.

7.條件運算子
條件運算子只有一個：

表示式1 ? 表示式2 : 表示式3

當 表示式1 的值為 true 時, 整個表示式的值為 表示式2 的值; 當 表示式1 的值為 false 時, 整個表示式的值為 表示式3 的值.

也是Java中的唯一一個三目運算子，是條件判斷語句的簡化寫法。