學(xué)習(xí)目標
- 能夠辨識關(guān)鍵字
- 掌握標識符的命名規(guī)則和規(guī)范
- 理解Java中的數(shù)據(jù)類型分類
- 能夠定義8種基本數(shù)據(jù)類型的變量
- 理解基本數(shù)據(jù)類型的自動類型轉(zhuǎn)換
- 理解基本數(shù)據(jù)類型的強制類型轉(zhuǎn)換
- 了解進制
- 了解ASCII編碼表和Unicode編碼表
- 理解+符號在字符串中的作用
- 掌握算術(shù)運算符
- 掌握賦值運算符
- 掌握比較運算符
- 掌握邏輯運算符
- 掌握三元運算符
- 理解位運算符
1. 關(guān)鍵字（keyword）（掌握）
- 定義：被Java語言賦予了特殊含義，用做專門用途的字符串（單詞）
- HelloWorld案例中，出現(xiàn)的關(guān)鍵字有
public、class、static、void等，這些單詞已經(jīng)被Java定義好
- HelloWorld案例中，出現(xiàn)的關(guān)鍵字有
- 特點：全部關(guān)鍵字都是
小寫字母。 - 關(guān)鍵字比較多，不需要死記硬背，學(xué)到哪里記到哪里即可。
- 官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
說明：
- 關(guān)鍵字一共50個，其中const和goto是保留字。
- true,false,null看起來像關(guān)鍵字，但從技術(shù)角度，它們是特殊的布爾值和空值。
2. 標識符( identifier)（掌握）
Java 對各種變量、方法和類等要素命名時使用的字符序列稱為標識符。
技巧：凡是自己可以起名字的地方都叫標識符。
標識符的命名規(guī)則（必須遵守的硬性規(guī)則）：
> 由26個英文字母大小寫，0-9 ，_或 $ 組成
> 數(shù)字不可以開頭。
> 不可以使用關(guān)鍵字和保留字，但能包含關(guān)鍵字和保留字。
> Java中嚴格區(qū)分大小寫，長度無限制。
> 標識符不能包含空格。
練習(xí)：miles, Test, a++, --a, 4#R, $4, #44, apps, class, public, int, x, y, radius
標識符的命名規(guī)范（建議遵守的軟性規(guī)則，否則容易被鄙視）:
> 包名：多單詞組成時所有字母都小寫：xxxyyyzzz。
例如：java.lang
> 類名、接口名：多單詞組成時，所有單詞的首字母大寫：XxxYyyZzz
例如：HelloWorld，String，System等
> 變量名、方法名：多單詞組成時，第一個單詞首字母小寫，第二個單詞開始每個單詞首字母大寫：xxxYyyZzz
例如：age,name,bookName,main
> 常量名：所有字母都大寫。多單詞時每個單詞用下劃線連接：XXX_YYY_ZZZ
例如：MAX_VALUE,PI
注意1：在起名字時，為了提高閱讀性，要盡量有意義，“見名知意”。
注意2：java采用unicode字符集，因此標識符也可以使用漢字聲明，但是不建議使用。
更多細節(jié)詳見《代碼整潔之道.pdf》《Java開發(fā)手冊（嵩山版）》
3. 變量（掌握）
3.1 Java中的數(shù)據(jù)類型
Java的數(shù)據(jù)類型分為兩大類：
-
基本數(shù)據(jù)類型：包括
整數(shù)、浮點數(shù)、字符、布爾。 -
引用數(shù)據(jù)類型：包括
數(shù)組、類、接口、枚舉、注解。
3.2 初識變量
- 變量的概念：
內(nèi)存中的一個存儲區(qū)域
該區(qū)域的數(shù)據(jù)可以在同一類型范圍內(nèi)不斷變化
變量是程序中最基本的存儲單元。包含變量類型、變量名和存儲的值
- 變量的作用：用于在內(nèi)存中保存數(shù)據(jù)
- 使用變量注意：
- Java中每個變量必須先聲明，后使用
- 使用變量名來訪問這塊區(qū)域的數(shù)據(jù)
- 變量的作用域：其定義所在的一對{ }內(nèi)
- 變量只有在其作用域內(nèi)才有效
- 同一個作用域內(nèi)，不能定義重名的變量
3.2 變量的定義
格式：數(shù)據(jù)類型 變量名;
//例如：
//存儲一個整數(shù)類型的年齡
int age;
//存儲一個小數(shù)類型的體重
double weight;
//存儲一個單字符類型的性別
char gender;
//存儲一個布爾類型的婚姻狀態(tài)
boolean marry;
//存儲一個字符串類型的姓名
String name;
//聲明多個同類型的變量
int a,b,c; //表示a,b,c三個變量都是int類型。
注意：變量的數(shù)據(jù)類型可以是基本數(shù)據(jù)類型，也可以是引用數(shù)據(jù)類型。
3.3 變量的賦值
給變量賦值，就是把“值”存到該變量代表的內(nèi)存空間中。
1、變量賦值的語法格式
變量名 = 值;
- 給變量賦值，變量名必須在=左邊，值必須在=右邊
- 給變量賦的值類型必須與變量聲明的類型一致或兼容
2、可以使用合適類型的常量值給變量賦值
int age = 18;
double weight = 109;
char gender = '女';
boolean beauty = true;
String name = "迪麗熱巴";
3、可以使用其他變量或者表達式給變量賦值
int m = 1;
int n = m;
int x = 1;
int y = 2;
int z = 2 * x + y;
4、變量可以反復(fù)賦值
- 變量的第一次賦值稱為初始化；
- 變量的再賦值稱為修改變量的值；
//先聲明，后初始化
char gender;
gender = '女';
//聲明的同時初始化
int age = 18;
System.out.println("age = " + age);///age = 18
//給變量重新賦值，修改gender變量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男
3.4 小結(jié)：變量的三要素
1、數(shù)據(jù)類型
- 變量的數(shù)據(jù)類型決定了在內(nèi)存中開辟多大空間
- 變量的數(shù)據(jù)類型也決定了該變量可以存什么值
2、變量名
- 見名知意非常重要
3、值
基本數(shù)據(jù)類型的變量：存儲數(shù)據(jù)值
引用數(shù)據(jù)類型的變量：存儲地址值，即對象的首地址。例如：String類型的變量存儲的是字符串對象的首地址（關(guān)于對象后面章節(jié)再詳細講解）
4. 基本數(shù)據(jù)類型介紹
4.1 整數(shù)類型：byte、short、int、long
Java各整數(shù)類型有固定的表數(shù)范圍和字段長度，不受具體OS的影響，以保證java程序的可移植性。
Java的整型常量默認為 int 型，聲明long型常量須后加‘l’或‘L’
Java程序中變量通常聲明為int型，除非不足以表示較大的數(shù)，才使用long
4.1.1 計算機存儲單位（掌握）
字節(jié)（Byte）：是計算機用于計量存儲容量的基本單位，一個字節(jié)等于8 bit。
位（bit）：是數(shù)據(jù)存儲的最小單位。二進制數(shù)系統(tǒng)中，每個0或1就是一個位，叫做bit（比特），其中8 bit 就稱為一個字節(jié)(Byte)。
-
轉(zhuǎn)換關(guān)系：
- 8 bit = 1 Byte
- 1024 Byte = 1 KB
- 1024 KB = 1 MB
- 1024 MB = 1 GB
- 1024 GB = 1 TB
4.2 浮點類型：float、double
與整數(shù)類型類似，Java 浮點類型也有固定的表數(shù)范圍和字段長度，不受具體操作系統(tǒng)的影響。
-
浮點型常量有兩種表示形式：
- 十進制數(shù)形式：如：5.12 512.0f .512 (必須有小數(shù)點）
- 科學(xué)計數(shù)法形式:如：5.12e2 512E2 100E-2
float:單精度，尾數(shù)可以精確到7位有效數(shù)字。很多情況下，精度很難滿足需求。
double:雙精度，精度是float的兩倍。通常采用此類型。
Java 的浮點型常量默認為double型，聲明float型常量，須后加‘f’或‘F’。
4.3 字符類型：char
- char 型數(shù)據(jù)用來表示通常意義上“字符”(2字節(jié))
- Java中的所有字符都使用Unicode編碼，故一個字符可以存儲一個字母，一個漢字，或其他書面語的一個字符。
- 字符型變量的三種表現(xiàn)形式：
- 字符常量是用單引號(‘ ’)括起來的單個字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
- Java中還允許使用轉(zhuǎn)義字符‘\’來將其后的字符轉(zhuǎn)變?yōu)樘厥庾址统Ａ?。例如：char c3 = ‘\n’; // '\n'表示換行符
- 直接使用 Unicode 值來表示字符型常量：‘\uXXXX’。其中，XXXX代表一個十六進制整數(shù)。如：\u000a 表示 \n。
- char類型是可以進行運算的。因為它都對應(yīng)有Unicode碼。
/*③ 可以表示的形式：形式一：一個具體的字符
形式二：一個轉(zhuǎn)義字符。比如：\n \t
形式三：使用unicode格式表示。比如:'\u12ab'
形式四：可以賦值ascii碼表字符對應(yīng)的整數(shù)，代表對應(yīng)字符'';
*/
//形式一：
char c = 'A';
char c = '中‘;
//形式二：
char c = '\n';
//形式三：
char c = '\u12ab';
//形式四：
char c = 97; //c=a
4.3.1 了解：ASCII碼
在計算機內(nèi)部，所有數(shù)據(jù)都使用
二進制表示。每一個二進制位（bit）有 0 和 1 兩種狀態(tài)，因此 8 個二進制位就可以組合出256種狀態(tài)，這被稱為一個字節(jié)（byte）。一個字節(jié)一共可以用來表示 256 種不同的狀態(tài)，每一個狀態(tài)對應(yīng)一個符號，就是 256 個符號，從 0000000 到 11111111。ASCII碼：上個世紀60年代，美國制定了一套字符編碼，對英語字符與二進制位之間的關(guān)系，做了統(tǒng)一規(guī)定。這被稱為ASCII碼。ASCII碼一共規(guī)定了
128個字符的編碼，比如空格“SPACE”是32（二進制00100000），大寫的字母A是65（二進制01000001）。這128個符號（包括32個不能打印出來的控制符號），只占用了一個字節(jié)的后面7位，最前面的1位統(tǒng)一規(guī)定為0。-
缺點：
- 不能表示所有字符。
- 相同的編碼表示的字符不一樣：比如，130在法語編碼中代表了é，在希伯來語編碼中卻代表了字母Gimel (?)
4.3.2 了解：Unicode碼
- 亂碼：世界上存在著多種編碼方式，同一個二進制數(shù)字可以被解釋成不同的符號。因此，要想打開一個文本文件，就必須知道它的編碼方式，否則用錯誤的編碼方式解讀，就會出現(xiàn)亂碼。
- Unicode：一種編碼，將世界上所有的符號都納入其中。每一個符號都給予一個獨一無二的編碼，使用 Unicode 沒有亂碼的問題。
- Unicode 的缺點：Unicode 只規(guī)定了符號的二進制代碼，卻沒有規(guī)定這個二進制代碼應(yīng)該如何存儲：無法區(qū)別 Unicode 和 ASCII：計算機無法區(qū)分三個字節(jié)表示一個符號還是分別表示三個符號。另外，我們知道，英文字母只用一個字節(jié)表示就夠了，如果unicode統(tǒng)一規(guī)定，每個符號用三個或四個字節(jié)表示，那么每個英文字母前都必然有二到三個字節(jié)是0，這對于存儲空間來說是極大的浪費。
4.3.3 了解：UTF-8
UTF-8 是在互聯(lián)網(wǎng)上使用最廣的一種 Unicode 的實現(xiàn)方式。
UTF-8 是一種變長的編碼方式。它可以使用 1-6 個字節(jié)表示一個符號，根據(jù)不同的符號而變化字節(jié)長度。
-
UTF-8的編碼規(guī)則：
- 對于單字節(jié)的UTF-8編碼，該字節(jié)的最高位為0，其余7位用來對字符進行編碼（等同于ASCII碼）。
- 對于多字節(jié)的UTF-8編碼，如果編碼包含 n 個字節(jié)，那么第一個字節(jié)的前 n 位為1，第一個字節(jié)的第 n+1 位為0，該字節(jié)的剩余各位用來對字符進行編碼。在第一個字節(jié)之后的所有的字節(jié)，都是最高兩位為"10"，其余6位用來對字符進行編碼。
4.4 布爾類型：boolean
- boolean 類型用來判斷邏輯條件，一般用于程序流程控制：
- if條件控制語句；
- while循環(huán)控制語句；
- do-while循環(huán)控制語句；
- for循環(huán)控制語句；
- boolean類型數(shù)據(jù)只允許取值true和false，無null。
- 不可以使用0或非 0 的整數(shù)替代false和true，這點和C語言不同。
- Java虛擬機中沒有任何供boolean值專用的字節(jié)碼指令，Java語言表達所操作的boolean值，在編譯之后都使用java虛擬機中的int數(shù)據(jù)類型來代替：true用1表示，false用0表示?！秊ava虛擬機規(guī)范 8版》
5. 基本數(shù)據(jù)類型間運算規(guī)則（掌握）
在Java程序中，不同的基本數(shù)據(jù)類型的值經(jīng)常需要進行相互轉(zhuǎn)換。Java語言所提供的七種數(shù)值類型之間可以相互轉(zhuǎn)換，基本數(shù)據(jù)類型轉(zhuǎn)換有兩種轉(zhuǎn)換方式：自動類型提升和強制類型轉(zhuǎn)換。boolean類型不參與。
5.1 自動類型提升
規(guī)則：將取值范圍小的類型自動提升為取值范圍大的類型 。
基本數(shù)據(jù)類型的轉(zhuǎn)換規(guī)則如圖所示：
（1）當把存儲范圍小的值（常量值、變量的值、表達式計算的結(jié)果值）賦值給了存儲范圍大的變量時。
int i = 'A';//char自動升級為int，其實就是把字符的編碼值賦值給i變量了
double d = 10;//int自動升級為double
byte b = 127; //右邊的整數(shù)常量值必須在-128~127范圍內(nèi)
//byte bigB = 130;//錯誤，右邊的整數(shù)常量值超過byte范圍
long num = 1234567; //右邊的整數(shù)常量值如果在int范圍呢，編譯和運行都可以通過，這里涉及到數(shù)據(jù)類型轉(zhuǎn)換
long bigNum = 12345678912L;//右邊的整數(shù)常量值如果超過int范圍，必須加L，否則編譯不通過
（2）當存儲范圍小的數(shù)據(jù)類型與存儲范圍大的數(shù)據(jù)類型一起混合運算時，會按照其中最大的類型運算。
int i = 1;
byte b = 1;
double d = 1.0;
double sum = i + b + d;//混合運算，升級為double
（3）當byte,short,char數(shù)據(jù)類型進行算術(shù)運算時，按照int類型處理。
byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//編譯報錯，b1 + b2自動升級為int
char c1 = '0';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int類型來接收
System.out.println(c1 + c2);//113
5.2 強制類型轉(zhuǎn)換
將1.5 賦值到int 類型變量會發(fā)生什么？產(chǎn)生編譯失敗，肯定無法賦值。
int i = 3.14; // 錯誤
想要賦值成功，只有通過強制類型轉(zhuǎn)換，將double 類型強制轉(zhuǎn)換成int 類型才能賦值。
規(guī)則：將取值范圍大的類型強制轉(zhuǎn)換成取值范圍小的類型。
比較而言，自動類型提升是Java自動執(zhí)行的，而強制類型轉(zhuǎn)換需要我們自己手動執(zhí)行。
轉(zhuǎn)換格式：
數(shù)據(jù)類型 變量名 = （數(shù)據(jù)類型）被強轉(zhuǎn)數(shù)據(jù)值; //()中的數(shù)據(jù)類型必須<=變量的數(shù)據(jù)類型，一般都是=
（1）當把存儲范圍大的值（常量值、變量的值、表達式計算的結(jié)果值）賦值給了存儲范圍小的變量時，需要強制類型轉(zhuǎn)換。這種轉(zhuǎn)換有風(fēng)險，可能會損失精度或溢出
int i = (int)3.14;//強制類型轉(zhuǎn)換，損失精度
double d = 1.2;
int num = (int)d;//損失精度
int i = 200;
byte b = (byte)i;//溢出
（2）當某個值想要提升數(shù)據(jù)類型時，也可以使用強制類型轉(zhuǎn)換。這種情況的強制類型轉(zhuǎn)換是沒有風(fēng)險的。
int i = 1;
int j = 2;
double bigger = (double)i/j;
練習(xí)：判斷是否能通過編譯
1）short s = 5;
s = s-2; //判斷：
2） byte b = 3;
b = b + 4; //判斷：
b = (byte)(b+4); //判斷：
3）char c = ‘a(chǎn)’;
int i = 5;
float d = .314F;
double result = c+i+d; //判斷：
4） byte b = 5;
short s = 3;
short t = s + b; //判斷：
5.3 基本數(shù)據(jù)類型與字符串類型的運算
5.3.1 字符串類型：String
String不是基本數(shù)據(jù)類型，屬于引用數(shù)據(jù)類型
使用方式與基本數(shù)據(jù)類型一致。例如：String str = “abcd”;
5.3.2 運算規(guī)則
1、任意八種基本數(shù)據(jù)類型的數(shù)據(jù)與String類型進行“+”運算時，結(jié)果一定是String類型
System.out.println("" + 1 + 2);//12
2、但是String類型不能通過強制類型()轉(zhuǎn)換，轉(zhuǎn)為其他的類型
String str = "123";
int num = (int)str;//錯誤的
int num = Integer.parseInt(str);//正確的，后面才能講到，借助包裝類的方法才能轉(zhuǎn)
練習(xí)：
String str1 = 4; //判斷對錯：
String str2 = 3.5f + “”; //判斷str2對錯：
System.out.println(str2); //輸出：
System.out .println(3+4+“Hello!”); //輸出：
System.out.println(“Hello!”+3+4); //輸出：
System.out.println(‘a(chǎn)’+1+“Hello!”); //輸出：
System.out.println(“Hello”+‘a(chǎn)’+1); //輸出：
6. 計算機底層如何存儲數(shù)據(jù)
計算機世界中只有二進制，所以計算機中存儲和運算的所有數(shù)據(jù)都要轉(zhuǎn)為二進制。包括數(shù)字、字符、圖片、聲音、視頻等。
世界上有10種人 ，認識和不認識二進制的。
6.1 進制的分類
-
十進制（decimal）
- 數(shù)字組成：0-9
- 進位規(guī)則：滿十進一，以0b或0B開頭
-
二進制（binary）
- 數(shù)字組成：0-1
- 進位規(guī)則：滿二進一
-
八進制（octal）：很少使用
- 數(shù)字組成：0-7
- 進位規(guī)則：滿八進一，以數(shù)字0開頭表示
-
十六進制
- 數(shù)字組成：0-9，a-f
- 進位規(guī)則：滿十六進一，以0x或0X開頭表示。此處的 a-f 不區(qū)分大小寫
6.2 進制的換算舉例
| 十進制 | 二進制 | 八進制 | 十六進制 |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 2 | 10 | 2 | 2 |
| 3 | 11 | 3 | 3 |
| 4 | 100 | 4 | 4 |
| 5 | 101 | 5 | 5 |
| 6 | 110 | 6 | 6 |
| 7 | 111 | 7 | 7 |
| 8 | 1000 | 10 | 8 |
| 9 | 1001 | 11 | 9 |
| 10 | 1010 | 12 | a或A |
| 11 | 1011 | 13 | b或B |
| 12 | 1100 | 14 | c或C |
| 13 | 1101 | 15 | d或D |
| 14 | 1110 | 16 | e或E |
| 15 | 1111 | 17 | f或F |
| 16 | 10000 | 20 | 10 |
6.3 二進制如何表示整數(shù)？
- 計算機數(shù)據(jù)的存儲使用二進制補碼形式存儲，并且最高位是符號位，最高位1是負數(shù)，最高位0是正數(shù)。
-
規(guī) 定
- 正數(shù)的補碼與反碼、原碼一樣，稱為三碼合一
- 負數(shù)的補碼與反碼、原碼不一樣：
- 負數(shù)的原碼：把十進制轉(zhuǎn)為二進制，然后最高位設(shè)置為1
- 負數(shù)的反碼：在原碼的基礎(chǔ)上，最高位不變，其余位取反（0變1,1變0）
- 負數(shù)的補碼：反碼+1
-
例如：byte類型（1個字節(jié)，8位）
25 ==> 原碼 0001 1001 ==> 反碼 0001 1001 -->補碼 0001 1001
-25 ==>原碼 1001 1001 ==> 反碼1110 0110 ==>補碼 1110 0111
整數(shù)：
正數(shù)：25 00000000 00000000 000000000 00011001（原碼）
正數(shù)：25 00000000 00000000 000000000 00011001（反碼）
正數(shù)：25 00000000 00000000 000000000 00011001（補碼）
負數(shù)：-25 10000000 00000000 000000000 00011001（原碼）
負數(shù)：-25 11111111 11111111 111111111 11100110（反碼）
負數(shù)：-25 11111111 11111111 111111111 11100111（補碼）
為什么要使用原碼、反碼、補碼表示形式呢？
計算機辨別“符號位”顯然會讓計算機的基礎(chǔ)電路設(shè)計變得十分復(fù)雜! 于是人們想出了將符號位也參與運算的方法. 我們知道, 根據(jù)運算法則減去一個正數(shù)等于加上一個負數(shù), 即: 1-1 = 1 + (-1) = 0 , 所以機器可以只有加法而沒有減法, 這樣計算機運算的設(shè)計就更簡單了。
一個字節(jié)可以存儲的整數(shù)范圍是多少？
1個字節(jié)：8位
0000 0001 ~ 0111 111 ==> 1~127
1000 0001 ~ 1111 1111 ==> -127 ~ -1
0000 0000 ==>0
1000 0000 ==> -128（特殊規(guī)定）=-127-1
6.4 十進制轉(zhuǎn)二進制
十進制轉(zhuǎn)二進制：除2取余的逆
6.5 二進制與八進制、十六進制間的轉(zhuǎn)換
二進制轉(zhuǎn)八進制
二進制轉(zhuǎn)十六進制
八進制、十六進制轉(zhuǎn)二進制
6.6 進制間的轉(zhuǎn)換
練習(xí)：
1.將以下十進制數(shù)轉(zhuǎn)換為十六進制和二進制
123 256 87 62
2.將以下十六進制數(shù)轉(zhuǎn)換為十進制和二進制
0x123 0x25F 0x38 0x62
7. 運算符（Operator）（掌握）
運算符是一種特殊的符號，用以表示數(shù)據(jù)的運算、賦值和比較等。
運算符的分類：
- 按照
功能分為：算術(shù)運算符、賦值運算符、比較(或關(guān)系)運算符、邏輯運算、位運算符、條件(或三元)運算符、Lambda運算符
| 分類 | 運算符 |
|---|---|
| 算術(shù)運算符（7個） | +、-、*、/、%、++、-- |
| 賦值運算符（12個） | =、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等 |
| 比較(或關(guān)系)運算符（6個） | >、>=、<、<=、==、!= |
| 邏輯運算符（6個） | &、|、^、!、&&、|| |
| 位運算符（7個） | &、|、^、~、<<、>>、>>> |
| 條件運算符（1個） | (條件表達式)?結(jié)果1:結(jié)果2 |
| Lambda運算符（1個） | ->（后面學(xué)） |
- 按照
操作數(shù)個數(shù)分為：一元運算符（單目運算符）、二元運算符（雙目運算符）、三元運算符 （三目運算符）
| 分類 | 運算符 |
|---|---|
| 一元運算符（單目運算符） | 正號（+）、負號（-）、++、--、!、~ |
| 二元運算符（雙目運算符） | 除了一元和三元運算符剩下的都是二元運算符 |
| 三元運算符 （三目運算符） | (條件表達式)?結(jié)果1:結(jié)果2 |
7.1 算術(shù)運算符
舉例1：加減乘除模
public class OperatorDemo01 {
public static void main(String[] args) {
int a = 3;
int b = 4;
System.out.println(a + b);// 7
System.out.println(a - b);// -1
System.out.println(a * b);// 12
System.out.println(a / b);// 計算機結(jié)果是0，為什么不是0.75呢？
System.out.println(a % b);// 3
System.out.println(5%2);//1
System.out.println(5%-2);//1
System.out.println(-5%2);//-1
System.out.println(-5%-2);//-1
//商*除數(shù) + 余數(shù) = 被除數(shù)
//5%-2 ==>商是-2，余數(shù)時1 (-2)*(-2)+1 = 5
//-5%2 ==>商是-2，余數(shù)是-1 (-2)*2+(-1) = -4-1=-5
}
}
舉例2：“+”號的兩種用法
- 第一種：對于
+兩邊都是數(shù)值的話，+就是加法的意思 - 第二種：對于
+兩邊至少有一邊是字符串的話，+就是拼接的意思
public class OperatorDemo02 {
public static void main(String[] args) {
// 字符串類型的變量基本使用
// 數(shù)據(jù)類型 變量名稱 = 數(shù)據(jù)值;
String str1 = "Hello";
System.out.println(str1); // Hello
System.out.println("Hello" + "World"); // HelloWorld
String str2 = "Java";
// String + int --> String
System.out.println(str2 + 520); // Java520
// String + int + int
// String + int
// String
System.out.println(str2 + 5 + 20); // Java520
}
}
舉例3：自加自減運算
理解：++ 運算，變量自己的值加1。反之，-- 運算，變量自己的值減少1，用法與++ 一致。
1、單獨使用
- 變量在單獨運算的時候，變量
前++和變量后++，變量的是一樣的； - 變量
前++：例如++a。 - 變量
后++：例如a++。
public class OperatorDemo3 {
public static void main(String[] args) {
// 定義一個int類型的變量a
int a = 3;
//++a;
a++;
// 無論是變量前++還是變量后++，結(jié)果都是4
System.out.println(a);
}
}
2、復(fù)合使用
- 和
其他變量放在一起使用或者和輸出語句放在一起使用，前++和后++就產(chǎn)生了不同。
- 變量
前++：變量先自身加1，然后再取值。 - 變量
后++：變量先取值，然后再自身加1。
public class OperatorDemo03 {
public static void main(String[] args) {
// 其他變量放在一起使用
int x = 3;
//int y = ++x; // y的值是4，x的值是4，
int y = x++; // y的值是3，x的值是4
System.out.println(x);
System.out.println(y);
System.out.println("==========");
// 和輸出語句一起
int z = 5;
//System.out.println(++z);// 輸出結(jié)果是6，z的值也是6
System.out.println(z++);// 輸出結(jié)果是5，z的值是6
System.out.println(z);
int a = 1;
a = a++;//(1)先取a的值“1”放操作數(shù)棧(2)a再自增,a=2(3)再把操作數(shù)棧中的"1"賦值給a,a=1
int i = 1;
int j = i++ + ++i * i++;
/*
從左往右加載
(1)先算i++
①取i的值“1”放操作數(shù)棧
②i再自增 i=2
（2）再算++i
①i先自增 i=3
②再取i的值“3”放操作數(shù)棧
（3）再算i++
①取i的值“3”放操作數(shù)棧
②i再自增 i=4
（4）先算乘法
用操作數(shù)棧中3 * 3 = 9，并把9壓會操作數(shù)棧
（5）再算求和
用操作數(shù)棧中的 1 + 9 = 10
（6）最后算賦值
j = 10
*/
}
}
- 小結(jié)：
- ++在前，先自加，后使用；
- ++在后，先使用，后自加。
練習(xí)1：算術(shù)運算符：自加、自減
public class SignTest{
public static void main(String[] args){
int i1 = 10;
int i2 = 20;
int i = i1++; //i=10 i1=11
System.out.print(“i=”+i);
System.out.println(“i1=”+i1);
i = ++i1; //i=12 i1=12
System.out.print(“i=”+i);
System.out.println(“i1=”+i1);
i = i2--; //i=12 i2=11
System.out.print(“i=”+i);
System.out.println(“i2=”+i2);
i = --i2; //i=10 i2=10
System.out.print(“i=”+i);
System.out.println(“i2=”+i2);
}
}
練習(xí)2：
隨意給出一個整數(shù)，打印顯示它的個位數(shù)，十位數(shù)，百位數(shù)的值。
格式如下：
數(shù)字xxx的情況如下：
個位數(shù)：
十位數(shù)：
百位數(shù)：
例如：
數(shù)字153的情況如下：
個位數(shù)：3
十位數(shù)：5
百位數(shù)：1
int num = 153;
int ge = num % 10; //個位
int shi = num / 10 % 10; //十位
int bai = num / 100 % 10; //百位
7.2 賦值運算符
-
符號：=
- 當“=”兩側(cè)數(shù)據(jù)類型不一致時，可以使用自動類型轉(zhuǎn)換或使用強制類型轉(zhuǎn)換原則進行處理。
- 支持連續(xù)賦值。
擴展賦值運算符： +=, -=, *=, /=, %=
public class OperatorDemo04 {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = a + b;
b += a;// 相當于 b = b + a ;
System.out.println(a); // 3
System.out.println(b); // 7
System.out.println(c); //7
short s = 3;
// s = s + 4; 代碼編譯報錯，因為將int類型的結(jié)果賦值給short類型的變量s時，可能損失精度
s += 4; // 代碼沒有報錯
//因為在得到int類型的結(jié)果后，JVM自動完成一步強制類型轉(zhuǎn)換，將int類型強轉(zhuǎn)成short
System.out.println(s);
int j = 1;
j += ++j * j++;//相當于 j = j + (++j * j++);
System.out.println(j);//5
int m = 1;
m <<= 2; //m=m << 2 = m * 2 * 2;
System.out.println(m); //4
}
}
思考1：
short s = 3;
s = s+2; ①
s += 2; ②
①和②有什么區(qū)別？
① 會編譯報錯，因為s（short）和 2（int）相加，自動提升為int，再賦值給short，會編譯報錯
需要這樣修改：s = (short)(s + 2);
② 編譯通過，s+=2 中間不會提升類型
思考2：
int i = 1;
i *= 0.1;
System.out.println(i);//0 因為是 *= i的類型不會提升為double 所以值為 0
i++;
System.out.println(i);//1
思考3：
int m = 2;
int n = 3;
n *= m++; //n = n * m (m++) => n=2*3 m=3
System.out.println("m=" + m); //3
System.out.println("n=" + n); //6
思考4：
int n = 10;
n += (n++) + (++n); //n= 10 + 10(n=11)+12(n=12) = 32
System.out.println(n); //32
7.3 關(guān)系運算符/比較運算符
- 比較運算符的結(jié)果都是boolean型，也就是要么是true，要么是false。
- 比較運算符“==”不能誤寫成“=” 。
思考：
boolean b1 = false;
//區(qū)分好==和=的區(qū)別。
if(b1=true) //由于 b1=true 是直接賦值成了true，
System.out.println("結(jié)果為真");
else
System.out.println("結(jié)果為假");
//結(jié)果為真
7.4 邏輯運算符
- 邏輯運算符，是用來連接兩個布爾類型值的運算符（
!除外），運算結(jié)果也是boolean值true或者false
- 邏輯運算符用于連接布爾型表達式，在Java中不可以寫成3<x<6，應(yīng)該寫成x>3 & x<6 。
-
“&（與）”和“&&（短路與）”的區(qū)別：
- 單&時，左邊無論真假，右邊都進行運算；
- 雙&時，如果左邊為真，右邊參與運算，如果左邊為假，那么右邊不參與運算。
“|（或）”和“||（短路或）”的區(qū)別同理，||表示：當左邊為真，右邊不參與運算。
- 異或( ^ )與或( | )的不同之處是：當左右都為true時，結(jié)果為false。
- 理解：異或，追求的是“異”!
public class OperatorDemo06 {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;
// & 與，且；有false則false
System.out.println((a > b) & (a > c)); //false & false =false
System.out.println((a > b) & (a < c)); //false & false = false
System.out.println((a < b) & (a > c)); //true & false = false
System.out.println((a < b) & (a < c)); //true & true = true
System.out.println("===============");
// | 或；有true則true
System.out.println((a > b) | (a > c)); //false | false = false
System.out.println((a > b) | (a < c)); //false | true = true
System.out.println((a < b) | (a > c)); //true | false = true;
System.out.println((a < b) | (a < c)); //true | true = true
System.out.println("===============");
// ^ 異或；相同為false，不同為true
System.out.println((a > b) ^ (a > c)); //false | false = false
System.out.println((a > b) ^ (a < c)); //false | true = true
System.out.println((a < b) ^ (a > c)); //true | false = true
System.out.println((a < b) ^ (a < c)); //true | true = true
System.out.println("===============");
// ! 非；非false則true，非true則false
System.out.println(!false); //true
System.out.println(!true); //false
//&和&&的區(qū)別
System.out.println((a > b) & (a++ > c)); //false & 3>5(false) =false
System.out.println("a = " + a); //a=4
System.out.println((a > b) && (a++ > c)); //false && (前為false，后不執(zhí)行)
System.out.println("a = " + a); //a=4
System.out.println((a == b) && (a++ > c)); //true && 4>5 false =false
System.out.println("a = " + a); //5
//|和||的區(qū)別
System.out.println((a > b) | (a++ > c)); //true | 5 > 5(false) =true
System.out.println("a = " + a); //a=6
System.out.println((a > b) || (a++ > c)); // true || (之后不執(zhí)行)=true
System.out.println("a = " + a); //a=6
System.out.println((a == b) || (a++ > c)); //false || 6 > 5(true) = true
System.out.println("a = " + a); //7
}
}
練習(xí)：請寫出每題的輸出結(jié)果
int x = 1;
int y=1;
if(x++==2 & ++y==2){ //1(x=2)==2 false & 2(y=2)==2 true = false
x =7;
}
System.out.println("x="+x+",y="+y); //x=2 y=2
int x = 1,y = 1;
if(x++==2 && ++y==2){ //1(x=2)==2 false && = false
x =7;
}
System.out.println("x="+x+",y="+y); //x=2 y=1
int x = 1,y = 1;
if(x++==1 | ++y==1){ //1(x=2)==1 true | 2(y=2)==1 =true
x =7;
}
System.out.println("x="+x+",y="+y); //x=7 y=2
int x = 1,y = 1;
if(x++==1 || ++y==1){ //1(x=2)==1 true || =true
x =7;
}
System.out.println("x="+x+",y="+y); //x=7 y=2
練習(xí)：程序輸出
1． class Test {
2. public static void main (String [] args) {
3． boolean x=true;
4． boolean y=false;
5． short z=42;
6． //if(y == true)
7. if( (z++==42) && (y=true) )z++; //42(z=43)==42 true && true = true z=44
8. if((x=false) || (++z==45)) z++; //false || 45(z=45)==45 true = true z=46
9．
10. System. out.println("z="+z); //46
11. }
12. }
//結(jié)果為：
//z= 46
7.5 位運算符
- 位運算符的運算過程都是基于二進制的補碼運算
（1）左移：<<
運算規(guī)則：左移幾位就相當于乘以2的幾次方
**注意：**當左移的位數(shù)n超過該數(shù)據(jù)類型的總位數(shù)時，相當于左移（n-總位數(shù)）位
byte,short,char在計算時按照int類型處理
3<<4 類似于 3*2的4次= 3*16 = 48
-3<<4 類似于 -3*2的4次= -3*16 = -48
（2）右移：>>
快速運算：類似于除以2的n次，如果不能整除，向下取整
69>>4 類似于 69/2的4次 = 69/16 =4
-69>>4 類似于 -69/2的4次 = -69/16 = -5
（3）無符號右移：>>>
運算規(guī)則：往右移動后，左邊空出來的位直接補0，不看符號位
正數(shù)：和右移一樣
負數(shù)：右邊移出去幾位，左邊補幾個0，結(jié)果變?yōu)檎龜?shù)
69>>>4 類似于 69/2的4次 = 69/16 =4
-69>>>4 結(jié)果：268435451
（4）按位與：&
運算規(guī)則：對應(yīng)位都是1才為1
1 & 1 結(jié)果為1
1 & 0 結(jié)果為0
0 & 1 結(jié)果為0
0 & 0 結(jié)果為0
9&7 = 1
-9&7 = 7
（5）按位或：|
運算規(guī)則：對應(yīng)位只要有1即為1
1 | 1 結(jié)果為1
1 | 0 結(jié)果為1
0 | 1 結(jié)果為1
0 & 0 結(jié)果為0
9|7 結(jié)果： 15
-9|7 結(jié)果： -9
（6）按位異或：^
運算規(guī)則：對應(yīng)位一個為1一個為0，才為1
1 ^ 1 結(jié)果為0
1 ^ 0 結(jié)果為1
0 ^ 1 結(jié)果為1
0 ^ 0 結(jié)果為0
9^7 結(jié)果為14
-9^7 結(jié)果為-16
（7）按位取反：~
運算規(guī)則：~0就是1
~1就是0
~9 結(jié)果：-10
~-9 結(jié)果：8
練習(xí)1：
練習(xí)2：體會 m = k ^ n = (m ^ n) ^ n
練習(xí)3：交換兩個變量值的操作
//方式1：定義一個臨時變量 。更具有通用性
int temp = a;
a = b;
b = temp;
//方式2：數(shù)學(xué)運算的方式
//a = a + b;//30 = 10 + 20
//b = a - b;// 10 = 30 - 20
//a = a - b;//20 = 30 - 10
//方式3： 體會 a ^ b ^ a ---> b r
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println("a = " + a + ", b = " + b);
練習(xí)4：二進制轉(zhuǎn)十六進制
int num = 60;
int j1 = num & 15;
String s1 = (j1 > 9)? (char)(j1 - 10 + 'A') + "" : j1 + "";//取出了最低的4位對應(yīng)的字符
int j2 = (num >> 4) & 15;
String s2 = (j2 > 9)? (char)(j2 - 10 + 'A') + "" : j2 + "";//取出了次最低的4位對應(yīng)的字符
System.out.println(s2 + s1);
7.6 條件運算符
- 條件運算符格式：
(條件表達式)? 表達式1:表達式2
- 說明：
① 條件表達式必須是boolean類型的
② 表達1和表達式2數(shù)據(jù)類型一致即可
③ 結(jié)論：凡是使用條件運算符的結(jié)構(gòu) 都可以改寫成if-else結(jié)構(gòu);反之，不成立。
如果遇到既可以使用條件運算符，又可以使用if-else結(jié)構(gòu)的場景，建議使用條件運算符。因為效率稍高
public static void main(String[] args) {
int i = (1==2 ? 100 : 200);
System.out.println(i);//200
int j = (3<=4 ? 500 : 600);
System.out.println(j);//500
}
public class ConditionOperator{
public static void main(String[] args){
//判斷兩個變量a,b誰大，把大的變量賦值給max
int a = 2;
int b = 2;
int max = a >= b ? a : b;
//如果a>=b成立，就取a的值賦給max，否則取b的值賦給max
System.out.println(max);
boolean marry = false;
System.out.println(marry ? "已婚" : "未婚" );
}
}
- 表達式1和表達式2為同種類型
- 條件運算符的嵌套使用。不建議使用，因為可讀性差
練習(xí)：
獲取兩個數(shù)中的較大數(shù)
獲取三個數(shù)中的較大數(shù)
//方式1：
int max1 = (n1 > n2)? n1 : n2;
int max2 = (max1 > n3)? max1 : n3;
System.out.println("最大值為：" + max2);
//方式2：條件運算符的嵌套使用。不建議使用，因為可讀性差
int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
System.out.println("最大值為：" + max3);
7.7 運算符優(yōu)先級
提示說明：
（1）表達式不要太復(fù)雜
（2）先算的使用()
