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