變量-類型-運算符 · 資料資源

# 【變量、類型轉換、運算符】 ##### 今日復習指南 ~~~ 1.變量【重點: 用30分鐘】 Demo01BianLiang.java ? ?Demo02BianLiang.java ? 2.運算符【重點: 用1個小時】 ? ?Demo11Operator.java ? ?Demo12Operator.java ? ?Demo13Operator.java ? ?Demo14Operator.java ? ?Demo15Operator.java ? ?Demo16Operator.java ? ?Demo17Operator.java ? ? 練習寫代碼時,必要的注釋是需要的,但是千萬不要像響哥一樣寫的這么詳細,只要自己理解就ok了 ? ? 3.數據類型轉換【難點非重點: 理解,用30分鐘】大體看看 ? ? ? ~~~ ##### 今日內容介紹 ~~~ 變量【重點】數據類型轉換【難點非重點: 理解】運算符【重點】 ~~~ ### 第一章變量和數據類型【重要】 ##### 2.1 變量概念及分類 ~~~ 數學中有個常數的概念: y = x + 10; //整數數字10是不可以發生變化的 b = a + 6.6; //小數數字6.6是不可以發生變化的 ? 數學中的數字(常數)是有分類的,對應java中的常量也是有分類的 ? ? x,y是可以發生變化的 x: 2 y: 12 x: 6 y: 16 ? ? ... ? ? ? ? x,y中的數據是可以發生變化的,而且x,y內部的數據也是有類型(整數) ? ? ? ? ? a,b是可以發生變化的 ?a: 2.2 b: 8.8 ?a: 3.3 b: 9.9 ... a,b中的數據是可以發生變化的,而且a,b內部的數據也是有類型(小數) ? 像x,y,a,b這樣的東西,里面是可以存儲數據的,而且內部的數據是有具體的類型的,把這樣的東西叫做變量(理解為小的容器,只能存儲一個數據) ? 為什么變量會有很多分類? 不同類型的變量,占用的字節數(空間)不同,導致取值范圍不同,使用場景不一樣 ? 1.變量概念: 在程序的執行過程中,其值可以在一定范圍內發生改變的量 2.分類(四類八種): (1)整數 byte 占1個字節取值范圍 -128到127 short 占2個字節取值范圍正負3萬多 int 占4個字節取值范圍正負21億整數常量默認是int類型 long 占8個字節取值范圍大概19位數字表示long類型的數據時,建議右鍵添加字母L/l (2)小數 float 占4個字節表示float類型的數據時,建議右鍵添加字母F/f 雖然float占4個字節,但是由于內部采用科學計數法,取值范圍遠遠大于占用8個字節的long類型 double 占8個字節小數常量默認是double類型 (3)字符: char 占2個字節取值范圍0到65535 (4)布爾: boolean 占1個字節取值只有true,false ~~~ ##### 2.2 變量定義格式圖解分析 ~~~ 變量的理解 1.變量的本質就是內存中的一塊空間,空間的大小由數據類型決定 2.要想找到變量的內存空間,必須給這塊空間起個名字,叫做變量名稱 3.變量對應的內存空間中必須有數據才可以使用,向變量內存空間中,存儲數據的過程叫做初始化/賦值 ? 變量定義格式一(挖一個坑,同時種一個蘿卜): 數據類型變量名稱 = 數據值;//挖一個坑,同時種一個蘿卜 ? 變量定義格式二(先挖一個坑,然后種一個蘿卜): 數據類型變量名稱;//先挖一個坑變量名稱 = 數據值;//然后種一個蘿卜 ? 變量定義格式三(挖多個坑,同時向每個坑中種一個蘿卜): 數據類型變量名稱1 = 數據值1,變量名稱2 = 數據值2 ... ; ? 變量定義格式四(先挖多個坑,然后向每個坑中種一個蘿卜): 數據類型變量名稱1 ,變量名稱2 ... ;//先挖多個坑變量名稱1 = 數據值1;//然后向每個坑中種一個蘿卜變量名稱2 = 數據值2; //.... ~~~ ##### 圖解: ![](https://img.kancloud.cn/e0/d6/e0d6ea268f82ce31b9ba9b13331880ce_1340x513.png) ##### 2.3 定義8種變量 ~~~ /* 變量定義的四種格式 */ public class Demo01BianLiang { public static void main(String[] args){ /* 變量定義格式一(挖一個坑,同時種一個蘿卜): 數據類型變量名稱 = 數據值;//挖一個坑,同時種一個蘿卜 */ //挖一個byte類型(占1個字節)的坑,給這個坑起個名字叫a,同時把數字10放入這個坑中 byte a = 10; System.out.println(a);//打印名稱為a的坑中的內容 a = 20;//把數字20放入名稱為a的坑中,原來的數據被替換調用 System.out.println(a);//打印名稱為a的坑中的內容 System.out.println("--------------------------------"); /* 變量定義格式二(先挖一個坑,然后種一個蘿卜): 數據類型變量名稱;//先挖一個坑變量名稱 = 數據值;//然后種一個蘿卜 */ short b;//挖一個short類型(占2個字節)的坑,給這個坑起個名字叫b b = 30;//把數字30放入名稱為b的坑中 System.out.println(b);//打印名稱為b的坑中的內容 System.out.println("--------------------------------"); /* 變量定義格式三(挖多個坑,同時向每個坑中種一個蘿卜): 數據類型變量名稱1 = 數據值1,變量名稱2 = 數據值2 ... ; */ //挖兩個個int類型(占4個字節)的坑,一個坑起個名字叫c,一個坑起個名字叫d,分別向每個坑中放入數據 int c = 40, d = 50; System.out.println(c);//打印名稱為c的坑中的內容 System.out.println(d);//打印名稱為d的坑中的內容 System.out.println("--------------------------------"); /* 變量定義格式四(先挖多個坑,然后向每個坑中種一個蘿卜): 數據類型變量名稱1 ,變量名稱2 ... ;//先挖多個坑變量名稱1 = 數據值1;//然后向每個坑中種一個蘿卜變量名稱2 = 數據值2; //.... */ //挖兩個long類型(占8個字節)的坑,一個坑起個名字叫e,一個坑起個名字叫f long e,f; e = 60L;//把數字60放入名稱為e的坑中 f = 70L;//把數字70放入名稱為f的坑中 System.out.println(e);//打印名稱為e的坑中的內容 System.out.println(f);//打印名稱為f的坑中的內容 System.out.println("HelloWorld"); } } ~~~ ~~~ /* 其它類型變量的定義 */ public class Demo02BianLiang { public static void main(String[] args){ //定義float類型的變量a,初始化值6.6F float a = 6.6F; System.out.println(a);//打印變量a中的內容 //定義double類型的變量b,初始化值8.8 double b = 8.8; System.out.println(b);//打印變量b中的內容 //定義char類型的變量ch,初始化值'a' char ch = 'a'; //char ch = 'ab';//錯誤: ''中不能寫兩個及以上的字符 //char ch = '';//錯誤: ''中不能沒有字符 System.out.println(ch);//打印變量ch中的內容 //定義boolean類型的變量c,初始化值true boolean c = true; c = false;//把false賦值給變量c,原來的值將被覆蓋 System.out.println(c);//打印變量c中的內容 ? } } ~~~ ##### 2.4 變量的注意事項變量定義的注意事項: 1.定義long類型的變量時，需要在整數的后面加L（大小寫均可，建議大寫）。因為整數默認是int類型，整數太大可能超出int范圍。 2.定義float類型的變量時，需要在小數的后面加F（大小寫均可，建議大寫）。因為浮點數的默認類型是double， double的取值范圍是大于float的，類型不兼容。 3.變量名稱：在同一個大括號范圍內，變量的名字不可以相同。 ? 4.變量賦值：定義的變量，不賦值不能使用。 ~~~ /* 變量定義的注意事項: 1.變量名稱：在同一個大括號范圍內，變量的名字不可以相同。 2.變量賦值：定義的變量，不賦值不能使用。 */ public class Demo03Notice { public static void main(String[] args){ //定義int變量a,初始值10 int a = 10; System.out.println(a);//打印變量a中的內容 //錯誤: 不能在同一個{}中定義同名的變量 //int a = 20; //System.out.println(a);//打印變量a中的內容 //定義int變量b,未賦值 int b; //錯誤: b中沒有內容,不能使用 //System.out.println(b);//打印變量b中的內容 b = 30;//把數字30存入變量b中 System.out.println(b);//打印變量b中的內容 ? } } ~~~ ~~~ /* 變量定義的注意事項: 1.定義long類型的變量時，需要在整數的后面加L（大小寫均可，建議大寫）。因為整數默認是int類型，整數太大可能超出int范圍。 2.定義float類型的變量時，需要在小數的后面加F（大小寫均可，建議大寫）。因為浮點數的默認類型是double， double的取值范圍是大于float的，類型不兼容。 */ public class Demo04Notice { public static void main(String[] args){ //定義long變量a,初始值6000000000: 60億 //long a = 6000000000;//錯誤: 整數6000000000默認是int類型,但是已經遠遠的超出了int的取值范圍21億 //System.out.println(a);//打印變量a中的內容 long b = 6000000000L;//正確: 整數常量后面+L,類型就是long類型 System.out.println(b);//打印變量b中的內容 System.out.println("-------------------"); //定義float變量f,初始值8.8 //錯誤: 大蘿卜不能直接放入小坑中 //float f = 8.8;//錯誤: 小數常量8.8,默認是double類型,占8個字節,不能放入占4個字節的坑中 //System.out.println(f);//打印變量f中的內容 float g = 8.8F;//正確: 小數常量后面+F,類型就是float類型 System.out.println(g);//打印變量g中的內容 ? } } ~~~ ##### 2.5 標識符的含義及注意事項 ~~~ 標識符: 1.概念: 程序中起名字的地方(類名,方法名稱,變量名) 2.命名規則：硬性要求標識符可以包含英文字母26個(區分大小寫) 、 0-9數字、 $（美元符號）和 _（下劃線）。標識符不能以數字開頭。標識符不能是關鍵字。 3.命名規范：軟性建議類名規范：首字母大寫，后面每個單詞首字母大寫（大駝峰式）。 Demo01BianLiang Demo02BianLiang Demo03BianLiangNotice Demo04BiaoShiFu 方法名規范：首字母小寫，后面每個單詞首字母大寫（小駝峰式）。 getMin(...){...} getMax(...){...} 變量名規范：首字母小寫，后面每個單詞首字母大寫（小駝峰式）。 num value maxValue ~~~ ~~~ public class Demo05BiaoShiFu { public static void main(String[] args){ int b2$_a;//正確的 //int b2$_%a;//錯誤的,不能包含% //int 2b;//錯誤:不能以數字開頭 //int public;//錯誤:不能是關鍵字 int ageOfMyGirlFriend = 18; System.out.println(ageOfMyGirlFriend); //不建議 int ageofmygirlfriend = 28; System.out.println(ageofmygirlfriend); } } ~~~ ### 第二章數據類型轉換【理解】 ##### 3.1 自動類型轉換【從小到大自動】 ~~~ Java程序中要求參與的計算的數據，必須要保證數據類型的一致性，如果數據類型不一致將發生類型的轉換。舉例: int + int 兩個都是int,類型一直,可以直接計算,結果是int int + long 類型不一致,可以把int轉換成long(從小到大,自動完成,不需要代碼特殊處理: 自動類型轉換) int + long 類型不一致,可以把long轉換成int(從大到小,不會自動完成,需要代碼特殊處理: 強制類型轉換) 1.自動類型轉換概念: 取值范圍小的數據或者變量,可以直接賦值給取值范圍大的變量(小蘿卜可以直接放入大坑中) 2.特點: (1)自動完成的,不需要代碼的特殊處理 (2)byte/short/char類型數據,只要參加運算會自動轉換為int類型 (3)byte、short、char-->int-->long-->float-->double 舉例: 有一個byte類型(1個字節)的數字5: 00000101 byte類型自動類型轉換成short類型(2個字節): 在數字的左側補充1個字節的0,由于補充的都是0,所以數字的大小不變,還是5 00000000 00000101 byte類型自動類型轉換成int類型(4個字節): 在數字的左側補充3個字節的0,由于補充的都是0,所以數字的大小不變,還是5 00000000 00000000 00000000 00000101 byte類型自動類型轉換成long類型(8個字節): 在數字的左側補充7個字節的0,由于補充的都是0,所以數字的大小不變,還是5 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101 總結(打腫臉充胖子): 根據需求在數字的左側補充若干字節的0,由于補充的都是0,所以數字的大小不變,但是占用的空間發生了變化 ~~~ ~~~ /* 自動類型轉換 1.自動類型轉換概念: 取值范圍小的數據或者變量,可以直接賦值給取值范圍大的變量(小蘿卜可以直接放入大坑中) 2.特點: (1)自動完成的,不需要代碼的特殊處理 (2)byte/short/char類型數據,只要參加運算會自動轉換為int類型 (3)byte、short、char-->int-->long-->float-->double */ public class Demo06Convert { public static void main(String[] args){ int i = 1; byte b = 2; /* b是byte類型,i是int類型,不一致 byte類型只要參加運算,會自動轉換為int類型 byte類型(占1個字節)的b,自動轉換為int類型(占4個字節:左側補充3個字節的0,大小仍然是2) byte + int ==> int + int ==> 兩個int相加,結果是int類型(4個字節), 但是左側變量x是byte類型(1個字節) 錯誤: 右側是int類型,左側變量是byte類型,無法賦值(大蘿卜,不能直接放入小坑當中) 目前解決方案: 把左側的坑變大把左側的byte類型的變量,改成int類型變量 */ //byte x = b + i; /* b是byte類型,i是int類型,不一致 byte類型只要參加運算,會自動轉換為int類型 byte類型(占1個字節)的b,自動轉換為int類型(占4個字節:左側補充3個字節的0,大小仍然是2) byte + int ==> int + int ==> 兩個int相加,結果是int類型(4個字節), 正好左側變量y是int類型(4個字節),可以完成賦值 */ int y = b + i; System.out.println(y); } } ~~~ ~~~ /* 自動類型轉換 */ public class Demo07Convert { public static void main(String[] args){ int i = 1; double d = 2.5; /* d是double類型,i是int類型,不一致 int類型會自動轉換為double類型,在數字后面加上.0 1==>1.0 int + double ==> double + double ==> 兩個double相加,結果是double類型(8個字節), 但是左側變量x是int類型(4個字節) 錯誤: 右側是double類型,左側變量是int類型,無法賦值(大蘿卜,不能直接放入小坑當中) 目前解決方案: 把左側的坑變大把左側的int類型的變量,改成double類型變量 */ //int x = i + d; /* d是double類型,i是int類型,不一致 int類型會自動轉換為double類型,在數字后面加上.0 1==>1.0 int + double ==> double + double ==> 兩個double相加,結果是double類型(8個字節), 正好左側變量x是double類型(8個字節),可以完成賦值 */ double x = i + d; System.out.println(x); } } ~~~ ##### 3.2 強制類型轉換【從大到小強制】 ~~~ 1.強制類型轉換概念: 取值范圍大的數據或者變量,不能夠直接賦值給取值范圍小的變量, 要想賦值,必須進行強制類型轉換(大蘿卜不能直接放入小坑中) 2.格式: 轉后類型變量名稱 = (轉后類型)轉前數據/轉前變量; 舉例: 有一個long類型(8個字節)的數字5: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101 long類型強制類型轉換成int類型(4個字節): 砍掉左側的四個字節內容,由于砍掉的內容都是0,不會影響原有數據的大小 00000000 00000000 00000000 00000101 long類型強制類型轉換成short類型(2個字節): 砍掉左側的六個字節內容,由于砍掉的內容都是0,不會影響原有數據的大小 00000000 00000101 long類型強制類型轉換成byte類型(1個字節): 砍掉左側的七個字節內容,由于砍掉的內容都是0,不會影響原有數據的大小 00000101 總結: 根據需求,砍掉左側若干字節的內容,如果砍掉的都是0,對原數據沒有任何影響,只要砍掉的內容中包含1,就會影響原有數據的大小 ~~~ ~~~ /* 1.強制類型轉換概念: 取值范圍大的數據或者變量,不能夠直接賦值給取值范圍小的變量, 要想賦值,必須進行強制類型轉換(大蘿卜不能直接放入小坑中) 2.格式: 轉后類型變量名稱 = (轉后類型)轉前數據/轉前變量; */ public class Demo08Convert { public static void main(String[] args){ short s = 1; /* s是short類型,1是int類型,不一致 short類型只要參加運算,會自動轉換為int類型 short類型(占2個字節)的s,自動轉換為int類型(占4個字節:左側補充2個字節的0,大小仍然是1) short + int ==> int + int ==> 兩個int相加,結果是int類型(4個字節), 但是左側變量s是short類型(2個字節) 錯誤: 右側是int類型,左側變量是short類型,無法賦值(大蘿卜,不能直接放入小坑當中) 目前解決方案: 強制類型轉換,把右側的int類型結果強制轉換成short類型 */ //s = s + 1; /* 把s+1的最終的int類型的結果數據,強制轉換成short類型(砍掉左側的兩個字節的0) int類型結果: 00000000 00000000 00000000 00000010 強制轉換后的short類型結果: 00000000 00000010 */ s = (short)(s + 1); System.out.println(s); } } ~~~ ~~~ /* 強制類型轉換問題: 可能會損失精度 */ public class Demo09Convert { public static void main(String[] args){ /* 右側1.5是double類型占8個字節(大蘿卜), 左側的變量int類型占4個字節(小坑) 問題: 大蘿卜不能直接放入小坑中解決方案: 強制類型轉換 */ //int i = 1.5; //小數強制類型轉換成整數: 直接砍掉小數部分,所以會損失精度 int j = (int)1.5; System.out.println(j);// } } ~~~ ##### 圖解(其它案例): ![](https://img.kancloud.cn/0e/68/0e68f342f46d4a3207b7d6a71b2a0aa9_1298x510.png) ##### 3.3 ASCII碼表 ~~~ 計算機是一個二貨,只能存儲0和1,所以存儲到計算機中的所有內容都會轉換成0和1進行存儲所以我們在計算機中存儲的字符也不例外,也需要把字符轉換成0和1進行存儲問題: 如何把字符轉換成0和1呢? 解決方案: 使用ASCII編碼表: 存儲字符和數字對應關系的一張表格存儲字符時：需要查找ASC碼表,找到字符對應的數字,將數字轉換為二進制數存放到計算機中 'a' ---> 97 ---> 1100001 小寫字母對應的int數字是連續的 'A' ---> 65 ---> 1000001 大寫字母對應的int數字是連續的 '0' ---> 48 ---> 110000 數字字符對應的int數字是連續的使用字符時：將對應的二進制數轉換為十進制找到ASC表中對應的字符顯示出來 1100001 ---> 97 ---> 'a' 1000001 ---> 65 ---> 'A' 110000 ---> 48 ---> '0' ~~~ ![](https://img.kancloud.cn/c6/04/c604966240fde9ea809469af06ba575a_778x581.png) ##### 3.4 int類型和char類型的運算原理 ~~~ public class Demo10Char { public static void main(String[] args){ //定義char類型的變量ch,初始值'A' char ch = 'A'; System.out.println(ch);//'A' /* byte/short/char類型數據,只要參加運算會自動轉換為int類型 char類型數據和int類型數據一起運算會把char類型的數據自動類型轉換為int類型問題: 如何把char類型的'A'轉換成int類型呢? 答案: 查看ASCII碼表: 'A' --> 65 char + int ==> int + int ==> 65 + 1 ==>66 */ System.out.println(ch+1);//66 /* byte/short/char類型數據,只要參加運算會自動轉換為int類型把ch+1的結果數據66強制類型轉換成char類型問題: 如何把int轉換為對應的char類型呢? 答案: 查看ASCII碼表: 66 --> 'B' */ System.out.println((char)(ch+1));//'B' } } ~~~ ### 第三章運算符 ##### 4.1 算術運算符加減乘除 ~~~ 1.運算符：對常量或者變量進行操作/運算的符號 2.表達式：用運算符把常量或者變量連接起來符合java語法的式子就可以稱為表達式。 3.數學運算符: (1)+: 加法運算 (2)-: 減法運算 (3)*: 乘法運算 (4)/: 除法運算 /* 算數運算符 1.運算符：對常量或者變量進行操作/運算的符號 2.表達式：用運算符把常量或者變量連接起來符合java語法的式子就可以稱為表達式。 3.數學運算符: (1)+: 加法運算 (2)-: 減法運算 (3)*: 乘法運算 (4)/: 除法運算數學中的除法運算: 被除數 ÷ 除數 = 商(/: 取的是商) .... 余數 */ public class Demo11Operator { public static void main(String[] args){ int a = 10,b = 20; System.out.println(a + b);//打印變量a和b中數據的和: 10 + 20 結果: 30 System.out.println(a - b);//打印變量a和b中數據的查: 10 - 20 結果: -10 System.out.println(a * b);//打印變量a和b中數據的積: 10 * 20 結果: 200 System.out.println(b / a);//打印變量b和a中數據的商: 20 / 10 結果: 2 //int/int ==> 結果一定是int類型 System.out.println(3/2);//1 //double/int ==> double/double ==> double System.out.println(3.0/2);//1.5 } } ~~~ ##### 4.2 算術運算符% ~~~ /* %運算符: 取余數運算符數學中的除法運算: 被除數 ÷ 除數 = 商(/: 取的是商) .... 余數(%: 取的是余數) 作用: 1.判斷數字的奇偶性偶數: 可以被2整除余數是0 奇數: 不可以被2整除余數是1 2.判斷一個數字能否被另一個數字整除思考: 結合/和%,來計算一個四位數字的每位數字 1234: 個位: 4 十位: 3 百位: 2 千位: 1 */ public class Demo12Operator { public static void main(String[] args){ System.out.println(12%2);//0: 說明12是偶數 System.out.println(13%2);//1: 說明13是奇數 System.out.println(100%25);//0: 說明100可以被25整除 System.out.println(120%25);//20: 說明100不可以被25整除 } } ~~~ ##### 4.3 算術運算符+的特殊用法當+前面是字符串時 +相當于做字符串拼接 "5 + 5" + 5 + 5 => 5+5 = 55 ~~~ /* 算術運算符+的特殊用法 1.進行數學中的加法運算 2.+的前后有字符串,此時+不再代表數學中的加法運算,代表字符串的連接 */ public class Demo13Operator { public static void main(String[] args){ System.out.println(5+5);//10 /* byte/short/char類型數據,只要參加運算會自動轉換為int類型 char + int ==> int + int ==> int 需要查看ASCII碼表,把字母'A'轉換成對應的數字65 */ System.out.println('A'+5);//'A'+5 ==> 65 + 5 ==> 70 /* byte/short/char類型數據,只要參加運算會自動轉換為int類型 char + char ==> int + int 需要查看ASCII碼表,把字母'A'轉換成對應的數字65 需要查看ASCII碼表,把字母'B'轉換成對應的數字66 */ System.out.println('A'+'B');//'A'+'B' ==> 65 + 66 ==> 131 System.out.println("HelloWorld"); System.out.println("Hello"+"World");//此處+代表字符串的連接: 把World連接到Hello的后面 /* 表達式"5+5="+5+5: 是從左向右運算先計算"5+5="+5: 因為+的前面是字符串,此處+代表字符串的連接: "5+5=5" 再計算"5+5=5"+5:因為+的前面是字符串,此處+代表字符串的連接: "5+5=55" */ System.out.println("5+5="+5+5);//5+5=55 /* 表達式"5+5="+(5+5): 是從左向右運算因為表達式中有(),優先計算()中的式子5+5: +代表的是加法運算: 10 表達式"5+5="+(5+5)變為了:"5+5="+10 此處+前面是一個字符串,所以+代表字符串的連接: "5+5=10" */ System.out.println("5+5="+(5+5));//5+5=55 } } ~~~ ##### 4.4 賦值運算符 ~~~ = 賦值 a=10，將10賦值給變量a += 加后賦值 a+=b，將a+b的值給a a = a + b -= 減后賦值 a-=b，將a-b的值給a a = a - b *= 乘后賦值 a*=b，將a×b的值給a a = a * b /= 除后賦值 a/=b，將a÷b的商給a a = a / b %= 取余后賦值 a%=b，將a÷b的余數給a a = a % b ~~~ ~~~ public class Demo14Operator { public static void main(String[] args){ int a;//定義int變量a a = 10;//把數字10賦值給變量a System.out.println(a);//打印變量a中的值 int b = 20, c = 30; b += c;// b = b + c System.out.println(b);//打印變量b中的值: 50 System.out.println(c);//打印變量c中的值: 30 int d = 5, e = 3; d %= e;// d = d % e ==> 5 % 3: 2 System.out.println(d);//打印變量d中的值: 2 System.out.println(e);//打印變量e中的值: 3 } } ~~~ ##### 4.5 賦值運算符的特點 ~~~ /* 賦值運算符的特點 1.+=,-=,*=,/=,%= 如果計算結果的數據類型和左側變量的數據類型不一致,會自動進行隱藏的強制類型轉換 2.整數常量只要不超出所賦值的變量的取值范圍,就可以直接賦值,內部隱藏強制類型轉換 */ public class Demo15Operator { public static void main(String[] args){ short s = 1; /* s是short類型,1是int類型,不一致 short類型只要參加運算,會自動轉換為int類型 short類型(占2個字節)的s,自動轉換為int類型(占4個字節:左側補充2個字節的0,大小仍然是1) short + int ==> int + int ==> 兩個int相加,結果是int類型(4個字節), 但是左側變量s是short類型(2個字節) 錯誤: 右側是int類型,左側變量是short類型,無法賦值(大蘿卜,不能直接放入小坑當中) 目前解決方案: 強制類型轉換,把右側的int類型結果強制轉換成short類型 */ //s = s + 1; //目前解決方案: 強制類型轉換,把右側的int類型結果強制轉換成short類型 //s = (short)(s+1); /* 把short類型s的值和int類型1相加結果是int類型的2,再賦值給short類型的s的時候,會幫助我們進行強制類型轉換 */ s += 1;//等價于s = (short)(s+1); System.out.println(s); /* 右側100是int類型,占四個字節左側變量b是byte類型,占1個字節按照道理講: 大蘿卜是不能直接放入小坑中的目前運行代碼發現沒有問題: 原因: 整數常量只要不超出所賦值的變量的取值范圍,就可以直接賦值,內部隱藏強制類型轉換 int類型100: 00000000 00000000 00000000 01100100 強制轉換成byte: 砍掉左側三個字節的0,數字大小沒變 01100100 */ byte b = 100;//內部: byte b = (byte)100; System.out.println(b); } } ~~~ ##### 4.6 自增自減運算符 ~~~ /* 自增(++)和自減(--)運算符 1.作用: 就是讓變量的值增加1(++)或者減少1(--) 2.使用格式: (1)可以寫在變量的前面: ++a,--a (2)可以寫在變量的后面: a++,a-- 以下以++為例 3.使用方式: (1)單獨使用: 不和其它操作(賦值/打印)一起進行運算 ++寫在變量的前面和++寫在變量的后面: 效果是一樣的,都是讓變量的值增加1 (2)混合使用: 和其它操作(賦值/打印)一起進行運算 ++寫在變量的前面和++寫在變量的后面: 有重大區別 ++寫在變量的前面: 先++后使用先把變量的值增加1,然后再使用變量增加1之后的結果數據 ++寫在變量的后面: 先使用后++ 先使用變量中的值(此時還沒有增加1),然后把變量的值增加1 最常用的: a++和a-- */ public class Demo16Operator { public static void main(String[] args){ int a = 2; ++a;//單獨使用: a = a + 1 System.out.println(a);//3 int b = 2; b++;//單獨使用: b = b + 1 System.out.println(b);//3 System.out.println("-------------"); int c = 2; /* ++和=一起構成了混合運算因為++在變量c的前面,所以先把變量c的值增加1,c增加1之后的結果數據3, 然后把c增加1之后的結果數據3賦值給變量d,所以d的值是3 */ int d = ++c; System.out.println(c);//3 System.out.println(d);//3 System.out.println("-------------"); int e = 2; /* ++和=一起構成了混合運算因為++在變量e的后面,所以先使用e的值(沒有增加1之前的值)2賦值給變量f,所以f的值是2 然后e的值增加1,變為3 */ int f = e++; System.out.println(e);//3 System.out.println(f);//2 } } ~~~ ~~~ /* 自增自減運算符的練習 */ public class Demo17Operator { public static void main(String[] args){ int x = 4; /* 表達式(x++)+(++x)+(x*10): 從左向右計算先計算x++: 因為++在x的后面,所以先使用x的值4,和后面的內容進行加法運算,然后x的值增加1,變成5 (x++)+(++x)+(x*10)==> 4 + (++x)+(x*10): 注意這個式子中x的值5 再計算(++x): 因為++在x的前面,所以x的值先增加1變為6,然后再使用結果數據6 4 + (++x)+(x*10) ==> 4 + 6 + (x*10): 注意這個式子中x的值6 4 + 6 + (x*10) ==> 4 + 6 + 6*10 = 70 */ int y = (x++)+(++x)+(x*10); System.out.println("x="+x);//6 System.out.println("y="+y);//70 } } ~~~ ## 總結 ~~~ 能夠說出8種基本數據類型 1.整數: byte,short,int,long 2.小數: float,double 3.字符: char 4.布爾: boolean 能夠完成變量的定義及輸出 int a = 10; sout(a); int b = 20, c = 30; sout(b); sout(c); int d; d = 50; sout(d); int e,f; e = 60; f = 70; sout(e); sout(f); 能夠知道類型轉換的格式和順序【小到大自動，大到小強制】從小到大: 自動類型轉換不需要代碼干預從大到小: 強制類型轉換把long類型的數據強制轉換為int類型轉換后類型變量名稱 = (轉后類型)轉前數據/變量; long num = 100L; int a = (int)num; 能夠說出常見的運算符有哪幾種 +,-,*,/(商),%(余數) 能夠知道除法和取余的區別 5 ÷ 2 = 2(商: /) ....1(余數: %) 能夠完成字符和字符串的加 +的特殊用法 1.數學中的加法運算: int + int ,int + char, char + char 2.字符串的連接 +前面或者后面有字符串時,此時+代表字符串連接,把后面的內容連接到前面的串的后面 "hello"+5: "hello5" 5+"hello": "5hello" 5+5+"hello": 10 + "hello" ==> "10hello" ~~~