Java基礎語法
1、變量
2、運算符
01.變量概述
* A: 什麼是變量?
* a: 變量是一個內存中的小盒子（小容器），容器是什麼？生活中也有很多容器，例如水杯是容器，用來裝載水；你家裏的大衣櫃是容器，用來裝載衣褲；飯盒是容器，用來裝載飯菜。那麼變量是裝載什麼的呢？答案是數據！結論：變量是內存中裝載數據的小盒子，你只能用它來存數據和取數據。
02.計算機存儲單元
* A: 計算機中儲存和運算的最小單位是?
* a: 一個字節,也就是一個byte.
* win+r--cmd--回車
* b: 常用儲存單位
*1B（字節） = 8bit
*1KB = 1024B
*1MB = 1024KB
*1GB = 1024MB
*1TB = 1024GB
*1PB = 1024TB
03.Java中數據類型四類八種
* A: 數據類型四類八種
*四類 八種 字節數 數據表示範圍
*整型 byte 1 -128～127
short 2 -32768～32767
int 4 -2147483648～2147483648
long 8 -263～263-1
*浮點型 float 4 -3.403E38～3.403E38
double 8 -1.798E308～1.798E308
*字符型 char 2 表示一個字符，如('a'，'A'，'0'，'家')
*布爾型 boolean 1 只有兩個值true與false
04.常量和數據類型
* A:常量的定義
* a: 整形常量默認是int類型
* b: 小數常量默認是double類型
* c: 定義長整形數據如果值超過int取值範圍後面要+"L"
* d: 定義float類型的數據後面要+"f" 否則默認是double
05.變量創建的三要素
* A: 定義變量的語法格式：
數據類型 變量名 = 變量值;
* int a = 100;
* B:代碼:
public class Variable {
public static void main(String[] args) {
int a = 10;
double b = 3.14;
char c = 'z';
String s = "i love java";
a = 20;
System.out.println(a);
}
}06.定義所有的基本數據類型變量
* A: 案例演示
* a: 八種基本類型數據的創建
07.定義字符串變量
* A：案例演示
* 創建字符串數據類型變量
* String 是引用數據類型
08.變量定義使用注意事項
* A：變量使用的注意事項
* a: 變量定義後可以不賦值，使用時再賦值。不賦值不能使用。
public static void main(String[] args) {
int x;
x = 20; //爲x賦值20
System.out.println(x);//讀取x變量中的值，再打印
}
* c: 變量使用時有作用域的限制。
public static void main(String[] args) {
int x = 20;
{
int y = 20;
}
System.out.println(x);//讀取x變量中的值，再打印
System.out.println(y);//讀取y變量中的值失敗，失敗原因，找不到y變量，因爲超出了y變量作用範圍，所以不能使用y變量
}
09.數據類型轉換_自動轉換
* A: 自動類型轉換
* a:表示範圍小的數據類型轉換成範圍大的數據類型，這種方式稱爲自動類型轉換
自動類型轉換格式：
範圍大的數據類型 變量 = 範圍小的數據類型值；
如：
double d = 1000;
或
int i = 100;
double d2 = i;
10.數據類型轉換_強制轉換
* A: 強制類型轉換
*a: 表示範圍大的數據類型轉換成範圍小的數據類型，這種方式稱爲強制類型轉換
*b: 強制類型轉換格式：
範圍小的數據類型 變量 = (範圍小的數據類型) 範圍大的數據類型值;
如：
int i = (int)6.718; //i的值爲6
或
double d = 3.14;
int i2 = (int)d; //i2的值爲3
11.算數運算符_1
* A: 常見操作
運算符 運算規則 範例 結果
+ 正號 +3 3
+ 加 2+3 5
+ 連接字符串 “中”+“國” “中國”
- 負號 int a=3;-a -3
- 減 3-1 2
* 乘 2*3 6
/ 除 5/2 2
% 取模 5/2 1
++ 自增 int a=1;a++/++a 2
-- 自減 int b=3;a--/--a 2
* B: 注意事項
*a:加法運算符在連接字符串時要注意，只有直接與字符串相加纔會轉成字符串。
*b:除法“/”當兩邊爲整數時，取整數部分，舍餘數。當其中一邊爲浮點型時，按正常規則相除。
*c:“%”爲整除取餘符號，小數取餘沒有意義。結果符號與被取餘符號相同。
*d:整數做被除數，0不能做除數，否則報錯。
*e:小數做被除數，整除0結果爲Infinity，對0取模結果爲NaN
* C:代碼演示
public class OperatorDemo1 {
public static void main(String[] args) {
/*
* 常量使用算數運算符
*/
System.out.println(10+20);
/*
* 變量使用算數運算符
*/
int x = 10;
int y = 20;
//"+"作爲加法運算使用
int z = x + y;
//"+"作爲連接字符串使用
System.out.println("x="+x);
System.out.println("y="+y);
System.out.println("z="+z);
}
}12.算數運算符_2
* A:算數運算符++、--的使用
* a: ++運算符，會在原有值的基礎上自增1
* b: --運算符，會在原有值的基礎上自減1。
* B:++ -- 位置的使用
* a:++,--運算符後置時，先使用變量a原有值參與運算操作，運算操作完成後，變量a的值自增1或者自減1；
* b:++，--運算符前置時，先將變量a的值自增1或者自減1，然後使用更新後的新值參與運算操作。
13.賦值運算符
* A: 賦值運算符的使用
運算符 運算規則 範例 結果
= 賦值 int a=2 2
+= 加後賦值 int a=2，a+=2 4
-= 減後賦值 int a=2，a-=2 0
*= 乘後賦值 int a=2，a*=2 4
/= 整除後賦值 int a=2，a/=2 1
%= 取模後賦值 int a=2，a%=2 0
* B：案例演示
* 賦值運算符
* +=, -=, *=, /=, %= ：
* 上面的運算符作用：將等號左右兩邊計算，會將結果自動強轉成等號左邊的數據類型,再賦值給等號左邊的
* 注意：賦值運算符左邊必須是變量
public class OperatorDemo2 {
public static void main(String[] args) {
byte x = 10;
x += 20;// 相當於 x = (byte)(x+20);
System.out.println(x);
}
}14.比較運算符
* A:比較運算符的使用
運算符 運算規則 範例 結果
== 相等於 4==3 False
!= 不等於 4!=3 True
< 小於 4<3 False
> 大於 4>3 True
<= 小於等於 4<=3 False
>= 大於等於 4>=3 True
15.邏輯運算符
* A: 邏輯運算符的使用
運算符 運算規則 範例 結果
& 與 false&true False
| 或 false|true True
^ 異或 true^flase True
! 非 !true Flase
&& 短路與 false&&true False
|| 短路或 false||true True
規律小結:
短路與&&:參與運算的兩邊數據，有false，則運算結果爲false；
短路或||:參與運算的兩邊數據，有true，則運算結果爲true；
邏輯非! : 參與運算的數據，原先是true則變成false，原先是false則變成true。
16.三元運算符
* A: 格式:
(條件表達式)？表達式1：表達式2；
* B: 代碼案例
方式一：
System.out.println( 3>2 ? “正確” : “錯誤” );
// 三元運算符運算後的結果爲true，運算結果爲表達式1的值“正確”，然後將結果“正確”，在控制檯輸出打印
方式二：
int a = 3;
int b = 4;
String result = (a==b) ? “相等” : “不相等”;
//三元運算符運算後的結果爲false，運算結果爲表達式2的值“不相等”，然後將結果賦值給了變量result
方式三：
int n = (3>2 && 4>6) ? 100 : 200;
//三元運算符運算後的結果爲false，運算結果爲表達式2的值200,然後將結果200賦值給了變量n
17.運算符優先級
優先級 描述 運算符
1 括號 ()、[]
2 正負號 +、-
3 自增自減，非 ++、--、!
4 乘除，取餘 *、/、%
5 加減 +、-
6 移位運算 <<、>>、>>>
7 大小關係 >、>=、<、<=
8 相等關係 ==、!=
9 按位與 &
10 按位異或 ^
11 按位或 |
12 邏輯與 &&
13 邏輯或 ||
14 條件運算 ?:
15 賦值運算 =、+=、-=、*=、/=、%=
16 位賦值運算 &=、|=、<<=、>>=、>>>=
18. 商場庫存清單案例
A: 案例分析.
* a:觀察清單後，可將清單分解爲三個部分（清單頂部、清單中部、清單底部）
* b:清單頂部爲固定的數據，直接打印即可
* c:清單中部爲商品，爲變化的數據，需要記錄商品信息後，打印
經過觀察，我們確定一項商品應該有如下幾個屬性：
品牌型號: 即商品名稱，String型
尺寸：物品大小，double型
價格：物品單價，double型
配置：這一項爲每種商品的配置信息，String型
庫存數：這一項爲每種商品的庫存個數，int型
* d:清單底部包含了統計操作，需經過計算後，打印
我們發現兩個單獨的可變化量
總庫存數：所有商品總個數，int型
庫存商品總金額：所有商品金額，double型
B: 案例代碼實現
//步驟一: 創建Demo01庫存清單.java文件，編寫main主方法
public class Demo01庫存清單 {
public static void main(String[] args) {
}
}
//步驟二: 記錄每種庫存商品信息
//蘋果筆記本電腦
String macBrand = "MacBookAir";
double macSize = 13.3;
double macPrice = 6988.88;
int macCount = 5;
//聯想Thinkpad筆記本電腦
String thinkpadBrand = "ThinkpadT450";
double thinkpadSize = 14.0;
double thinkpadPrice = 5999.99;
int thinkpadCount = 10;
//華碩ASUS筆記本電腦
String ASUSBrand = "ASUS-FL5800";
double ASUSSize = 15.6;
double ASUSPrice = 4999.50;
int ASUSCount = 18;
//步驟三: 統計庫存總個數、庫存總金額
int totalCount = macCount + thinkpadCount + ASUSCount;
double totalMoney = (macCount * macPrice) + (thinkpadCount * thinkpadPrice) + (ASUSCount * ASUSPrice);
//步驟四: 列表頂部
System.out.println("-------------------商城庫存清單-------------------");
System.out.println("品牌型號 尺寸 價格 庫存數");
// 步驟四:打印庫存清單中部信息
//列表中部
System.out.println(macBrand+" "+macSize+" "+macPrice+" "+macCount);
System.out.println(thinkpadBrand+" "+thinkpadSize+" "+thinkpadPrice+" "+thinkpadCount);
System.out.println(ASUSBrand+" "+ASUSSize+" "+ASUSPrice+" "ASUSCount);
// 打印庫存清單底部信息
//列表底部
System.out.println("------------------------------------------------------");
System.out.println("總庫存數："+totalCount);
System.out.println("庫存商品總金額："+totalMoney);今日內容介紹
* 變量
* 運算符
1. 變量
1. 變量概述
前面我們已經學習了常量，接下來我們要學習變量。在Java中變量的應用比常量的應用要多很多。所以變量也是尤爲重要的知識點！
什麼是變量？變量是一個內存中的小盒子（小容器），容器是什麼？生活中也有很多容器，例如水杯是容器，用來裝載水；你家裏的大衣櫃是容器，用來裝載衣褲；飯盒是容器，用來裝載飯菜。那麼變量是裝載什麼的呢？答案是數據！結論：變量是內存中裝載數據的小盒子，你只能用它來存數據和取數據。
1. 計算機存儲單元
變量是內存中的小容器，用來存儲數據。那麼計算機內存是怎麼存儲數據的呢？無論是內存還是硬盤，計算機存儲設備的最小信息單元叫“位（bit）”，我們又稱之爲“比特位”，通常用小寫的字母b表示。而計算機最小的存儲單元叫“字節（byte）”，通常用大寫字母B表示，字節是由連續的8個位組成。
當程序需要使用存儲空間時，操作系統最小會分派給程序1個字節，而不是1個位。你可能會說，如果程序只需要1個位的空間，系統分派不能只分派1個位嗎？答案是不能！這就像你只需要1支菸，你到商店去買菸，商店分派的最小單元是1盒（20支），他不可能賣給你1支菸。
你可能會想，1個字節（8位）可以存儲很大的數值了，1位最大是9那麼8位最大值爲99999999。你錯了，因爲計算機是採用二進行存儲的，而不是我們生活中常用的十進制。所以1個字節存儲的最大數據是11111111的二進制數。
除了字節外還有一些常用的存儲單位，大家可能比較熟悉，我們一起來看看：
1B（字節） = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
1. 基本類型之4類8種
大衣櫃不能用來裝載水，水杯也不能用來裝載衣褲。這說明不同的容器裝載不同的物品。變量也是如此，在創建變量時需要指定變量的數據類型，例如整型變量、浮點型變量等等。結論：變量必須要有明確的類型，什麼類型的變量裝載什麼類型的數據。
水杯是用來裝水的，那麼水杯能裝多少水呢？一噸？我們知道水杯在創建時不只確定了要裝載的是水（數據類型），而且還確定了能裝多少水（數據類型的具體種類）。變量也是如此，需要指定變量能裝載什麼類型的數據，同時也要指定變量能裝載多大的數據。
Java中基本類型一共4類，把這4類展開後共8種基本類型。我們今後編寫程序時使用的是這8種基本類型而不是4類，這8種基本類型指定了範圍。
四類
八種
字節數
數據表示範圍
整型
byte
1
-128～127
short
2
-32768～32767
int
4
-2147483648～2147483648
long
8
-263～263-1
浮點型
float
4
-3.403E38～3.403E38
double
8
-1.798E308～1.798E308
字符型
char
2
表示一個字符，如(‘a’，’A’，’0’，’家’)
布爾型
boolean
1
只有兩個值true與false
1. 常量與類型
前面我們說過100是整數常量，但它是byte、short、int、long中的哪一種呢？下面我們來聊聊這一常量類型的問題。
整數常量可以根據所在範圍來確定類型，例如100在-128~127之間，所以他是byte類型；500在-32768~32767之間，所以它是short類型；100000在-2147483648~2147483648之間，所以它是int類型。java中默認的整數類型是int類型
你可能會認爲12345678901在-263~263-1之間，所以它是long類型。注意了，這是錯誤的！！！在Java中整數常量如果不在-2147483648~2147483648之間就必須添加“L”後綴（小寫的也可以，但建議使用大寫），在-2147483648~2147483648之間的也可以添加“L”後綴。也就是說12345678901不在-2147483648~2147483648之間，所以它在Java中是錯誤的常量，你必須這樣寫：12345678901L，這纔是正確的常量。所以添加了“L”後綴的整數常量都是long類型的，例如：100L、12345678901L都是long類型的常量。
浮點類型的常量也可使用後綴，在Java中所有沒有後綴以及使用“D”後綴（小寫也可以，但建議使用大寫）的小數都是double類型；float類型常量必須添加“F”後綴（小寫也可以，但建議使用大寫）java中默認的浮點類型是double類型
* 3.14沒有後綴，所以它是double類型；
* 5.28D爲double類型；
* 1.26F爲float類型。
1. 定義變量（創建變量）
定義變量的語法格式：
數據類型 變量名 = 數據值；
int a = 100;
其中int是數據類型，指定了變量只能存儲整數，而且指定了存儲範圍爲-2147483648～2147483648。
其中a表示變量名，變量名是標識符，這說明只要是合法的標識符都可以用來做變量名。在程序中可以通過變量名來操作變量（內存中的小盒子）。
其中“=100”是給變量賦值，即向a變量中寫入100（變量是個小盒子，現在小盒子中保存的是100）。注意，給變量賦的值一定要與類型符合，也就是說int類型只能存儲整數，而且必須是在-2147483648～2147483648範圍內的整數。100滿足了這兩個條件，所以是正確的。
練習：
Variabe.java
/
/*
變量定義格式：
數據類型 變量名 = 變量值;
*/
public class Variable {
public static void main(String[] args) {
int a = 10;
double b = 3.14;
char c = 'z';
String s = "i love java";
a = 20;
System.out.println(a);
}
}1. 變量使用的注意事項
我們使用變量的時候需要注意，要滿足變量的使用規則纔可以使用的，我們來看看都有哪些注意事項。
* 變量使用的注意事項
* 變量定義後可以不賦值，使用時再賦值。不賦值不能使用。
public static void main(String[] args) {
int x;
x = 20; //爲x賦值20
System.out.println(x);//讀取x變量中的值，再打印
}* 變量使用時有作用域的限制。
public static void main(String[] args) {
int x = 20;
{
int y = 20;
}
System.out.println(x);//讀取x變量中的值，再打印
System.out.println(y);//讀取y變量中的值失敗，失敗原因，找不到y變量，因爲超出了y變量作用範圍，所以不能使用y變量
}* 變量不可以重複定義。
public static void main(String[] args){
int x = 10;
double x = 5.5;//編譯失敗，變量重複定義
}1. 數據類型轉換
不同類型的變量是否可以在一起運算呢？答案是可以的，但要先進行類型轉換再運算。下面我們來學習一下類型轉換。
其實，我們所學習的數據，它的表示方式是可以靈活多變的，比如把小數轉換成整數的操作
轉換的過程中，數據遵循一個原則：
範圍小的數據類型值（如byte），可以直接轉換爲範圍大的數據類型值（如int）；
範圍大的數據類型值（如int），不可以直接轉換爲範圍小的數據類型值（如byte）
那麼，大家還記得每種類型表示數據的範圍嗎？忘記了不要緊，我來告訴大家，將各種數據類型按照數據範圍從小到大依次列出：
byte -> short -> int -> long -> float -> double
關於數據類型轉換有兩種方式，我們來學習一下：
* 自動類型轉換
表示範圍小的數據類型轉換成範圍大的數據類型，這種方式稱爲自動類型轉換
自動類型轉換格式：
範圍大的數據類型 變量 = 範圍小的數據類型值；
如：
double d = 1000;
或
int i = 100;
double d2 = i;
* 強制類型轉換
表示範圍大的數據類型轉換成範圍小的數據類型，這種方式稱爲強制類型轉換
強制類型轉換格式：
範圍小的數據類型 變量 = (範圍小的數據類型) 範圍大的數據類型值;
如：
int i = (int)6.718; //i的值爲6
或
double d = 3.14;
int i2 = (int)d; //i2的值爲3
1. 運算符
1. 算術運算符
運算符是用來計算數據的符號。數據可以是常量，也可以是變量。被運算符操作的數我們稱爲操作數。
算術運算符最常見的操作就是將操作數參與數學計算，具體使用看下圖：
運算符
運算規則
範例
結果
+
正號
+3
3
+
加
2+3
5
+
連接字符串
“中”+“國”
“中國”
負號
int a=3;-a
-3
減
3-1
2
*
乘
2*3
6
/
除
5/2
2
%
取模
5/2
1
++
自增
int a=1;a++/++a
2
自減
int b=3;a–/–a
2
我們在使用算術運算符時，記得要注意下列事項：
* 加法運算符在連接字符串時要注意，只有直接與字符串相加纔會轉成字符串。
* 除法“/”當兩邊爲整數時，取整數部分，舍餘數。當其中一邊爲浮點型時，按正常規則相除。
* “%”爲整除取餘符號，小數取餘沒有意義。結果符號與被取餘符號相同。
* 整數做被除數，0不能做除數，否則報錯。
代碼演示
/*
* 算術運算符
*/
public class OperatorDemo1 {
public static void main(String[] args) {
/*
* 常量使用算數運算符
*/
System.out.println(10+20);
/*
* 變量使用算數運算符
*/
int x = 10;
int y = 20;
//"+"作爲加法運算使用
int z = x + y;
//"+"作爲連接字符串使用
System.out.println("x="+x);
System.out.println("y="+y);
System.out.println("z="+z);
}
} 運行結果如下圖所示。
1. 運行結果
1. 算數運算符++、--的使用
算數運算符在前面我們已經學習過了，這裏進行一些補充。
在一般情況下，算數運算符不會改變參與計算的變量值。而是在原有變量值不變的情況下，計算出新的值。但是有些操作符會改變參與計算的變量的值，比如++，–。
我們來看一段代碼：
int a = 3;
int b = 3;
a++;
b–;
System.out.println(a);
System.out.println(b);
上面代碼的輸出結果a值爲4，b值爲2；
這說明a的原有值發生了改變，在原有值的基礎上自增1；b的原有值也發生了改變，在原有值的基礎上自減1；
* ++運算符，會在原有值的基礎上自增1；
* --運算符，會在原有值的基礎上自減1。
我們再看一段代碼：
int a = 3;
int b = 3;
++a;
–b;
System.out.println(a);
System.out.println(b);
上面代碼的輸出結果a值爲4，b值爲2；
這說明++,–運算符單獨使用，不參與運算操作時，運算符前後位置導致的運算結果是一致的。
接下來，介紹下++，–運算符參與運算操作時，發生了怎樣的變化，我們來看一段代碼：
int a = 3;
int b;
b = a++ + 10;
System.out.println(a);
System.out.println(b); 上面代碼的輸出結果a值爲4，b值爲13；
這裏我要強調一下了，當++，--運算符參與運算操作時，後置++，--的作用：
* ++,--運算符後置時，先使用變量a原有值參與運算操作，運算操作完成後，變量a的值自增1或者自減1；
再介紹下++，–運算符前置時，參與運算操作的變化，我們來看一段代碼：
：
int a = 3;
int b;
b = ++a + 10;
System.out.println(a);
System.out.println(b上面代碼的輸出結果a值爲4，b值爲14；
這裏我強調一下，當++，–運算符參與運算操作時，前置++，–的作用：
* ++，--運算符前置時，先將變量a的值自增1或者自減1，然後使用更新後的新值參與運算操作。
1. 賦值運算符
我們來學習一下賦值運算符，賦值運算符就是爲變量賦值的符號，賦值運算符的使用看下圖：
運算符
運算規則
範例
結果
賦值
int a=2
2
+=
加後賦值
int a=2，a+=2
4
-=
減後賦值
int a=2，a-=2
0
*=
乘後賦值
int a=2，a*=2
4
/=
整除後賦值
int a=2，a/=2
1
%=
取模後賦值
int a=2，a%=2
0
注意：諸如+=這樣形式的賦值運算符，會將結果自動強轉成等號左邊的數據類型。
寫一個代碼，我們看一下賦值運算符的使用
/*
* 賦值運算符
* +=, -=, *=, /=, %= ：
* 上面的運算符作用：將等號左右兩邊計算，會將結果自動強轉成等號左邊的數據類型,再賦值給等號左邊的
* 注意：賦值運算符左邊必須是變量
*/
public class OperatorDemo2 {
public static void main(String[] args) {
byte x = 10;
x += 20;// 相當於 x = (byte)(x+20);
System.out.println(x);
}
}運行結果如下圖所示。
1. 運行結果
1. 比較運算符
比較運算符，又叫關係運算符，它是用來判斷兩個操作數的大小關係及是否相等關係的，結果是布爾值true或者false。
運算符
運算規則
範例
結果
相等於
4==3
False
!=
不等於
4!=3
True
<
小於
4<3
False
>
大於
4>3
True
<=
小於等於
4<=3
False
=
大於等於
4>=3
True
這裏需要注意一下：
* 賦值運算符的 = 符號與比較運算符的 == 符號是有區別的，如下：
* 賦值運算符的 = 符號，是用來將 = 符號右邊的值，賦值給 = 符號左邊的變量；
* 比較運算符的 == 符號，是用來判斷 == 符號 左右變量的值是否相等的。
我們通過下面的一段代碼，我們演示一下這個注意事項：
int a = 3;
int b = 4;
System.out.println( a=b );
System.out.println( a==b );
上面代碼輸出的結果第一個值爲4，第二個值爲false。
1. 邏輯運算符
邏輯運算符，它是用於布爾值進行運算的，運算的最終結果爲布爾值true或false。
運算符
運算規則
範例
結果
&
與
false&true
False
|
或
false|true
True
^
異或
true^flase
True
!
非
!true
Flase
&&
短路與
false&&true
False
||
短路或
false||true
True
看完圖後，我們來看一下邏輯運算符的常規使用方式：
* 邏輯運算符通常連接兩個其他表達式計算後的布爾值結果
* 當使用短路與或者短路或時，只要能判斷出結果則後邊的部分就不再判斷。
我們通過代碼演示一下：
boolean b = 100>10;
boolean b2 = false;
System.out.println(b&&b2); // 打印結果爲 false
System.out.println(b||b2); //打印結果爲 true
System.out.println(!b2); //打印結果爲 true
System.out.println(b && 100>10); //打印結果爲 true，本行結果的計算方式稍後講解運算符優先級時解答
好了，我們來總結一下運算符的結果規律吧：
* 短路與&&:參與運算的兩邊數據，有false，則運算結果爲false；
* 短路或||:參與運算的兩邊數據，有true，則運算結果爲true；
* 邏輯非! : 參與運算的數據，原先是true則變成false，原先是false則變成true。
1. 三元運算符
接下來我們要學習的三元運算符與之前的運算符不同。之前學習的均爲一元或者二元運算符。元即參與運算的數據。
* 格式：
(條件表達式)？表達式1：表達式2；
* 表達式：通俗的說，即通過使用運算符將操作數聯繫起來的式子，例如：
* 3+2，使用算數運算符將操作數聯繫起來，這種情況，我們稱爲算數表達式。
* 3>2，使用比較運算符（也稱爲條件運算符）將操作數聯繫起來，這種情況，我們稱爲條件表達式。
* 其他表達式，不再一一舉例。
* 三元運算符運算規則：
先判斷條件表達式的值，若爲true，運算結果爲表達式1；若爲false，運算結果爲表達式2。
通過代碼演示，我們來學習下三元運算符的使用：
方式一：
System.out.println( 3>2 ? “正確” : “錯誤” );
// 三元運算符運算後的結果爲true，運算結果爲表達式1的值“正確”，然後將結果“正確”，在控制檯輸出打印
方式二：
int a = 3;
int b = 4;
String result = (a==b) ? “相等” : “不相等”;
//三元運算符運算後的結果爲false，運算結果爲表達式2的值“不相等”，然後將結果賦值給了變量result
方式三：
int n = (3>2 && 4>6) ? 100 : 200;
//三元運算符運算後的結果爲false，運算結果爲表達式2的值200,然後將結果200賦值給了變量n
1. 運算符優先級
在學習運算符的過程中，我們發現，當多個運算符一起使用的時候，容易出現不清晰先後運算順序的問題，那麼，在這裏，我們來學習下，運算符之間的運算優先級。
下圖是每種運算符的優先級，按照運算先後順序排序（優先級相同的情況下，按照從左到右的順序依次運算）
優先級
描述
運算符
1
括號
()、[]
2
正負號
+、-
3
自增自減，非
++、–、!
4
乘除，取餘
*、/、%
5
加減
+、-
6
移位運算
<<、>>、>>>
7
大小關係
、>=、<、<=
8
相等關係
==、!=
9
按位與
&
10
按位異或
^
11
按位或
|
12
邏輯與
&&
13
邏輯或
||
14
條件運算
?:
15
賦值運算
=、+=、-=、*=、/=、%=
16
位賦值運算
&=、|=、<<=、>>=、>>>=
優先級順序看完了，我們來通過代碼，加強一下：
int n = 3>4 ? 100 : 200;
這行的代碼運算執行順序我們來寫一下：
* 1.執行 3>4操作，得到布爾類型false的結果
* 2.通過結果false，將對應的表達式2的結果200，作爲運算的最終結果
* 3.把200 賦值給變量n
接下來，我們看一個比較複雜的代碼：
int a = 5;
int b = 3;
int c = 1;
int n2 = (a>b && b>c) ? (c++) : (++c);
這段代碼運算執行順序我們也寫一下：
* 1.小括號優先級高，我們先運算第一組小括號中的代碼
* 1.1. 比較運算符”>” 優先級大於 邏輯運算符”&&”
* 先執行 a>b,得到結果true；
* 再執行 b>c,得到結果true；
* 最後執行 a>b的結果 && b>c的結果，即 true && true, 結果爲true
* 2.三元運算符中的條件判斷結果爲true，返回表達式1的結果 c++
* 先將變量c的原有值賦值給變量n2，即n2值爲1；
* 再將變量c的值自增1,更新爲2。
運算符我們學到這裏就結束了，稍後在“趣味樂園”中，我們可以運用運算符進行練習。
1. 商場庫存清單案例
1. 案例介紹
現在我們來做一個複雜點的案例——商場庫存清單案例，這個案例最終會在控制檯輸出如下結果：
1. 案例需求分析
* 觀察清單後，可將清單分解爲三個部分（清單頂部、清單中部、清單底部）
* 1.清單頂部爲固定的數據，直接打印即可
* 2.清單中部爲商品，爲變化的數據，需要記錄商品信息後，打印
經過觀察，我們確定一項商品應該有如下幾個屬性：
品牌型號: 即商品名稱，String型
尺寸：物品大小，double型
價格：物品單價，double型
配置：這一項爲每種商品的配置信息，String型
庫存數：這一項爲每種商品的庫存個數，int型
* 3.清單底部包含了統計操作，需經過計算後，打印
我們發現兩個單獨的可變化量
總庫存數：所有商品總個數，int型
庫存商品總金額：所有商品金額，double型
1. 實現代碼步驟
一起分析完畢了，我們開始完成案例代碼的編寫：
* 創建Demo01庫存清單.java文件，編寫main主方法
public class Demo01庫存清單 {
public static void main(String[] args) {
}
}
* 記錄每種庫存商品信息
//蘋果筆記本電腦
String macBrand = "MacBookAir";
double macSize = 13.3;
double macPrice = 6988.88;
int macCount = 5;
//聯想Thinkpad筆記本電腦
String thinkpadBrand = "ThinkpadT450";
double thinkpadSize = 14.0;
double thinkpadPrice = 5999.99;
int thinkpadCount = 10;
//華碩ASUS筆記本電腦
String ASUSBrand = "ASUS-FL5800";
double ASUSSize = 15.6;
double ASUSPrice = 4999.50;
int ASUSCount = 18;
* 統計所有庫存商品數量與金額
//統計庫存總個數、庫存總金額
int totalCount = macCount + thinkpadCount + ASUSCount;
double totalMoney = (macCount * macPrice) + (thinkpadCount * thinkpadPrice) + (ASUSCount * ASUSPrice);
* 打印庫存清單頂部信息
//列表頂部
System.out.println("------------------------------商城庫存清單-----------------------------");
System.out.println("品牌型號 尺寸 價格 庫存數");
* 打印庫存清單中部信息
//列表中部
System.out.println(macBrand+" "+macSize+" "+macPrice+" "+macCount);
System.out.println(thinkpadBrand+" "+thinkpadSize+" "+thinkpadPrice+" "+thinkpadCount);
System.out.println(ASUSBrand+" "+ASUSSize+" "+ASUSPrice+" "ASUSCount);
* 打印庫存清單底部信息
//列表底部
System.out.println("-----------------------------------------------------------------------");
System.out.println("總庫存數："+totalCount);
System.out.println("庫存商品總金額："+totalMoney);1. 總結
1. 知識點總結
* 數據類型轉換
* 數據類型範圍從小到大排序（byte < char < short < int < long < float < double），布爾類型Boolean不能參與類型轉換；
* 自動類型轉換，範圍小的數據類型向範圍大的數據類型轉換時使用；
* 強制類型轉換，範圍大的數據類型向範圍小的數據類型轉換時使用。
* 算數運算符
* 用來完成算數運算（如加減乘除計算等）
* ++，--運算符的使用
* ++，--前置（如++a），當參與運算時，變量a的值先自增1，然後用自增後的新值再參與運算；
* ++，--後置（如a++），當參與運算時，變量a先使用原有值參與運算符，變量a的值再自增1。
* 賦值運算符
* 用來完成數據的賦值（如 int a = 100;）
* +=,-,*=,/=這樣的賦值運算符包含了一個強制轉換的操作，會將左右兩邊運算後的結果，強制類型轉換後賦值給左邊
int n = 10;
byte by = 20;
by += n; // 運算完畢後，by的值爲byte類型30， 相當於代碼 by = (byte)(by + n);
* 比較運算符
* 用來比較數據的大小（如 3>4），比較運算符也稱爲條件運算符。
* 比較後的結果爲布爾類型Boolean的值
* “==”兩個等號代表比較是否相等，“=”一個等號代表賦值。
* 邏輯運算符
* 邏輯與& 和邏輯短路與&&：代表着並且的意思，左右兩邊都要條件成立，結果才爲true；
* 邏輯或| 和邏輯短路或||：代表着或者的意思，左邊兩邊有一個條件成立，結果就爲true；
* 邏輯非!：代表着相反的意思，原先是false，結果就爲true；原先是ture，結果就爲false；
* 邏輯異或^： 左右兩邊條件結果相同，結果就爲false，左右兩邊條件結果不同，結果就爲true；
* 三元運算符
* 根據判斷條件運算結果，執行不同的表達式值；條件爲true，執行表達式1，否則，執行表達式2。