運算符

1.隱式轉換和強制轉換

 類型轉換的分類
1.隱式轉換：
取值范圍小的數值 轉換為 取值范圍大的數值
2.強制轉換：
取值范圍大的數值 轉換為 取值范圍小的數值隱式轉換的兩種提升規則
取值范圍小的，和取值范圍大的進行運算，小的會先提升為大的，再進行運算
byte short char 三種類型的數據在運算的時候，都會直接先提升為 int，然后再進行運算byte => intint => long => float => doubleshort => int

//        判斷結果的數據類型：
//        byte b1 = 10;
//        byte b2 = 20;
//        result = b1 + b2;   // 數據類型 int
//
//        int i = 10;
//        long n = 100L;
//        double d = 20.0;
//        result = i + n + d;   // 數據類型 double
//
//        byte b = 10;
//        short s = 20;
//        long n = 100L;
//        result = b + s + n;   // 數據類型 long

強制轉換
如果把一個取值范圍大的數值，賦值給取值范圍小的變量。是不允許直接賦值的。如果一定要這么做就需要加入強制轉換。
格式：目標數據類型 變量名 =(目標數據類型) 被強轉的數據；

????????//        范例：double a = 12.3;int b = (int) a;byte b1 = 100;byte b2 = 100;byte result = (byte)(b1 + b2);System.out.println(result);// -56  結果就發生錯誤了 因為要轉換的數據過大

2.字符串和字符的加操作

字符串的 “+” 操作
當 “+” 操作中出現字符串時，這個 “+” 是字符串連接符，而不是算術運算符了。會將前后的數據進行拼接，并產生一個新的字符串。
“123” + 123  結果為  “123123”
連續進行 “+” 操作時，從左到右逐個執行。
1 + 99 + “年黑馬”  結果為  “100 年黑馬”

// 當 字符+字符 或 字符+數字 時，會把字符通過 ASCII 碼表查詢到對應的數字再進行計算。System.out.println(1 + 'a'); //98System.out.println('a' + 'c'); //196System.out.println('a' + "abc"); //aabc

3.自增自減運算符

//        單獨使用: ++ 和 -- 無論是放在變量的前邊還是后邊，單獨寫一行結果是一樣的。
//        參與計算:
//        先用后加int a = 10;int b = a++;
//        先加后用int a = 10;int b = ++a;

4.賦值運算符和關系運算符

        賦值運算符符號      作用                    說明=          賦值         int a = 10，將 10 賦值給變量 a+=     加后賦值       a += b，將 a + b 的值給 a-=     減后賦值       a -= b，將 a - b 的值給 a*=     乘后賦值       a *= b，將 a × b 的值給 a/=     除后賦值       a /= b，將 a ÷ b 的商給 a%=     取余后賦值  a %= b，將 a ÷ b 的余數給 a關系運算符符號             說明==     a==b，判斷 a 和 b 的值是否相等，成立為 true，不成立為 false!=     a!=b，判斷 a 和 b 的值是否不相等，成立為 true，不成立為 false>      a>b，判斷 a 是否大于 b，成立為 true，不成立為 false>=     a>=b，判斷 a 是否大于等于 b，成立為 true，不成立為 false<      a<b，判斷 a 是否小于 b，成立為 true，不成立為 false<=     a<=b，判斷 a 是否小于等于 b，成立為 true，不成立為 false

5.四種邏輯運算符和兩個短路邏輯運算符

        符號    作用         說明&        邏輯與（且） 并且，兩邊都為真，結果才是真|        邏輯或        或者，兩邊都為假，結果才是假^        邏輯異或       相同為 false，不同為 true!        邏輯非        取反&&   短路與        結果和 & 相同，但是有短路效果||   短路或        結果和 | 相同，但是有短路效果

6.三元運算符和運算符的優先級

        (三元運算符 / 三元表達式) 格式格式：關系表達式? 表達式1: 表達式2;

//        范例：求兩個數的較大值int max = a > b ? a : b;System.out.println(a > b ? a : b);

        計算規則首先計算關系表達式的值如果值為 true，表達式 1 的值就是運算結果如果值為 false，表達式 2 的值就是運算結果小括號()的優先級最高

判斷和循環

1.順序結構

//    順序結構語句是 Java 程序默認的執行流程，按照代碼的先后順序，從上到下依次執行System.out.println("努力做主人喜歡的事");System.out.println("大小姐駕到！統統閃開！");System.out.println("凜冬已至，故鄉的梅花開了嗎");System.out.println("心懷不懼，方能翱翔于天際");

2.分支結構if

   if格式if(關系表達式){語句體;}if 的注意點：大括號的開頭可以另起一行書寫，但是建議寫在第一行的末尾在語句體中，如果只有一句代碼，大括號可以省略不寫如果對一個布爾類型的變量進行判斷，不要用 == 號if (關系表達式) {語句體1;} else {語句體2;}執行流程：I. 首先計算關系表達式的值II. 如果關系表達式的值為 true 就執行語句體 1III. 如果關系表達式的值為 false 就執行語句體 2IV. 繼續執行后面的其他語句if (關系表達式1) {語句體1;} else if (關系表達式2) {語句體2;}...else {語句體 n + 1;}執行流程：I. 首先計算關系表達式 1 的值II. 如果為 true 就執行語句體 1；如果為 false 就計算關系表達式 2 的值III. 如果為 true 就執行語句體 2；如果為 false 就計算關系表達式 3 的值IV. ……V. 如果所有關系表達式結果都為 false，就執行語句體 n+1

3.分支結構switch

        switch(表達式) {case 值1:語句體1;break;case 值2:語句體2;break;...default:語句體n+1;break;}執行流程：I. 首先計算表達式的值。II. 依次和 case 后面的值進行比較，如果有對應的值，就會執行相應的語句，在執行的過程中，遇到 break 就會結束。III. 如果所有的 case 后面的值和表達式的值都不匹配，就會執行 default 里面的語句體，然后結束整個 switch 語句。default 的位置和省略位置：default 不一定是寫在最下面的，我們可以寫在任意位置。只不過習慣會寫在最下面省略：default 可以省略，語法不會有問題，但是不建議省略。case 穿透就是語句體中沒有寫 break 導致的。執行流程：首先還是會拿著小括號中表達式的值跟下面每一個 case 進行匹配。如果匹配上了，就會執行對應的語句體，如果此時發現了 break，那么結束整個 switch 語句。如果沒有發現 break，那么程序會繼續執行下一個 case 的語句體，一直遇到 break 或者右大括號為止使用場景：如果多個 case 的語句體重復了，那么我們考慮利用 case 穿透去簡化代碼。

//        用箭頭簡寫int number = 1;switch (number){case 1 -> {System.out.println("一");break;}case 2 -> {System.out.println("二");break;}case 3 -> {System.out.println("三");break;}default -> {System.out.println("沒有這種選項");break;}}

//        省略大括號switch (number){case 1 -> System.out.println("一");case 2 -> System.out.println("二");case 3 -> System.out.println("三");default -> System.out.println("沒有這種選項");}

4.循環語句for

        格式：for (初始化語句 ;條件判斷語句 ;條件控制語句) {循環體語句;}執行流程：
① 執行初始化語句
② 執行條件判斷語句，看其結果是 true 還是 false如果是 false，循環結束如果是 true，執行循環體語句
③ 執行條件控制語句
④ 回到②繼續執行條件判斷語句

5.循環語句while

    初始化語句;while(條件判斷語句){循環體語句;條件控制語句;}for 和 while 的區別：for 循環中，控制循環的變量，因為歸屬 for 循環的語法結構中，在 for 循環結束后，就不能再次被訪問到了while 循環中，控制循環的變量，對于 while 循環來說不歸屬其語法結構中，在 while 循環結束后，該變量還可以繼續使用

循環高級綜合練習

1.無限循環和跳轉控制語句

//for格式的無限循環
for(;;){System.out.println("學習");
}

//while格式的無限循環
while(true){System.out.println("學習");
}

注意事項
無限循環的下面不能再寫其他代碼了，因為循環永遠停不下來，那么下面的代碼永遠執行不到

//1.continue跳過某一次循環
for (int i = 1; i <= 5; i++) {if(i == 3){//結束本次循環，繼續下次循環continue;}System.out.println("小老虎在吃第" + i + "個包子");
}
//2.結束整個循環
for (int i = 1; i <= 5; i++) {if(i == 3){//結束整個循環break;}System.out.println("小老虎在吃第" + i + "個包子");

數組

1.數組的概述和靜態初始化

        數組：是一種容器，可以用來存儲同種數據類型的多個值數組容器在存儲數據的時候，需要結合隱式轉換考慮格式一：數據類型 [] 數組名范例：int [] array格式二：數據類型 數組名 []范例：int array[]數組的初始化初始化：就是在內存中，為數組容器開辟空間，并將數據存入容器中的過程。數組初始化的兩種方式1.靜態初始化2.動態初始化數組的靜態初始化初始化：就是在內存中，為數組容器開辟空間，并將數據存入容器中的過程完整格式：數據類型 [] 數組名 = new 數據類型 []{元素1，元素2，元素3...};范例：int [] array = new int []{11, 22, 33};范例：double [] array2 = new double []{11.1, 22.2, 33.3};簡化格式：數據類型 [] 數組名 = {元素1，元素2，元素3...};范例：int [] array = {11, 22, 33};范例：double [] array2 = {11.1, 22.2, 33.3};

//需求1：定義數組存儲5個學生的年齡int[] arr1 = new int[]{11,12,13,14,15};int[] arr2 = {11,12,13,14,15};//需求2：定義數組存儲3個學生的姓名String[] arr3 = new String[]{"zhangsan","lisi","wangwu"};String[] arr4 = {"zhangsan","lisi","wangwu"};//需求3：定義數組存儲4個學生的身高 1.93double[] arr5 = new double[]{1.93,1.75,1.73,1.81};double[] arr6 = {1.93,1.75,1.73,1.81};

2.數組的地址值和元素訪問

double[] arr6 = {1.93,1.75,1.73,1.81};
System.out.println(arr6);//[D@23fc625e  地址值
擴展：
解釋一下地址值的格式含義 [D@23fc625e
[ ：表示當前是一個數組
D：表示當前數組里面的元素都是double類型的
@：表示一個間隔符號。（固定格式）
23fc625e：才是數組真正的地址值，（十六進制）平時我們習慣性的會把這個整體叫做數組的地址值

數組元素訪問
格式：數組名[索引];
索引：也叫做下標，角標。
索引的特點：從 0 開始，逐個 + 1 增長，連續不間斷利用索引對數組中的元素進行訪問
1.獲取數組里面的元素
格式： 數組名[索引]

int[] arr = {1,2,3,4,5};
//獲取數組中的第一個元素
//其實就是0索引上對應的元素
int number = arr[0];
System.out.println(number);//1
//獲取數組中1索引上對應的數據，并直接打印出來
System.out.println(arr[1]);//2//2.把數據存儲到數組當中
//格式：  數組名[索引] = 具體數據/變量;
arr[0] = 100;
System.out.println(arr[0]);//100

3.數組的遍歷

        int[] arr = {1,2,3,4,5};
在Java當中，關于數組的一個長度屬性，length
調用方式：數組名.lengthSystem.out.println(arr.length);for (int i = 0; i < arr.length; i++) {//i: 0 1 2 3 4System.out.println(arr[i]);}擴展：
自動的快速生成數組的遍歷方式
idea提供的
數組名.fori

4.數組的動態初始化和常見問題

        數組動態初始化動態初始化：初始化時只指定數組長度，由系統為數組分配初始值。格式：數據類型[] 數組名 = new 數據類型[數組長度];范例：int[] arr = new int[3];

//在創建的時候，由我們自己指定數組的長度，由虛擬機給出默認的初始化值String[] arr = new String[50];
//添加學生arr[0] = "zhangsan";arr[1] = "lisi";
//獲取System.out.println(arr[0]);//zhangsanSystem.out.println(arr[1]);//lisiSystem.out.println(arr[2]);//打印出來的是默認初始化值null

數組默認初始化值的規律
整數類型：默認初始化值0
小數類型：默認初始化值0.0
字符類型：默認初始化值'\u0000' 空格
布爾類型：默認初始化值 false
引用數據類型：默認初始化值 null

int[] arr2 = new int[3];
System.out.println(arr2[0]);//0
System.out.println(arr2[1]);//0
System.out.println(arr2[2]);//0

數組動態初始化和靜態初始化的區別
動態初始化：手動指定數組長度，由系統給出默認初始化值。
只明確元素個數，不明確具體數值，推薦使用動態初始化
靜態初始化：手動指定數組元素，系統會根據元素個數，計算出數組的長度。
需求中已經明確了要操作的具體數據，直接靜態初始化即可。

數組常見問題當訪問了數組中不存在的索引，就會引發索引越界異常。

5.數組的內存圈

Java 內存分配
棧：方法運行時使用的內存，比如 main 方法運行，進入方法棧中執行
堆：存儲對象或者數組，new 來創建的，都存儲在堆內存
方法區：存儲可以運行的 class 文件
本地方法棧：JVM 在使用操作系統功能的時候使用，和我們開發無關
寄存器：給 CPU 使用，和我們開發無關

方法

1.什么是方法

        什么是方法？方法是程序中最小的執行單元實際開發中，什么時候用到方法？重復的代碼、具有獨立功能的代碼可以抽取到方法中實際開發中，方法有什么好處？可以提高代碼的復用性可以提高代碼的可維護性

2.最簡單的方法定義和調用

        方法定義格式public static void 方法名 (){方法體（就是打包起來的代碼）;}范例public static void playGame (){七個打印語句;}方法調用格式方法名();范例playGame();注意：方法必須先定義后調用，否則程序將報錯

//定義一個方法
public static void playGame(){System.out.println("選人物");System.out.println("準備開局");System.out.println("對線");System.out.println("崩盤");System.out.println("罵隊友");System.out.println("送人頭");System.out.println("GG");
}

//調用方法
playGame();

3.帶參數的方法定義和調用

        帶參數的方法定義單個參數格式：public static void 方法名(參數){......}范例：public static void method(int number){......}多個參數格式：public static void 方法名(參數1, 參數2, ......){......}范例：public static void getSum(int number1, int number2){......}帶參數的方法調用單個參數單個參數：方法名(參數);范例 1：method(10);范例 2：method(變量);多個參數多個參數：方法名(參數1, 參數2, ……);范例 1：getSum(10,20);范例 2：getSum(變量1, 變量2);

    public static void main(String[] args) {getSum(10,20);}public static void getSum(int num1, int num2){int result = num1 + num2;System.out.println(result);}

    形參和實參形參：全稱形式參數，是指方法定義中的參數實參：全稱實際參數，方法調用中的參數注意：方法調用時，形參和實參必須一一對應，否則程序將報錯。

4.帶返回值方法的定義和調用

        方法的返回值其實就是方法運行的最終結果如果在調用處要根據方法的結果，去編寫另外一段代碼邏輯為了在調用處拿到方法產生的結果，就需要定義帶有返回值的方法帶返回值方法定義格式public static 返回值類型 方法名(參數) {方法體;return 返回值;}范例public static int getSum(int a, int b) {int c = a + b;return c;}帶返回值方法的調用直接調用：方法名 (實參);賦值調用：整數類型 變量名 = 方法名 (實參);輸出調用：System.out.println (方法名 (實參));

????????return 關鍵字方法沒有返回值：可以省略不寫。如果書寫，表示結束方法方法有返回值：必須要寫。表示結束方法和返回結果

5.方法的重載

        方法的重載在同一個類中，定義了多個同名的方法，這些同名的方法具有同種的功能。每個方法具有不同的參數類型或參數個數，這些同名的方法，就構成了重載關系簡單記：同一個類中，方法名相同，參數不同的方法。與返回值無關。參數不同：個數不同、類型不同、順序不同