自增加
+在遇到字串時：表示拼接
三目運算子：
擴展知識：
代碼：
Demo04Operator.java
/* 運算子：進行特定操作的符號，例如：+ 運算式：用運算子連起來的式子叫做運算式，例如：20 + 5，又例如：a + b 四則運算： 加：+ 減：- 乘：* 除：/ 取模（取余數）：% 首先計算得到運算式的結果，然后再列印輸出這個結果， 復習一下小學一年級的除法公式： 被除數 / 除數 = 商 ... 余數 對于一個整數的運算式來說，除法用的是整除，整數除以整數，結果仍然是整數，只看商，不看余數， 只有對于整數的除法來說，取模運算子才有余數的意義， 注意事項： 1. 一旦運算當中有不同型別的資料，那么結果將會是資料型別范圍大的那種， */ public class Demo04Operator { public static void main(String[] args) { // 兩個常量之間可以進行數學運算 System.out.println(20 + 30); // 兩個變數之間也可以進行數學運算 int a = 20; int b = 30; System.out.println(a - b); // -10 // 變數和常量之間可以混合使用 System.out.println(a * 10); // 200 int x = 10; int y = 3; int result1 = x / y; System.out.println(result1); // 3 int result2 = x % y; System.out.println(result2); // 余數，模，1 // int + double --> double + double --> double double result3 = x + 2.5; System.out.println(result3); // 12.5 } }View Code
Demo05Plus.java
/* 四則運算當中的加號“+”有常見的三種用法： 1. 對于數值來說，那就是加法， 2. 對于字符char型別來說，在計算之前，char會被提升成為int，然后再計算， char型別字符，和int型別數字，之間的對照關系表：ASCII、Unicode 3. 對于字串String（首字母大寫，并不是關鍵字）來說，加號代表字串連接操作， 任何資料型別和字串進行連接的時候，結果都會變成字串 */ public class Demo05Plus { public static void main(String[] args) { // 字串型別的變數基本使用 // 資料型別 變數名稱 = 資料值; String str1 = "Hello"; System.out.println(str1); // Hello System.out.println("Hello" + "World"); // HelloWorld String str2 = "Java"; // String + int --> String System.out.println(str2 + 20); // Java20 // 優先級問題 // String + int + int // String + int // String System.out.println(str2 + 20 + 30); // Java2030 System.out.println(str2 + (20 + 30)); // Java50 } }View Code
Demo06Operator.java
/* 自增運算子：++ 自減運算子：-- 基本含義：讓一個變數漲一個數字1，或者讓一個變數降一個數字1 使用格式：寫在變數名稱之前，或者寫在變數名稱之后，例如：++num，也可以num++ 使用方式： 1. 單獨使用：不和其他任何操作混合，自己獨立成為一個步驟， 2. 混合使用：和其他操作混合，例如與賦值混合，或者與列印操作混合，等， 使用區別： 1. 在單獨使用的時候，前++和后++沒有任何區別，也就是：++num;和num++;是完全一樣的， 2. 在混合的時候，有【重大區別】 A. 如果是【前++】，那么變數【立刻馬上+1】，然后拿著結果進行使用， 【先加后用】 B. 如果是【后++】，那么首先使用變數本來的數值，【然后再讓變數+1】， 【先用后加】 注意事項： 只有變數才能使用自增、自減運算子，常量不可發生改變，所以不能用， */ public class Demo06Operator { public static void main(String[] args) { int num1 = 10; System.out.println(num1); // 10 ++num1; // 單獨使用，前++ System.out.println(num1); // 11 num1++; // 單獨使用，后++ System.out.println(num1); // 12 System.out.println("================="); // 與列印操作混合的時候 int num2 = 20; // 混合使用，先++，變數立刻馬上變成21，然后列印結果21 System.out.println(++num2); // 21 System.out.println(num2); // 21 System.out.println("================="); int num3 = 30; // 混合使用，后++，首先使用變數本來的30，然后再讓變數+1得到31 System.out.println(num3++); // 30 System.out.println(num3); // 31 System.out.println("================="); int num4 = 40; // 和賦值操作混合 int result1 = --num4; // 混合使用，前--，變數立刻馬上-1變成39，然后將結果39交給result1變數 System.out.println(result1); // 39 System.out.println(num4); // 39 System.out.println("================="); int num5 = 50; // 混合使用，后--，首先把本來的數字50交給result2，然后我自己再-1變成49 int result2 = num5--; System.out.println(result2); // 50 System.out.println(num5); // 49 System.out.println("================="); int x = 10; int y = 20; // 11 + 20 = 31 int result3 = ++x + y--; System.out.println(result3); // 31 System.out.println(x); // 11 System.out.println(y); // 19 // 30++; // 錯誤寫法！常量不可以使用++或者-- } }View Code
Demo07Operator.java
/* 賦值運算子分為： 基本賦值運算子：就是一個等號“=”，代表將右側的資料交給左側的變數， int a = 30; 復合賦值運算子： += a += 3 相當于 a = a + 3 -= b -= 4 相當于 b = b - 4 *= c *= 5 相當于 c = c * 5 /= d /= 6 相當于 d = d / 6 %= e %= 7 相當于 e = e % 7 注意事項： 1. 只有變數才能使用賦值運算子，常量不能進行賦值， 2. 復合賦值運算子其中隱含了一個強制型別轉換， */ public class Demo07Operator { public static void main(String[] args) { int a = 10; // 按照公式進行翻譯：a = a + 5 // a = 10 + 5; // a = 15; // a本來是10，現在重新賦值得到15 a += 5; System.out.println(a); // 15 int x = 10; // x = x % 3; // x = 10 % 3; // x = 1; // x本來是10，現在重新賦值得到1 x %= 3; System.out.println(x); // 1 // 50 = 30; // 常量不能進行賦值，不能寫在賦值運算子的左邊，錯誤寫法！ byte num = 30; // num = num + 5; // num = byte + int // num = int + int // num = int // num = (byte) int num += 5; System.out.println(num); // 35 } }View Code
Demo08Operator.java
/* 比較運算子： 大于： > 小于： < 大于等于： >= 小于等于： <= 相等： == 【兩個等號連寫才是相等，一個等號代表的是賦值】 不相等： != 注意事項： 1. 比較運算子的結果一定是一個boolean值，成立就是true，不成立就是false 2. 如果進行多次判斷，不能連著寫， 數學當中的寫法，例如：1 < x < 3 程式當中【不允許】這種寫法， */ public class Demo08Operator { public static void main(String[] args) { System.out.println(10 > 5); // true int num1 = 10; int num2 = 12; System.out.println(num1 < num2); // true System.out.println(num2 >= 100); // false System.out.println(num2 <= 100); // true System.out.println(num2 <= 12); // true System.out.println("==============="); System.out.println(10 == 10); // true System.out.println(20 != 25); // true System.out.println(20 != 20); // false int x = 2; // System.out.println(1 < x < 3); // 錯誤寫法！編譯報錯！不能連著寫， } }View Code
Demo09Logic.java
/* 與（并且） && 全都是true，才是true；否則就是false 或（或者） || 至少一個是true，就是true；全都是false，才是false 非（取反） ! 本來是true，變成false；本來是false，變成true 與“&&”，或“||”，具有短路效果：如果根據左邊已經可以判斷得到最終結果，那么右邊的代碼將不再執行，從而節省一定的性能， 注意事項： 1. 邏輯運算子只能用于boolean值， 2. 與、或需要左右各自有一個boolean值，但是取反只要有唯一的一個boolean值即可， 3. 與、或兩種運算子，如果有多個條件，可以連續寫， 兩個條件：條件A && 條件B 多個條件：條件A && 條件B && 條件C TIPS： 對于1 < x < 3的情況，應該拆成兩個部分，然后使用與運算子連接起來： int x = 2; 1 < x && x < 3 */ public class Demo09Logic { public static void main(String[] args) { System.out.println(true && false); // false // true && true --> true System.out.println(3 < 4 && 10 > 5); // true System.out.println("============"); System.out.println(true || false); // true System.out.println(true || true); // true System.out.println(false || false); // false System.out.println("============"); System.out.println(true); // true System.out.println(!true); // false System.out.println("============"); int a = 10; // false && ... System.out.println(3 > 4 && ++a < 100); // false System.out.println(a); // 10 System.out.println("============"); int b = 20; // true || ... System.out.println(3 < 4 || ++b < 100); // true System.out.println(b); // 20 } }View Code
Demo10Operator.java
/* 一元運算子：只需要一個資料就可以進行操作的運算子，例如：取反!、自增++、自減-- 二元運算子：需要兩個資料才可以進行操作的運算子，例如：加法+、賦值= 三元運算子：需要三個資料才可以進行操作的運算子， 格式： 資料型別 變數名稱 = 條件判斷 ? 運算式A : 運算式B; 流程： 首先判斷條件是否成立： 如果成立為true，那么將運算式A的值賦值給左側的變數； 如果不成立為false，那么將運算式B的值賦值給左側的變數； 二者選其一， 注意事項： 1. 必須同時保證運算式A和運算式B都符合左側資料型別的要求， 2. 三元運算子的結果必須被使用， */ public class Demo10Operator { public static void main(String[] args) { int a = 10; int b = 20; // 資料型別 變數名稱 = 條件判斷 ? 運算式A : 運算式B; // 判斷a > b是否成立，如果成立將a的值賦值給max；如果不成立將b的值賦值給max，二者選其一 int max = a > b ? a : b; // 最大值的變數 System.out.println("最大值：" + max); // 20 // int result = 3 > 4 ? 2.5 : 10; // 錯誤寫法！ System.out.println(a > b ? a : b); // 正確寫法！ // a > b ? a : b; // 錯誤寫法！ } }View Code
Demo11Method.java
/* 定義一個方法的格式： public static void 方法名稱() { 方法體 } 方法名稱的命名規則和變數一樣，使用小駝峰， 方法體：也就是大括號當中可以包含任意條陳述句， 注意事項： 1. 方法定義的先后順序無所謂， 2. 方法的定義不能產生嵌套包含關系， 3. 方法定義好了之后，不會執行的，如果要想執行，一定要進行方法的【呼叫】， 如何呼叫方法，格式： 方法名稱(); */ public class Demo11Method { public static void main(String[] args) { farmer(); // 呼叫農民的方法 seller(); // 呼叫小商販的方法 cook(); // 呼叫廚子的方法 me(); // 呼叫我自己的方法 } // 廚子 public static void cook() { System.out.println("洗菜"); System.out.println("切菜"); System.out.println("炒菜"); System.out.println("裝盤"); } // 我 public static void me() { System.out.println("吃"); } // 小商販 public static void seller() { System.out.println("運輸到農貿市場"); System.out.println("抬高價格"); System.out.println("吆喝"); System.out.println("賣給廚子"); } // 農民伯伯 public static void farmer() { System.out.println("播種"); System.out.println("澆水"); System.out.println("施肥"); System.out.println("除蟲"); System.out.println("收割"); System.out.println("賣給小商販"); } }View Code
Demo12Notice.java
/* 對于byte/short/char三種型別來說，如果右側賦值的數值沒有超過范圍， 那么javac編譯器將會自動隱含地為我們補上一個(byte)(short)(char)， 1. 如果沒有超過左側的范圍，編譯器補上強轉， 2. 如果右側超過了左側范圍，那么直接編譯器報錯， */ public class Demo12Notice { public static void main(String[] args) { // 右側確實是一個int數字，但是沒有超過左側的范圍，就是正確的， // int --> byte，不是自動型別轉換 byte num1 = /*(byte)*/ 30; // 右側沒有超過左側的范圍 System.out.println(num1); // 30 // byte num2 = 128; // 右側超過了左側的范圍 // int --> char，沒有超過范圍 // 編譯器將會自動補上一個隱含的(char) char zifu = /*(char)*/ 65; System.out.println(zifu); // A } }View Code
Demo13Notice.java
/* 在給變數進行賦值的時候，如果右側的運算式當中全都是常量，沒有任何變數， 那么編譯器javac將會直接將若干個常量運算式計算得到結果， short result = 5 + 8; // 等號右邊全都是常量，沒有任何變數參與運算 編譯之后，得到的.class位元組碼檔案當中相當于【直接就是】： short result = 13; 右側的常量結果數值，沒有超過左側范圍，所以正確， 這稱為“編譯器的常量優化”， 但是注意：一旦運算式當中有變數參與，那么就不能進行這種優化了， */ public class Demo13Notice { public static void main(String[] args) { short num1 = 10; // 正確寫法，右側沒有超過左側的范圍， short a = 5; short b = 8; // short + short --> int + int --> int // short result = a + b; // 錯誤寫法！左側需要是int型別 // 右側不用變數，而是采用常量，而且只有兩個常量，沒有別人 short result = 5 + 8; System.out.println(result); short result2 = 5 + a + 8; // 18 } }View Code
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/241200.html
標籤：Java