第2天 Java基礎語法
今日內容介紹
u 變量
u 運算符
第1章 變量
1.1 變量概述
前面我們已經學習了常量，接下來我們要學習變量。在Java中變量的應用比常量的應用要多很多。所以變量也是尤為重要的知識點！
什么是變量？變量是一個內存中的小盒子（小容器），容器是什么？生活中也有很多容器，例如水杯是容器，用來裝載水；你家里的大衣櫃是容器，用來裝載衣褲；飯盒是容器，用來裝載飯菜。那么變量是裝載什么的呢？答案是數據！結論：變量是內存中裝載數據的小盒子，你只能用它來存數據和取數據。
1.2 計算機存儲單元
變量是內存中的小容器，用來存儲數據。那么計算機內存是怎么存儲數據的呢？無論是內存還是硬盤，計算機存儲設備的最小信息單元叫“位（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.3 基本類型之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.4 常量與類型
前面我們說過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類型
l 3.14沒有后綴，所以它是double類型；
l 5.28D為double類型；
l 1.26F為float類型。
1.5 定義變量（創建變量）
定義變量的語法格式：
數據類型 變量名 = 數據值；
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.6 變量使用的注意事項
我們使用變量的時候需要注意，要滿足變量的使用規則才可以使用的，我們來看看都有哪些注意事項。
l 變量使用的注意事項
l 變量定義后可以不賦值，使用時再賦值。不賦值不能使用。
public static void main(String[] args) {
int x;
x = 20; //為x賦值20
System.out.println(x);//讀取x變量中的值，再打印
}
l 變量使用時有作用域的限制。
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變量
}
l 變量不可以重復定義。
public static void main(String[] args){
int x = 10;
double x = 5.5;//編譯失敗，變量重復定義
}
1.7 數據類型轉換
不同類型的變量是否可以在一起運算呢？答案是可以的，但要先進行類型轉換再運算。下面我們來學習一下類型轉換。
其實，我們所學習的數據，它的表示方式是可以靈活多變的，比如把小數轉換成整數的操作
轉換的過程中，數據遵循一個原則：
范圍小的數據類型值（如byte），可以直接轉換為范圍大的數據類型值（如int）；
范圍大的數據類型值（如int），不可以直接轉換為范圍小的數據類型值（如byte）
那么，大家還記得每種類型表示數據的范圍嗎？忘記了不要緊，我來告訴大家，將各種數據類型按照數據范圍從小到大依次列出：
byte -> short -> int -> long -> float -> double
關於數據類型轉換有兩種方式，我們來學習一下：
l 自動類型轉換
表示范圍小的數據類型轉換成范圍大的數據類型，這種方式稱為自動類型轉換
自動類型轉換格式：
范圍大的數據類型 變量 = 范圍小的數據類型值；
如：
double d = 1000;
或
int i = 100;
double d2 = i;
l 強制類型轉換
表示范圍大的數據類型轉換成范圍小的數據類型，這種方式稱為強制類型轉換
強制類型轉換格式：
范圍小的數據類型 變量 = (范圍小的數據類型) 范圍大的數據類型值;
如：
int i = (int)6.718; //i的值為6
或
double d = 3.14;
int i2 = (int)d; //i2的值為3
第2章 運算符
2.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 |
我們在使用算術運算符時，記得要注意下列事項：
l 加法運算符在連接字符串時要注意，只有直接與字符串相加才會轉成字符串。
l 除法“/”當兩邊為整數時，取整數部分，舍余數。當其中一邊為浮點型時，按正常規則相除。
l “%”為整除取余符號，小數取余沒有意義。結果符號與被取余符號相同。
l 整數做被除數，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 運行結果
2.2 算數運算符++、--的使用
算數運算符在前面我們已經學習過了，這里進行一些補充。
在一般情況下，算數運算符不會改變參與計算的變量值。而是在原有變量值不變的情況下，計算出新的值。但是有些操作符會改變參與計算的變量的值，比如++，--。
我們來看一段代碼：
int a = 3;
int b = 3;
a++;
b--;
System.out.println(a);
System.out.println(b);
上面代碼的輸出結果a值為4，b值為2；
這說明a的原有值發生了改變，在原有值的基礎上自增1；b的原有值也發生了改變，在原有值的基礎上自減1；
l ++運算符，會在原有值的基礎上自增1；
l --運算符，會在原有值的基礎上自減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；
這里我要強調一下了，當++，--運算符參與運算操作時，后置++，--的作用：
l ++,--運算符后置時，先使用變量a原有值參與運算操作，運算操作完成后，變量a的值自增1或者自減1；
再介紹下++，--運算符前置時，參與運算操作的變化，我們來看一段代碼：
int a = 3;
int b;
b = ++a + 10;
System.out.println(a);
System.out.println(b);
上面代碼的輸出結果a值為4，b值為14；
這里我強調一下，當++，--運算符參與運算操作時，前置++，--的作用：
l ++，--運算符前置時，先將變量a的值自增1或者自減1，然后使用更新后的新值參與運算操作。
2.3 賦值運算符
我們來學習一下賦值運算符，賦值運算符就是為變量賦值的符號，賦值運算符的使用看下圖：
| 運算符 |
運算規則 |
范例 |
結果 |
| = |
賦值 |
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-2 運行結果
2.4 比較運算符
比較運算符，又叫關系運算符，它是用來判斷兩個操作數的大小關系及是否相等關系的，結果是布爾值true或者false。
| 運算符 |
運算規則 |
范例 |
結果 |
| == |
相等於 |
4==3 |
False |
| != |
不等於 |
4!=3 |
True |
| < |
小於 |
4<3 |
False |
| > |
大於 |
4>3 |
True |
| <= |
小於等於 |
4<=3 |
False |
| >= |
大於等於 |
4>=3 |
True |
這里需要注意一下：
l 賦值運算符的 = 符號與比較運算符的 == 符號是有區別的，如下：
l 賦值運算符的 = 符號，是用來將 = 符號右邊的值，賦值給 = 符號左邊的變量；
l 比較運算符的 == 符號，是用來判斷 == 符號 左右變量的值是否相等的。
我們通過下面的一段代碼，我們演示一下這個注意事項：
int a = 3;
int b = 4;
System.out.println( a=b );
System.out.println( a==b );
上面代碼輸出的結果第一個值為4，第二個值為false。
2.5 邏輯運算符
邏輯運算符，它是用於布爾值進行運算的，運算的最終結果為布爾值true或false。
| 運算符 |
運算規則 |
范例 |
結果 |
| & |
與 |
false&true |
False |
| | |
或 |
false|true |
True |
| ^ |
異或 |
true^flase |
True |
| ! |
非 |
!true |
Flase |
| && |
短路與 |
false&&true |
False |
| || |
短路或 |
false||true |
True |
看完圖后，我們來看一下邏輯運算符的常規使用方式：
l 邏輯運算符通常連接兩個其他表達式計算后的布爾值結果
l 當使用短路與或者短路或時，只要能判斷出結果則后邊的部分就不再判斷。
我們通過代碼演示一下：
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，本行結果的計算方式稍后講解運算符優先級時解答
好了，我們來總結一下運算符的結果規律吧：
l 短路與&&:參與運算的兩邊數據，有false，則運算結果為false；
l 短路或||:參與運算的兩邊數據，有true，則運算結果為true；
l 邏輯非! : 參與運算的數據，原先是true則變成false，原先是false則變成true。
2.6 三元運算符
接下來我們要學習的三元運算符與之前的運算符不同。之前學習的均為一元或者二元運算符。元即參與運算的數據。
l 格式：
(條件表達式)？表達式1：表達式2；
l 表達式：通俗的說，即通過使用運算符將操作數聯系起來的式子，例如：
l 3+2，使用算數運算符將操作數聯系起來，這種情況，我們稱為算數表達式。
l 3>2，使用比較運算符（也稱為條件運算符）將操作數聯系起來，這種情況，我們稱為條件表達式。
l 其他表達式，不再一一舉例。
l 三元運算符運算規則：
先判斷條件表達式的值，若為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
2.7 運算符優先級
在學習運算符的過程中，我們發現，當多個運算符一起使用的時候，容易出現不清晰先后運算順序的問題，那么，在這里，我們來學習下，運算符之間的運算優先級。
下圖是每種運算符的優先級，按照運算先后順序排序（優先級相同的情況下，按照從左到右的順序依次運算）
| 優先級 |
描述 |
運算符 |
| 1 |
括號 |
()、[] |
| 2 |
正負號 |
+、- |
| 3 |
自增自減，非 |
++、--、! |
| 4 |
乘除，取余 |
*、/、% |
| 5 |
加減 |
+、- |
| 6 |
移位運算 |
<<、>>、>>> |
| 7 |
大小關系 |
>、>=、<、<= |
| 8 |
相等關系 |
==、!= |
| 9 |
按位與 |
& |
| 10 |
按位異或 |
^ |
| 11 |
按位或 |
| |
| 12 |
邏輯與 |
&& |
| 13 |
邏輯或 |
|| |
| 14 |
條件運算 |
?: |
| 15 |
賦值運算 |
=、+=、-=、*=、/=、%= |
| 16 |
位賦值運算 |
&=、|=、<<=、>>=、>>>= |
優先級順序看完了，我們來通過代碼，加強一下：
int n = 3>4 ? 100 : 200;
這行的代碼運算執行順序我們來寫一下：
l 1.執行 3>4操作，得到布爾類型false的結果
l 2.通過結果false，將對應的表達式2的結果200，作為運算的最終結果
l 3.把200 賦值給變量n
接下來，我們看一個比較復雜的代碼：
int a = 5;
int b = 3;
int c = 1;
int n2 = (a>b && b>c) ? (c++) : (++c);
這段代碼運算執行順序我們也寫一下：
l 1.小括號優先級高，我們先運算第一組小括號中的代碼
l 1.1. 比較運算符”>” 優先級大於 邏輯運算符”&&”
l 先執行 a>b,得到結果true；
l 再執行 b>c,得到結果true；
l 最后執行 a>b的結果 && b>c的結果，即 true && true, 結果為true
l 2.三元運算符中的條件判斷結果為true，返回表達式1的結果 c++
l 先將變量c的原有值賦值給變量n2，即n2值為1；
l 再將變量c的值自增1,更新為2。
運算符我們學到這里就結束了，稍后在“趣味樂園”中，我們可以運用運算符進行練習。
第3章 商場庫存清單案例
3.1 案例介紹
現在我們來做一個復雜點的案例——商場庫存清單案例，這個案例最終會在控制台輸出如下結果：
3.2 案例需求分析
l 觀察清單后，可將清單分解為三個部分（清單頂部、清單中部、清單底部）
l 1.清單頂部為固定的數據，直接打印即可
l 2.清單中部為商品，為變化的數據，需要記錄商品信息后，打印
經過觀察，我們確定一項商品應該有如下幾個屬性：
品牌型號: 即商品名稱，String型
尺寸：物品大小，double型
價格：物品單價，double型
配置：這一項為每種商品的配置信息，String型
庫存數：這一項為每種商品的庫存個數，int型
l 3.清單底部包含了統計操作，需經過計算后，打印
我們發現兩個單獨的可變化量
總庫存數：所有商品總個數，int型
庫存商品總金額：所有商品金額，double型
3.3 實現代碼步驟
一起分析完畢了，我們開始完成案例代碼的編寫：
l 創建Demo01庫存清單.java文件，編寫main主方法
public class Demo01庫存清單 {
public static void main(String[] args) {
}
}
l 記錄每種庫存商品信息
//蘋果筆記本電腦
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;
l 統計所有庫存商品數量與金額
//統計庫存總個數、庫存總金額
int totalCount = macCount + thinkpadCount + ASUSCount;
double totalMoney = (macCount * macPrice) + (thinkpadCount * thinkpadPrice) + (ASUSCount * ASUSPrice);
l 打印庫存清單頂部信息
//列表頂部
System.out.println("------------------------------商城庫存清單-----------------------------");
System.out.println("品牌型號 尺寸 價格 庫存數");
l 打印庫存清單中部信息
//列表中部
System.out.println(macBrand+" "+macSize+" "+macPrice+" "+macCount);
System.out.println(thinkpadBrand+" "+thinkpadSize+" "+thinkpadPrice+" "+thinkpadCount);
System.out.println(ASUSBrand+" "+ASUSSize+" "+ASUSPrice+" "ASUSCount);
l 打印庫存清單底部信息
//列表底部
System.out.println("-----------------------------------------------------------------------");
System.out.println("總庫存數："+totalCount);
System.out.println("庫存商品總金額："+totalMoney);
第4章 總結
4.1 知識點總結
l 數據類型轉換
l 數據類型范圍從小到大排序（byte < char < short < int < long < float < double），布爾類型Boolean不能參與類型轉換；
l 自動類型轉換，范圍小的數據類型向范圍大的數據類型轉換時使用；
l 強制類型轉換，范圍大的數據類型向范圍小的數據類型轉換時使用。
l 算數運算符
l 用來完成算數運算（如加減乘除計算等）
l ++，--運算符的使用
l ++，--前置（如++a），當參與運算時，變量a的值先自增1，然后用自增后的新值再參與運算；
l ++，--后置（如a++），當參與運算時，變量a先使用原有值參與運算符，變量a的值再自增1。
l 賦值運算符
l 用來完成數據的賦值（如 int a = 100;）
l +=,-,*=,/=這樣的賦值運算符包含了一個強制轉換的操作，會將左右兩邊運算后的結果，強制類型轉換后賦值給左邊
int n = 10;
byte by = 20;
by += n; // 運算完畢后，by的值為byte類型30， 相當於代碼 by = (byte)(by + n);
l 比較運算符
l 用來比較數據的大小（如 3>4），比較運算符也稱為條件運算符。
l 比較后的結果為布爾類型Boolean的值
l “==”兩個等號代表比較是否相等，“=”一個等號代表賦值。
l 邏輯運算符
l 邏輯與& 和邏輯短路與&&：代表着並且的意思，左右兩邊都要條件成立，結果才為true；
l 邏輯或| 和邏輯短路或||：代表着或者的意思，左邊兩邊有一個條件成立，結果就為true；
l 邏輯非!：代表着相反的意思，原先是false，結果就為true；原先是ture，結果就為false；
l 邏輯異或^： 左右兩邊條件結果相同，結果就為false，左右兩邊條件結果不同，結果就為true；
l 三元運算符
l 根據判斷條件運算結果，執行不同的表達式值；條件為true，執行表達式1，否則，執行表達式2。