Java入门学习笔记[狂神说Java]
寫在前面：
本文根據(jù)B站狂神說Java 與菜鳥教程 整理而來，僅供個人學習使用，如有侵權(quán)，請聯(lián)系刪除。
文章目錄
- IDEA使用
- Java基礎(chǔ)01：注釋
- Java基礎(chǔ)02：數(shù)據(jù)類型
- Java基礎(chǔ)03：類型轉(zhuǎn)換
- Java基礎(chǔ)04：變量
- Java基礎(chǔ)05：運算符
- Java基礎(chǔ)06：包機制
- Java流程控制01：用戶交互Scanner
- Java流程控制02：Switch case語句
- Java流程控制03：循環(huán)語句
- Java方法01：方法的基本概念
- Java數(shù)組01：數(shù)組基礎(chǔ)
- Java數(shù)組02：Arrays類
- Java數(shù)組02：手撕冒泡排序
- Java面向?qū)ο?1：OOP簡介
- Java面向?qū)ο?2：創(chuàng)建對象
- Java面向?qū)ο?3：封裝、繼承、多態(tài)?
- Java面向?qū)ο?4：抽象類
- Java 面向?qū)ο?5：接口interface?
- Java 面向?qū)ο?6：內(nèi)部類
- Java 面向?qū)ο?7：異常exception
- 參考資料
IDEA使用
新建一個空項目（這里沒有選擇新建Java項目），目的是把本節(jié)所有的語法內(nèi)容放在該項目下，免得建太多項目。
此時會出現(xiàn)Project Structure提示，這里先關(guān)掉，后面再設(shè)置。
關(guān)掉之后，真的是空項目，空空如也。
新建module
module（模塊）里面再選擇Java,選擇JDK后下一步。
這里命名為基礎(chǔ)語法
創(chuàng)建完成后，需要在src文件夾下面進行java代碼的開發(fā)。在此之前，先找到項目結(jié)構(gòu)，進行JDK的配置。
配置完成后，先點擊apply，再點ok。
右擊src文件，選擇新建，新建java class，然后隨便命名即可，這里命名為HelloWorld。這里面寫Java代碼。
下面是一個測試，輸入psvm會顯示 public static void main這一行；輸入sout會顯示System.out.println這一行。這樣就是一個main函數(shù)，可以直接運行。
public class Hello {public static void main(String[] args) {System.out.println("Hello,World");} }運行的話，點擊第二行（是main函數(shù)所在的行）前面的綠色箭頭，這是執(zhí)行按鈕。選擇Run。然后開始運行程序。
下面就是運行結(jié)果：輸出程序員最熟悉的Hello，World。
Java基礎(chǔ)01：注釋
Java中的注釋有3種：單行注釋//，多行注釋/**/，文檔注釋/** */。
文檔注釋使用方法：
JavaDoc是用來生成自己API文檔的。
參數(shù)信息：
舉例如下：加在類上的是類的注釋，加在方法上的是方法的注釋。
package com.baidu;/*** @author Lishizheng* @version 1.0* @since 1.8*/public class Doc {String name;/*** * @param name* @return* @throws Exception*/public String test(String name) throws Exception{return name;} }Java基礎(chǔ)02：數(shù)據(jù)類型
Java是強類型語言：要求變量的使用要嚴格符合規(guī)定，所有變量都是先聲明后使用。
Java數(shù)據(jù)分為兩種類型：基本類型和引用類型。
float類型：定義的數(shù)據(jù)后面一般需要加F來表示float類型，不加的話默認為double類型。
字符：char 只能用單引號，不能用雙引號。char可以存儲1個英文字符，也可以存儲一個漢字。
boolean類型 只能賦值true和false，不能賦值0和1.
進制表示
二進制0b開頭，八進制0開頭，十六進制0x開頭。
浮點數(shù)補充:最好避免使用float進行比較。
Java基礎(chǔ)03：類型轉(zhuǎn)換
運算中，不同類型的數(shù)據(jù)先轉(zhuǎn)化為同一類型，然后進行運算。
從低到高 byte，short，char ->int -> long -> float -> double自動類型轉(zhuǎn)換
強制類型轉(zhuǎn)換
注意點：
浮點數(shù)轉(zhuǎn)int
System.out.println((int)2.31); //輸出2System.out.println((int) -45.14444); //輸出-45char轉(zhuǎn)int，是低轉(zhuǎn)高，不是強制轉(zhuǎn)換，而是自動轉(zhuǎn)換，所以不需要顯式表示出來。 字符’a’ +1 就是自動轉(zhuǎn)換為轉(zhuǎn)化為int型進行計算。
//char 轉(zhuǎn) int char a='a';System.out.println(a);int num = a + 1; // a的ASCII碼值是97 ，這里num是98System.out.println( num); //輸出98System.out.println((char)num); //輸出b操作大數(shù)的時候注意溢出問題，同時JDK7的新特性，數(shù)字內(nèi)部可以使用下劃線分割，編譯器不輸出下劃線。
int money = 10_0000_0000; //輸出1000000000System.out.println(money);Java基礎(chǔ)04：變量
變量包括三要素：變量名，變量類型和作用域。
變量作用域：
需要關(guān)鍵字static，之后該類內(nèi)的方法都可以使用該變量。
從屬于對象；如果未初始化，編譯器會將其初始化為其類型的默認值。數(shù)值變量一般默認初始化為0或0.0，boolean變量默認初始化為false；除了基本類型，其余變量(比如string類型的變量) 默認初始化為null。
作用域限于方法內(nèi)
常量
使用關(guān)鍵字final 作為修飾符。
格式為
final 數(shù)據(jù)類型 常量名 = 值常量名一般用大寫字符。
final double PI = 3.14;變量的命名規(guī)范
- 所有變量、方法、類名：見名知意
- 類成員變量、局部變量：首字母小寫和駝峰命名法：monthSalary
- 常量：大寫字符和下劃線 ：MAX_VALUE
- 類名： 首字母大寫和駝峰命名法：Man，GoodMan
- 方法名：首字母小寫和駝峰命名法：getNumber()
Java基礎(chǔ)05：運算符
自增自減運算符：
a ++ :先賦值，后運算
++ a：先運算，后賦值
位運算符：
與：A&B ,
或：A | B,
取反： ~B,
異或（相同為0，不同為1）：A^B，其實異或是二進制中不進位加法
左移：<<(左移還是右移看箭頭指向,指向左是左移，指向右是右移)
右移:>>
面試題：請用最高效的寫法求2的三次方的值。
答：需要用位運算，答案是2 << 3 :表示2的二進制左移三位
字符串連接符 ： +
如果 在 + 號兩側(cè)其中一側(cè)出現(xiàn)string類型，結(jié)果就是string。
面試題：請問下面代碼輸出結(jié)果分別是什么？
答：1020 ；30
條件運算符（三元運算符）：
x ? y : z表示如果x為真，則結(jié)果為y，否則結(jié)果為z
舉例如下：
成績 < 60 ? 沒飯吃：高薪工作
解釋為，如果成績小于60，則沒飯吃，否則高薪工作。
學會了？出去玩 ： 繼續(xù)學。
public class HelloWorld {public static void main(String[] args) {int score = 60;String res = score < 60 ? " 沒飯吃" : "高薪工作";System.out.println(res);} }Java基礎(chǔ)06：包機制
為了更好地組織類，Java提供了包機制，用于區(qū)別類名的命名空間。
一般利用 公司域名倒置 作為包名。
比如 百度的域名是 www.baidu.com，如果作為包的話是這樣的：com.baidu.www
為了能夠使用某一個包的成員、方法，需要在java程序中明確導(dǎo)入該包，使用“import”語句完成 此功能。
Java流程控制01：用戶交互Scanner
java.util.Scanner是Java5的新特性，我們可以通過Scanner類來獲取用戶的輸入。
基本語法
通過Scanner類的next()和nextLine()方法獲取輸入的字符串，在讀取前我們一般使用hasNext()與hasNextLine()判斷是否還有輸入的數(shù)據(jù)。
import java.util.Scanner;public class Demo01 {public static void main(String[] args) {//創(chuàng)建一個掃描器對象，用于接收鍵盤數(shù)據(jù)Scanner scanner = new Scanner(System.in);System.out.println("使用next方法接收： ");if( scanner.hasNext()){//接收用戶輸入String str = scanner.next();System.out.println("輸出的內(nèi)容為： "+ str);}scanner.close();} }next不能得到帶有空格的字符串；
nextLine以回車為結(jié)束符，即輸入一行。
例題：從控制臺輸入數(shù)據(jù)，并求和和計算平均值
package com.baidu;import java.util.Scanner;public class Demo01 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("請輸入數(shù)字，以非數(shù)字結(jié)束");int cnt = 0;double sum = 0;while(scanner.hasNextDouble()){double x = scanner.nextDouble();cnt ++;sum += x;}System.out.println(cnt+"個數(shù)的和為:" + sum);System.out.println(cnt + "個數(shù)的平均數(shù)是： " + sum/cnt);scanner.close();} }Java流程控制02：Switch case語句
switch case 語句判斷一個變量與一系列值中某個值是否相等，每個值稱為一個分支。
switch case 語句有如下規(guī)則：
- switch 語句中的變量類型可以是： byte、short、int 或者 char。從 Java SE 7 開始，switch 支持字符串 String 類型了，同時 case 標簽必須為字符串常量或字面量。
- switch 語句可以擁有多個 case 語句。每個 case 后面跟一個要比較的值和冒號。
- case 語句中的值的數(shù)據(jù)類型必須與變量的數(shù)據(jù)類型相同，而且只能是常量或者字面常量。
- 當變量的值與 case 語句的值相等時，那么 case 語句之后的語句開始執(zhí)行，直到 break 語句出現(xiàn)才會跳出 switch 語句。
- 當遇到 break 語句時，switch 語句終止。程序跳轉(zhuǎn)到 switch 語句后面的語句執(zhí)行。case 語句不必須要包含 break 語句。如果沒有 break 語句出現(xiàn)，程序會繼續(xù)執(zhí)行下一條 case 語句，直到出現(xiàn) break 語句。
- switch 語句可以包含一個 default 分支，該分支一般是 switch 語句的最后一個分支（可以在任何位置，但建議在最后一個）。default 在沒有 case 語句的值和變量值相等的時候執(zhí)行。default 分支不需要 break 語句。
- switch case 執(zhí)行時，一定會先進行匹配，匹配成功返回當前 case 的值，再根據(jù)是否有 break，判斷是否繼續(xù)輸出，或是跳出判斷。
Java流程控制03：循環(huán)語句
while循環(huán)
對于 while 語句而言，如果不滿足條件，則不能進入循環(huán)。但有時候我們需要即使不滿足條件，也至少執(zhí)行一次。
do…while 循環(huán)和 while 循環(huán)相似，不同的是，do…while 循環(huán)至少會執(zhí)行一次。
package com.baidu;public class Demo01 {public static void main(String[] args) {//while 循環(huán)int a = 0;while( a < 0){System.out.println(a);a++;}System.out.println("=============");// do - while循環(huán)a = 0;do{System.out.println(a);a++;} while (a<0);} }/*輸出： ============= 0 */for循環(huán)
for循環(huán)次數(shù)在執(zhí)行前已經(jīng)確定。
for死循環(huán)的寫法
練習題：求0~1000中5的倍數(shù)，輸出要求每行三個。
package com.baidu;public class Demo01 {public static void main(String[] args) {int cnt = 0;for (int i = 0; i < 1000; i++) {if( i % 5 == 0){if(cnt!=0 && cnt % 3 == 0) System.out.println();System.out.print(i+" ");cnt++;}}} }練習題：使用for循環(huán)輸出99乘法表
package com.baidu;public class Demo01 {public static void main(String[] args) {for (int i = 1; i <= 9; i++) {for (int j = 1; j <= i; j++) {System.out.print(j + "*" + i + "=" + i*j + " ");}System.out.println();}} }/*1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 Process finished with exit code 0*/增強 for循環(huán)
Java5 引入了一種主要用于數(shù)組的增強型 for 循環(huán)。
語法格式
for(聲明語句 : 表達式) {//代碼句子 }示例如下：輸出數(shù)組num中的元素。
package com.baidu;public class Demo01 {public static void main(String[] args) {int num[] = {10 ,20 ,30 ,40 ,50};for(int x : num) System.out.println(x);} }BREAK關(guān)鍵字和CONTINUE關(guān)鍵字
break
- break 主要用在循環(huán)語句或者 switch 語句中，用來跳出整個語句塊。
- break 跳出最里層的循環(huán)，并且繼續(xù)執(zhí)行該循環(huán)下面的語句。
continue
- continue 適用于任何循環(huán)控制結(jié)構(gòu)中。作用是讓程序立刻跳轉(zhuǎn)到下一次循環(huán)的迭代。
- 在 for 循環(huán)中，continue 語句使程序立即跳轉(zhuǎn)到更新語句。
- 在 while 或者 do…while 循環(huán)中，程序立即跳轉(zhuǎn)到布爾表達式的判斷語句。
練習題：打印三角形
package com.baidu;public class Demo01 {public static void main(String[] args) {for (int i = 1; i <= 5; i++) {//打印左邊空格for (int j = 5; j >=i; j--) {System.out.print(" ");}//打印左邊三角形for (int j = 1; j <= i; j++) {System.out.print("*");}//打印右邊三角形for (int j = 1; j < i; j++) {System.out.print("*");}System.out.println();}} } /**************************Process finished with exit code 0*/Java方法01：方法的基本概念
參考：https://www.runoob.com/java/java-methods.html
什么是方法？
Java方法是語句的集合，它們在一起執(zhí)行一個功能。
- 方法是解決一類問題的步驟的有序組合
- 方法包含于類或?qū)ο笾?/li>
- 方法在程序中被創(chuàng)建，在其他地方被引用
方法的命名規(guī)則是怎樣的呢？
方法詳解
方法一般定義如下格式
比如 兩個數(shù)的加法可以寫成一個方法：
public static int add(int a , int b){return a + b;}
圖片來源：菜鳥教程
方法調(diào)用
當程序調(diào)用一個方法時，程序的控制權(quán)交給了被調(diào)用的方法。當被調(diào)用方法的返回語句執(zhí)行或者到達方法體閉括號時候交還控制權(quán)給程序。
面試題：Java是值傳遞還是引用傳遞？ 值傳遞。
方法重載
重載：一個類的兩個方法擁有相同的名字，但是有不同的參數(shù)列表。
重載的方法必須擁有不同的參數(shù)列表。不能僅僅依據(jù)修飾符或者返回類型的不同來重載方法。
// 參數(shù)為intpublic static int add(int a , int b){return a + b;}//參數(shù)為 double public static double add(double a, double b){return a +b;}//參數(shù)個數(shù)不同public static int add(int a, int b,int c){return a + b + c;}命令行傳參
D:\user\文檔\IDEA\Java入門學習\基礎(chǔ)語法\src> java com.baidu.Demo01 this is lishizheng args[0]: this args[1]: is args[2]: lishizheng可變參數(shù)
JDK 1.5 開始，Java支持傳遞同類型的可變參數(shù)給一個方法。
方法的可變參數(shù)的聲明如下所示：
typeName... parameterName在方法聲明中，在指定參數(shù)類型后加一個省略號(…) 。
一個方法中只能指定一個可變參數(shù)，它必須是方法的最后一個參數(shù)。任何普通的參數(shù)必須在它之前聲明。
package com.baidu;public class Demo01 {public static void main(String[] args) {Demo01 demo01 = new Demo01();demo01.test(1,2);demo01.test(1,1,2,2);}// i是可變參數(shù)，參數(shù)個數(shù)不確定，但必須是同類型public void test(int a, int ... i){System.out.println(i[0]);} }下面是使用可變參數(shù)來求最大值:傳入的參數(shù)個數(shù)是未知的。
package com.baidu;public class Demo01 {public static void main(String[] args) {Demo01 demo01 = new Demo01();demo01.printMax(1,2,3,4,5);}// 輸出參數(shù)中的最大值public void printMax (int ... num){if(num.length == 0){System.out.println("沒有傳遞參數(shù)");return ;}int res = num[0];for(int i:num){if(i > res) res = i;}System.out.println("最大值是：" + res);} }Java數(shù)組01：數(shù)組基礎(chǔ)
Java 語言中提供的數(shù)組是用來存儲固定大小的同類型元素。
數(shù)組聲明與創(chuàng)建
首先必須聲明數(shù)組變量，才能在程序中使用數(shù)組。下面是聲明數(shù)組變量的語法：
dataType[] arrayRefVar; // 首選的方法或dataType arrayRefVar[]; // 效果相同，但不是首選方法注意: 建議使用 dataType[] arrayRefVar 的聲明風格聲明數(shù)組變量。 dataType arrayRefVar[] 風格是來自 C/C++ 語言 ，在Java中采用是為了讓 C/C++ 程序員能夠快速理解java語言。
ava語言使用new操作符來創(chuàng)建數(shù)組，語法如下：
arrayRefVar = new dataType[arraySize];上面的語法語句做了兩件事：
- 使用 dataType[arraySize] 創(chuàng)建了一個數(shù)組。
- 把新創(chuàng)建的數(shù)組的引用賦值給變量 arrayRefVar。
舉例:
//先聲明，后創(chuàng)建的方式 int[] nums; nums = new int[10];數(shù)組變量的聲明，和創(chuàng)建數(shù)組可以用一條語句完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];另外，你還可以使用如下的方式創(chuàng)建數(shù)組。
dataType[] arrayRefVar = {value0, value1, ..., valuek};數(shù)組的元素是通過索引訪問的。數(shù)組索引從 0 開始，所以索引值從 0 到 arrayRefVar.length-1。
舉例
int[] nums = new int[10]; //聲明并創(chuàng)建 double[] d = new double[10]; float[] f= new float[10]; String [] s = new String[10];數(shù)組是引用類型，它的元素相當于類的實例變量，因此數(shù)組一經(jīng)分配空間，其中每個元素也被按照實例變量同樣的方式被隱式初始化。
數(shù)組的4個基本特點:
Java中對象是在堆中的，因此數(shù)組無論保存原始類型還是其他對象類型，數(shù)組對象本身是在堆中的。
數(shù)組的遍歷
package com.baidu;public class ArrayDemo02 {public static void main(String[] args) {int[] a = {1,2,3,4};//for循環(huán)for(int i = 0; i< a.length ; i++)System.out.println(a[i]);// for -each循環(huán)for (int i : a) {System.out.println(i);}// 數(shù)組作為參數(shù)printArray(a);}//打印數(shù)組public static void printArray(int[] array){for (int i : array) {System.out.print(i +" ");}} }數(shù)組的使用：反轉(zhuǎn)數(shù)組
package com.baidu;public class ArrayDemo02 {public static void main(String[] args) {int[] a = {1,2,3,4};// 數(shù)組作為參數(shù)printArray(a);int[] res = reverse(a);for (int i : res) {System.out.print(i + " ");}}//打印數(shù)組public static void printArray(int[] array){for (int i : array) {System.out.print(i +" ");}System.out.println();}// 翻轉(zhuǎn)數(shù)組public static int[] reverse(int[] array){int[] result = new int[array.length];for(int i = 0, j = result.length -1; i< array.length && j >= 0;i++,j--){result[j] = array[i];}return result;}} /* 1 2 3 4 4 3 2 1 Process finished with exit code 0*/多維數(shù)組
多維數(shù)組可以看成是數(shù)組的數(shù)組，比如二維數(shù)組就是一個特殊的一維數(shù)組，其每一個元素都是一個一維數(shù)組，例如：
double[][] d = new double[2][3];多維數(shù)組的動態(tài)初始化（以二維數(shù)組為例）
二維數(shù)組
package com.baidu;public class ArrayDemo03 {public static void main(String[] args) {int[][] num = {{1,2},{1,3},{2,3}};for(int i = 0; i<num.length; i++){for(int j = 0; j< num[i].length;j++)System.out.print(num[i][j] +" ");System.out.println();}} }Java數(shù)組02：Arrays類
java.util.Arrays 類能方便地操作數(shù)組。
Arrays類中的方法都是static修飾的靜態(tài)方法，在使用的時候可以直接使用類名進行調(diào)用，而不用使用對象來調(diào)用（注意，是不用，不是不可以）。
具有以下典型功能：
- 給數(shù)組賦值：通過 fill 方法。
- 對數(shù)組排序：通過 sort 方法,按升序。
- 比較數(shù)組：通過 equals 方法比較數(shù)組中元素值是否相等。
- 查找數(shù)組元素：通過 binarySearch 方法能對排序好的數(shù)組進行二分查找法操作。
舉例：
package com.baidu;import java.util.Arrays;public class ArrayDemo04 {public static void main(String[] args) {int[] a= {1,2,55,32, 6, 4,3};//調(diào)用 toString():數(shù)組轉(zhuǎn)換為字符串類型的數(shù)組System.out.println(Arrays.toString(a));//調(diào)用sort 進行排序Arrays.sort(a);System.out.println(Arrays.toString(a));//填充Arrays.fill(a,0);System.out.println(Arrays.toString(a));} } /* [1, 2, 55, 32, 6, 4, 3] [1, 2, 3, 4, 6, 32, 55] [0, 0, 0, 0, 0, 0, 0]Process finished with exit code 0 */舉例另一個方法：比如toString()方法，以字符串的形式輸出整個數(shù)組.
package com.baidu;import java.util.Arrays;public class ArrayDemo04 {public static void main(String[] args) {int[] a= {1,2,55,32, 6, 4,3};System.out.println(Arrays.toString(a));} }/* [1, 2, 55, 32, 6, 4, 3]Process finished with exit code 0 */toString()方法源碼如下：
查看源碼方法：鼠標放到toString上，按住ctrl加點擊即可進入。
/*** @param a the array whose string representation to return* 要返回其字符串表示形式的數(shù)組* @return a string representation of <tt>a</tt>* @since 1.5*/public static String toString(int[] a) {if (a == null)return "null";int iMax = a.length - 1;if (iMax == -1)return "[]";StringBuilder b = new StringBuilder();b.append('[');for (int i = 0; ; i++) {b.append(a[i]);if (i == iMax)return b.append(']').toString();b.append(", ");}}Java數(shù)組02：手撕冒泡排序
冒泡排序
1.從頭到尾依次比較數(shù)組中相鄰的元素
2.每輪把最大的數(shù)放到最后
Java面向?qū)ο?1：OOP簡介
- 面向過程：
步驟清晰簡單，第一步做什么，第二步做什么
適合處理簡單的問題 - 面向?qū)ο?
物以類聚，用的是分類的思想。面對復(fù)雜問題，首先思考問題會分為哪些類，然后對這些類進行單獨思考，最后，才對某個類下的細節(jié)進行面向過程的思考。
面向?qū)ο筮m合處理復(fù)雜的問題，適合處理需要多人協(xié)作的問題。
簡單理解面向?qū)ο蠛兔嫦蜻^程的區(qū)別：對于描述比較復(fù)雜的事物，為了從宏觀上把握、從整體上合理分析，我們需要使用面向?qū)ο蟮乃悸穪矸治稣麄€系統(tǒng)；具體到微觀操作，需要面向過程的思路去處理。
什么是面向?qū)ο缶幊?#xff1f;
面向?qū)ο缶幊?#xff08;Object-Oriented Programming,OOP）的本質(zhì)是：以類的方式組織代碼，以對象的形式封裝數(shù)據(jù)。
抽象是核心，抽象能力也是程序員必備的能力。
OOP的三大特性
- 封裝
- 繼承
- 多態(tài)
下面穿插著講解靜態(tài)方法和非靜態(tài)方法的區(qū)別，以及值傳遞和引用傳遞的區(qū)別，方便對后面面向?qū)ο蟮睦斫狻?/p>
回顧方法的調(diào)用
- 靜態(tài)方法：有修飾符static，調(diào)用通過類名+方法名
- 非靜態(tài)方法：沒有static，調(diào)用通過實例化一個類（創(chuàng)建對象），然后可調(diào)用方法。
下面是非靜態(tài)方法的調(diào)用舉例：
//非靜態(tài)方法
//實例化這個類 new
//對象類型 對象名稱 = 對象值
同一個類中，兩個方法a() 和b() 都不是static，則可以相互調(diào)用
package com.oop.demo01;public class Demo02 {public static void main(String[] args) {// a方法可調(diào)用 b方法public void a(){b();}public void b(){} }同一個類中，如果方法a() 被static修飾，而方法b()沒有被static修飾，則a()無法調(diào)用b()。原因是含有static 的方法是和類一起加載的，此時不含static的方法b()還沒有加載，方法b()是在類實例化之后加載，所以不能調(diào)用，否則會報錯。
package com.oop.demo01;public class Demo02 {public static void main(String[] args) {// a方法不可調(diào)用 b方法//和類一起加載public static void a(){b();}//實例化后才會加載//所以 a方法加載完之后，發(fā)現(xiàn)b方法還不存在，自然出錯。public void b(){} }報錯如下：
簡言之：靜態(tài)方法只能調(diào)用靜態(tài)方法，非靜態(tài)方法可以調(diào)用靜態(tài)方法。
值傳遞和引用傳遞
Java是值傳遞，舉例如下：
package com.oop.demo01;//值傳遞 public class Demo04 {public static void main(String[] args) {int a = 1;System.out.println(a); //輸出1change(a); //值傳遞，結(jié)果未改變System.out.println(a); // 輸出1，Java值傳遞}public static void change(int a){a = 10;} }引用傳遞：對象
package com.oop.demo01;//引用傳遞：對象 public class Demo05 {public static void main(String[] args) {Person person = new Person();System.out.println(person.name); // nullchange(person); //引用傳遞，結(jié)果改變System.out.println(person.name); // azheng}//引用傳遞傳遞的是對象的地址public static void change(Person person){person.name = "azheng";} } //定義了一個Person類，有一個屬性：name class Person{String name; //默認值為null }總結(jié)：
- 值傳遞：實參和形參在內(nèi)存中指向的是不同的兩個地址；
- 引用傳遞：實參和形參在內(nèi)存中指向的是同一個地址。
Java面向?qū)ο?2：創(chuàng)建對象
類與對象的關(guān)系
- 類是一種抽象的數(shù)據(jù)類型，它是對某一類事物整體描述、定義，但是它不能代表某一具體事物。
動物，植物，手機，電腦……
Person類，Pet類，Car類等 - 對象是抽象概念的具體實例
創(chuàng)建對象
對象是根據(jù)類創(chuàng)建的。在Java中，使用關(guān)鍵字 new 來創(chuàng)建一個新的對象。創(chuàng)建對象需要以下三步：
Student類：
package com.oop.demo01;//學生類 public class Student {//屬性String name;int age;//方法public void study(){System.out.println(this.name + "在學習 ");} }進行測試
package com.oop.demo01;public class Application {public static void main(String[] args) {//類 實例化//類實例化的結(jié)果會返回一個自己的對象//student對象就是一個Student類的具體實例Student tom = new Student();Student alice = new Student();System.out.println("默認初始化：");System.out.println("name：" +tom.name);System.out.println( "age:" + tom.age);System.out.println("調(diào)用成員修改屬性：");tom.name = "tom";tom.age = 3;System.out.println("name: " +tom.name);System.out.println( "age: " + tom.age);} } /* 默認初始化： name：null age:0 調(diào)用成員修改屬性： name: tom age: 3Process finished with exit code 0 */構(gòu)造函數(shù)
使用new關(guān)鍵字創(chuàng)建對象的時候，除了分配內(nèi)存空間外，還會給創(chuàng)建好的對象進行默認初始化，以及對類中構(gòu)造器的調(diào)用
類中的構(gòu)造器也稱為構(gòu)造方法，是在創(chuàng)建時對象時必須要調(diào)用的。一個類可以有多個構(gòu)造器。
構(gòu)造器有以下兩個特點：
作用：
new本質(zhì)上是調(diào)用構(gòu)造器，初始化對象
IDEA中快捷鍵alt + insert快速生成構(gòu)造器
Java面向?qū)ο?3：封裝、繼承、多態(tài)?
程序設(shè)計追求“高內(nèi)聚，低耦合”
高內(nèi)聚：類的內(nèi)部數(shù)據(jù)操作由自己完成；
低耦合：僅暴露少量的方法給外部使用。
封裝
在面向?qū)ο蟪淌皆O(shè)計方法中，封裝（Encapsulation）是指一種將抽象性函式接口的實現(xiàn)細節(jié)部分包裝、隱藏起來的方法。
封裝可以被認為是一個保護屏障，防止該類的代碼和數(shù)據(jù)被外部類定義的代碼隨機訪問。
要訪問該類的代碼和數(shù)據(jù)，必須通過嚴格的接口控制。
封裝最主要的功能在于我們能修改自己的實現(xiàn)代碼，而不用修改那些調(diào)用我們代碼的程序片段。
適當?shù)姆庋b可以讓程式碼更容易理解與維護，也加強了程式碼的安全性。
封裝的優(yōu)點
良好的封裝能夠減少耦合。
類內(nèi)部的結(jié)構(gòu)可以自由修改。
可以對成員變量進行更精確的控制。
隱藏信息，實現(xiàn)細節(jié)。
實現(xiàn)Java封裝的步驟
1） 修改屬性的可見性來限制對屬性的訪問（一般限制為private）
2）對每個值屬性提供對外的公共方法訪問，也就是創(chuàng)建一對賦取值方法（get和set），用于對私有屬性的訪問。
例如：
package com.oop.demo02;public class Student {//屬性私有private String name;private int id;private char sex;//提供一些可以操縱這些屬性的方法//提供一些public的get、set方法//get 獲取數(shù)據(jù)public String getName(){return this.name;}// set 設(shè)置數(shù)據(jù)public void setName(String name){this.name = name;}//alt + insert自動生成get和set方法public int getId() {return id;}public void setId(int id) {this.id = id;}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;} }繼承
繼承就是子類繼承父類的特征和行為，使得子類對象（實例）具有父類的實例域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。
繼承是類與類之間的關(guān)系。除此之外，類和類之間的關(guān)系還有依賴、組合、聚合等。
在 Java 中通過 extends 關(guān)鍵字可以申明一個類是從另外一個類繼承而來的，一般形式如下：
class 父類 { }class 子類 extends 父類 { }為什么繼承？
子類繼承父類之后，就具有父類當中的屬性和方法，子類就不會存在重復(fù)的代碼，維護性也提高，代碼也更加簡潔，提高代碼的復(fù)用性（復(fù)用性主要是可以多次使用，不用再多次寫同樣的代碼）。
繼承類型
需要注意的是 Java 不支持多繼承，但支持多重繼承。
來源：菜鳥教程
繼承的特性：
繼承關(guān)鍵字
繼承可以使用 extends 和 implements 這兩個關(guān)鍵字來實現(xiàn)繼承，而且所有的類都是繼承于java.lang.Object，當一個類沒有繼承的兩個關(guān)鍵字，則默認繼承object（這個類在java.lang包中，所以不需要 import）祖先類。
【1】extends關(guān)鍵字
在 Java 中，類的繼承是單一繼承，也就是說，一個子類只能擁有一個父類，所以 extends 只能繼承一個類。
知識點：
super 與 this 關(guān)鍵字
super關(guān)鍵字：我們可以通過super關(guān)鍵字來實現(xiàn)對父類成員的訪問，用來引用當前對象的父類。
this關(guān)鍵字：指向自己的引用。
package com.oop.demo03;//Java中所有的類，都默認直接或間接繼承自O(shè)bject類 public class Person {protected String name = "lishizheng";public void print(){System.out.println("printPerson");}}//派生類，子類 public class Student extends Person{//Ctrl + H 可查看繼承樹，繼承關(guān)系private String name = "stu";public void print(){System.out.println("printStudent");}public void test1(){print(); //調(diào)用當前類方法this.print(); //調(diào)用當前類方法super.print(); //調(diào)用父類方法}public void test(String name){System.out.println(name);//System.out.println(this.name); //調(diào)用當前類屬性System.out.println(super.name); //調(diào)用父類屬性} }//測試類 public class Application {public static void main(String[] args) {Student student = new Student();student.test("who");student.test1();}}構(gòu)造器
子類是不繼承父類的構(gòu)造器（構(gòu)造方法或者構(gòu)造函數(shù)）的，它只是調(diào)用（隱式或顯式）。如果父類的構(gòu)造器帶有參數(shù)，則必須在子類的構(gòu)造器中顯式地通過 super關(guān)鍵字調(diào)用父類的構(gòu)造器并配以適當?shù)膮?shù)列表。
如果父類構(gòu)造器沒有參數(shù)，則在子類的構(gòu)造器中不需要使用 super 關(guān)鍵字調(diào)用父類構(gòu)造器，系統(tǒng)會自動調(diào)用父類的無參構(gòu)造器
super注意點
【2】implements關(guān)鍵字
使用 implements 關(guān)鍵字可以變相的使java具有多繼承的特性，使用范圍為類繼承接口的情況，可以同時繼承多個接口（接口跟接口之間采用逗號分隔）。
重寫
重寫（Override）是子類對父類的允許訪問的方法的實現(xiàn)過程進行重新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！
重寫的好處在于子類可以根據(jù)需要，定義特定于自己的行為。 也就是說子類能夠根據(jù)需要實現(xiàn)父類的方法。
重寫方法不能拋出新的檢查異?；蛘弑缺恢貙懛椒ㄉ昝鞲訉挿旱漠惓?。例如： 父類的一個方法申明了一個檢查異常 IOException，但是在重寫這個方法的時候不能拋出 Exception 異常，因為 Exception 是 IOException 的父類，只能拋出 IOException 的子類異常。
在面向?qū)ο笤瓌t里，重寫意味著可以重寫任何現(xiàn)有方法。
舉例：B是父類，A是子類，A中重寫了父類B的方法test().
package com.oop.demo04;//父類 //重寫都是方法的重寫，和屬性無關(guān) public class B {public void test(){System.out.println("B.test()");} } //子類 public class A extends B{//方法重寫@Overridepublic void test() {System.out.println("A.test()");} }//測試類 public class Application {public static void main(String[] args) {//靜態(tài)方法的調(diào)用只和左邊定義的數(shù)據(jù)類型有關(guān)//因為靜態(tài)方法是類的方法//調(diào)用A類的方法testA a = new A();a.test();//非靜態(tài)方法可以重寫！！！//非靜態(tài)方法屬于對象B b = new A(); //調(diào)用A類的方法testb.test();}} /* A.test() A.test()Process finished with exit code 0*/重寫和重載的區(qū)別：
方法的重寫(Overriding)和重載(Overloading)是java多態(tài)性的不同表現(xiàn)，重寫是父類與子類之間多態(tài)性的一種表現(xiàn)，重載可以理解成多態(tài)的具體表現(xiàn)形式。
(1)方法重載是一個類中定義了多個方法名相同,而他們的參數(shù)的數(shù)量不同或數(shù)量相同而類型和次序不同,則稱為方法的重載(Overloading)。
(2)方法重寫是在子類存在方法與父類的方法的名字相同,而且參數(shù)的個數(shù)與類型一樣,返回值也一樣的方法,就稱為重寫(Overriding)。
(3)方法重載是一個類的多態(tài)性表現(xiàn),而方法重寫是子類與父類的一種多態(tài)性表現(xiàn)。
來源：菜鳥教程
方法的重寫規(guī)則
- 參數(shù)列表與被重寫方法的參數(shù)列表必須完全相同。
- 返回類型與被重寫方法的返回類型可以不相同，但是必須是父類返回值的派生類（java5 及更早版本返回類型要一樣，java7 及更高版本可以不同）。
- 訪問權(quán)限不能比父類中被重寫的方法的訪問權(quán)限更低。例如：如果父類的一個方法被聲明為 public，那么在子類中重寫該方法就不能聲明為 protected。
- 父類的成員方法只能被它的子類重寫。
- 聲明為 final 的方法不能被重寫。
- 聲明為 static 的方法不能被重寫，但是能夠被再次聲明。
- 子類和父類在同一個包中，那么子類可以重寫父類所有方法，除了聲明為 private 和 final 的方法。
- 子類和父類不在同一個包中，那么子類只能夠重寫父類的聲明為 public 和 protected 的非 final 方法。
- 重寫的方法能夠拋出任何非強制異常，無論被重寫的方法是否拋出異常。但是，重寫的方法不能拋出新的強制性異常，或者比被重寫方法聲明的更廣泛的強制性異常，反之則可以。
- 構(gòu)造方法不能被重寫。
- 如果不能繼承一個類，則不能重寫該類的方法。
多態(tài)
多態(tài)是同一個行為具有多個不同表現(xiàn)形式或形態(tài)的能力。
多態(tài)就是同一個接口，使用不同的實例而執(zhí)行不同操作。
多態(tài)存在的三個必要條件
- 繼承
- 重寫
- 父類引用指向子類對象：Parent p = new Child();
當使用多態(tài)方式調(diào)用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去調(diào)用子類的同名方法。
多態(tài)的好處：可以使程序有良好的擴展，并可以對所有類的對象進行通用處理。
package com.oop.demo05;//父類 public class Person {public void run(){System.out.println("跑路");} }//子類 public class Student extends Person {@Overridepublic void run() {System.out.println("son");}public void eat(){System.out.println("eat");} }//測試類 public class Application {public static void main(String[] args) {//一個對象的實際類型是確定的//但是可以指向的引用類型不確定，可以是：父類的引用指向子類對象//Student能調(diào)用自己和父類的方法Student s1 = new Student();//Person 可以指向子類，但是不能調(diào)用子類獨有的方法Person s2 = new Student();//對象能執(zhí)行哪些方法， 主要看左邊的類型s2.run(); //子類重寫了父類的方法，則執(zhí)行子類的方法s1.run();s1.eat();} }加載順序：靜態(tài)代碼塊 > 匿名代碼塊>構(gòu)造函數(shù)
package com.oop.demo05;public class Person {//2{System.out.println("匿名代碼塊");}//1static {System.out.println("靜態(tài)代碼塊");}//3public Person() {System.out.println("構(gòu)造方法");}public static void main(String[] args) {Person person = new Person();} }/* 靜態(tài)代碼塊 匿名代碼塊 構(gòu)造方法Process finished with exit code 0*/Java面向?qū)ο?4：抽象類
在面向?qū)ο蟮母拍钪?#xff0c;所有的對象都是通過類來描繪的，但是反過來，并不是所有的類都是用來描繪對象的，如果一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類。
抽象類
抽象類除了不能實例化對象之外，類的其它功能依然存在，成員變量、成員方法和構(gòu)造方法的訪問方式和普通類一樣。
關(guān)于抽象類的關(guān)鍵知識點???：
抽象類不能被實例化。如果被實例化會報錯，編譯無法通過。只有抽象類的非抽象子類可以創(chuàng)建對象。
抽象類中不一定包含抽象方法，當時有抽象方法的類一定是抽象類。
抽象類中的抽象方法只是聲明，不包含方法體，即不給出方法的具體實現(xiàn)。
構(gòu)造方法，類方法（用static修飾的方法）不能聲明為抽象類。
抽象類的子類必須給出抽象類中抽象方法的具體實現(xiàn)，除非該子類也是抽象類。
抽象類：Java中使用abstract class來定義抽象類
舉例如下：
下面代碼中Action類是抽象類，其中聲明了抽象方法doSomething();A類是Action的子類，但它不是抽象列，所以要在A類中要給出Action類中抽象方法的具體實現(xiàn)。
package com.oop.demo06;//abstract 抽象類 //Java中類 extends，單繼承 //但是 接口可以多繼承public abstract class Action {//抽象方法：abstract//約束；有人幫我們實現(xiàn)//abstract ，抽象方法，只有方法名字，沒有方法的實現(xiàn)public abstract void doSomething(); }繼承自Action類的子類A：
package com.oop.demo06;//抽象類中的所有方法，繼承了它的子類，都必須實現(xiàn)父類的方法 //除非該子類也聲明為abstractpublic class A extends Action {@Overridepublic void doSomething() {} }抽象方法
如果你想設(shè)計這樣一個類，該類包含一個特別的成員方法，該方法的具體實現(xiàn)由它的子類確定，那么你可以在父類中聲明該方法為抽象方法，使用abstract關(guān)鍵字來聲明，抽象方法沒有方法體。
抽象方法舉例： public abstract void doSomething();聲明抽象方法會造成以下兩種結(jié)果：
Java 面向?qū)ο?5：接口interface?
接口（interface）在Java中是一個抽象類型，是抽象方法的集合，通常以interface來聲明。一個類通過繼承接口，來繼承接口的抽象方法。
接口并不是類，編寫接口的方式和編寫類很相似，但是兩個是完全不同的概念。
類描述對象的屬性和方法。
接口包含類要實現(xiàn)的方法。
除非實現(xiàn)接口的類是抽象類，否則該類要定義接口中的所有方法。
接口無法被實例化，但是可以被實現(xiàn)。一個實現(xiàn)接口的類，必須實現(xiàn)接口內(nèi)所描述的所有方法，否則就必須聲明為抽象類。
接口與類的相似點???：
接口與類的區(qū)別???：
接口與抽象類的區(qū)別???：
接口特性
接口中每個方法都是隱式抽象的，接口中的方法會被隱式指定為public abstract.只能是public，不能是protected等其他修飾符。
接口中可以含有變量，但是接口中的變量會被隱式地指定為public static final變量，并且只能是public，不能是protected等其他修飾符，會報錯。
接口中的方法是不能在接口中實現(xiàn)的，只能由實現(xiàn)接口的類來實現(xiàn)接口中的方法。
接口舉例：
package com.oop.demo07;//interface 關(guān)鍵字，接口都需要有實現(xiàn)類 public interface UserService {// 常量：public static finalint AGE = 99;//接口中定義的方法默認都是public abstractvoid add(String name);void delete(String name);void update(String name);void query(String name);}接口的實現(xiàn)
當類實現(xiàn)接口的時候，類要實現(xiàn)接口中所有的方法；否則，類必須聲明為抽象的類。
類使用implements關(guān)鍵字實現(xiàn)接口。在類聲明中，implements關(guān)鍵字放在class聲明后面。
實現(xiàn)一個接口的語法，可以使用這個公式：
...implements 接口名稱[, 其他接口名稱, 其他接口名稱..., ...] ...接口的實現(xiàn)舉例：
下面類UserServiceImpl實現(xiàn)了接口UserService和接口TimeService
重寫接口中聲明的方法時，需要注意以下規(guī)則：
在實現(xiàn)接口的時候，也需要注意一些規(guī)則：
Java 面向?qū)ο?6：內(nèi)部類
內(nèi)部類就是在一個類的內(nèi)部再定義類。
成員內(nèi)部類
如何調(diào)用成員內(nèi)部類的方法？
通過實例化外部類來實現(xiàn)。
使用舉例：
在外部類Outer內(nèi)部，定義一個內(nèi)部類Inner。
一個.java文件中可以有多個class類，但是只能有一個public類。
局部內(nèi)部類
在方法中定義類。
package com.oop.demo08;public class Outer {private int id = 10;public void out(){System.out.println("這是外部類的方法");}//局部內(nèi)部類：方法里面定義類public void method(){class Inner1{public void test1(){}}}}匿名內(nèi)部類
調(diào)用的時候沒有類的名字。
package com.oop.demo08;public class Test {public static void main(String[] args) {//沒有名字初始化類,不用將實例保存到變量中new Apple().eat();//匿名內(nèi)部類new UserService(){@Overridepublic void sayHello() {}};} }class Apple{public void eat(){System.out.println("吃蘋果");} }interface UserService{void sayHello(); }Java 面向?qū)ο?7：異常exception
異常是程序中的一些錯誤，但并不是所有的錯誤都是異常，并且錯誤有時候是可以避免的。
比如說，你的代碼少了一個分號，那么運行出來結(jié)果是提示是錯誤 java.lang.Error；如果你用System.out.println(11/0)，那么你是因為你用0做了除數(shù)，會拋出 java.lang.ArithmeticException 的異常。
異常通常有以下幾類：
這些異常有的是由用戶錯誤引起的，有的是程序錯誤引起的，還有一些是由物理錯誤引起的。
要理解Java異常處理是如何工作的，需要對以下概念有所理解：
最具代表的檢查性異常是用戶錯誤的引起的異常。例如要打開一個不存在的文件時，一個異常就發(fā)生了。這些異常在編譯時不能簡單地被忽略。
運行時異常是可能被程序員避免的異常。與檢查性異常相反，運行時異常可以在編譯時被忽略。
錯誤不是異常。
Exception 類的層次
在Java中，異常被當作對象來處理。Java中定義了一個基類java.lang.Throwable作為所有異常的超類。
來源：菜鳥教程
Exception 類是 Throwable 類的子類。除了Exception類外，Throwable還有一個子類Error 。
Error類用來指示運行時環(huán)境發(fā)生的錯誤。例如JVM內(nèi)存溢出。一般地，程序不會從錯誤中恢復(fù)。而且，Java程序通常不捕獲錯誤。錯誤一般發(fā)生在嚴重故障時，它們在Java程序處理的范疇之外。
Error和Exception的區(qū)別：
Error通常是災(zāi)難性的、致命性的錯誤，是程序無法控制和處理的，當出現(xiàn)這些異常時，Java虛擬機（JVM）一般會選擇終止線程。
Exception通常情況下是可以被程序處理的，并且應(yīng)該盡可能地在程序中處理這些異常。
Exception類有兩個主要的子類：IOException和RuntimeException.
在RuntimeException子類中有如下異常：
- ArrayIndexOutOfBoundsException(數(shù)組下標越界)
- ArithmeticException(算術(shù)異常)
- NullPointerException（空指針異常）
- MissingResourceException（丟失資源異常）
- ClassNotFoundException(找不到類異常)
- 等
異常方法
來源：菜鳥教程
異常處理五個關(guān)鍵字
try catch finally throw throws捕獲異常
使用try 和 catch關(guān)鍵字可以捕獲異常。try/catch 代碼塊放在異常可能發(fā)生的地方。
try/catch代碼塊中的代碼稱為保護代碼，使用 try/catch 的語法如下：
try {// 程序代碼 }catch(ExceptionName e1) {//Catch 塊 }Catch 語句包含要捕獲異常類型的聲明。當保護代碼塊中發(fā)生一個異常時，try 后面的 catch 塊就會被檢查。
如果發(fā)生的異常包含在 catch 塊中，異常會被傳遞到該 catch 塊，這和傳遞一個參數(shù)到方法是一樣。
package com.exception;public class Test {public static void main(String[] args) {int a = 1;int b = 0;try { //try監(jiān)控區(qū)域System.out.println(a/b);}//catch()：括號中是想要捕獲的異常類型catch (ArithmeticException e){//捕獲異常System.out.println("程序出現(xiàn)異常：分母不能為0");}finally {//處理善后工作System.out.println("finally");}//finally 可以不用，它的作用是關(guān)閉IO、資源等。} } /* 程序出現(xiàn)異常：分母不能為0 finallyProcess finished with exit code 0*/多重捕獲塊
一個 try 代碼塊后面跟隨多個 catch 代碼塊的情況就叫多重捕獲。
多重捕獲塊的語法如下所示：
try{// 程序代碼 }catch(異常類型1 異常的變量名1){// 程序代碼 }catch(異常類型2 異常的變量名2){// 程序代碼 }catch(異常類型3 異常的變量名3){// 程序代碼 }多重捕獲塊舉例：
try/catch/catch的結(jié)構(gòu)類似于if/else/else的邏輯，從上往下逐層判斷，滿足則進入對應(yīng)的分支。
捕獲多重異常寫法需注意：從小到大
否則會報錯：
捕獲異常快捷鍵Ctrl+Alt+T
結(jié)果如下
throws/throw 關(guān)鍵字
如果一個方法沒有捕獲到一個檢查性異常，那么該方法必須使用 throws 關(guān)鍵字來聲明。throws 關(guān)鍵字放在方法簽名的尾部。
也可以使用 throw 關(guān)鍵字拋出一個異常，無論它是新實例化的還是剛捕獲到的。
舉例如下：下面代碼會拋出ArithmeticException異常，原因是0作為除數(shù)。
package com.exception;public class Demo02 {public static void main(String[] args) {int a = 1;int b = 0;new Demo02().test(a,b);}public void test(int a, int b) throws ArithmeticException{System.out.println("進行除法運算");System.out.println(a/b);} } /* 輸出結(jié)果如下：進行除法運算 Exception in thread "main" java.lang.ArithmeticException: / by zeroat com.exception.Demo02.test(Demo02.java:11)at com.exception.Demo02.main(Demo02.java:7)Process finished with exit code 1 */一個方法可以聲明拋出多個異常，多個異常之間用逗號隔開。
finally關(guān)鍵字
finally 關(guān)鍵字用來創(chuàng)建在 try 代碼塊后面執(zhí)行的代碼塊。
無論是否發(fā)生異常，finally 代碼塊中的代碼總會被執(zhí)行。
在 finally 代碼塊中，可以運行清理類型等收尾善后性質(zhì)的語句。
自定義異常
在Java中可以自定義異常，需要注意以下幾點：
一個異常類和其它任何類一樣，包含有變量和方法。
可以如下定義一個異常：繼承Exception類，表明這是一個檢查性異常類
自定義異常類舉例：
下面是自定義異常類MyException,處理的異常是：如果傳入的參數(shù)大于10，就拋出異常，輸出對應(yīng)的信息。
關(guān)于異常在實際應(yīng)用中的經(jīng)驗總結(jié)
參考資料
[1]https://www.bilibili.com/video/BV12J41137hu?p=1
[2]https://www.runoob.com/java/java-tutorial.html
感謝您閱讀到最后，為了您的閱讀體驗，附上鏈接方便跳轉(zhuǎn)。
文章目錄
- IDEA使用
- Java基礎(chǔ)01：注釋
- Java基礎(chǔ)02：數(shù)據(jù)類型
- Java基礎(chǔ)03：類型轉(zhuǎn)換
- Java基礎(chǔ)04：變量
- Java基礎(chǔ)05：運算符
- Java基礎(chǔ)06：包機制
- Java流程控制01：用戶交互Scanner
- Java流程控制02：Switch case語句
- Java流程控制03：循環(huán)語句
- Java方法01：方法的基本概念
- Java數(shù)組01：數(shù)組基礎(chǔ)
- Java數(shù)組02：Arrays類
- Java數(shù)組02：手撕冒泡排序
- Java面向?qū)ο?1：OOP簡介
- Java面向?qū)ο?2：創(chuàng)建對象
- Java面向?qū)ο?3：封裝、繼承、多態(tài)?
- Java面向?qū)ο?4：抽象類
- Java 面向?qū)ο?5：接口interface?
- Java 面向?qū)ο?6：內(nèi)部類
- Java 面向?qū)ο?7：異常exception
- 參考資料
總結(jié)
以上是生活随笔為你收集整理的Java入门学习笔记[狂神说Java]的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Java API帮助文档怎么查找？
- 下一篇： Java多线程详解[狂神说Java]