面向對象

一、初識面向對象

見文件資料的面向對象.md

全內容梳理

類與實體概念

現實生活：

? 類：抽象的概念，把具有相同特征和操作的事物歸為一類

? 先有實體，再有類的概念

代碼世界：

? 類：抽象的概念，把具有相同屬性和方法的對象歸為一類

? 編寫順序：先有類，再創建對象

? 類的作用：類相當于一個模板，刻畫出具有相同屬性和方法的對象

類

1. 類中只有屬性和方法
2. 屬性也叫做全局變量，屬性分為成員變量和靜態變量
3. 方法分為成員方法和靜態方法

public class 類名{//屬性也叫做全局變量，分為成員變量和靜態變量//成員變量數據類型 變量名;//靜態變量static 數據類型 變量名;//方法分為成員方法和靜態方法//成員方法訪問修飾符 返回值類型 方法名([參數]){}//靜態方法訪問修飾符 static 返回值類型 方法名([參數]){}
}

對象

創建對象的語法：類名 對象名 = new 類名();

? new 構造方法; 屬于對象，就在堆內存中開辟空間

? 類名 對象名 ：對象名屬于引用，存的是對象在堆內存中的地址

操作對象：

1. 設置成員屬性

2. 獲取成員屬性

3. 調用成員方法

成員屬性/成員變量

語法結構：數據類型 變量名;

編寫的位置：類里，方法的外面

成員變量 vs 局部變量

成員變量：類里，方法的外面的變量，并且系統會賦默認值，作用在整個類中

局部變量：方法內的變量，系統不會賦默認值，作用在方法中

成員方法

語法結構：訪問修飾符 返回值類型 方法名([參數]){}

編寫的位置：類里

成員方法 vs 靜態方法

成員方法：屬于對象的方法，必須使用對象調用

靜態方法：屬于類的方法，使用類名調用

案例理解

1.初識面向對象的需求

需求：創建人類的對象，并操作對象

分析：

? 人類 - Person

? 屬性：name、sex、age

? 方法：eat、sleep

步驟：

? 1.創建Person類，屬性、方法

? 2.創建Person類的對象

public static void main(String[] args) {//創建對象Person p = new Person();//設置屬性p.name = "奇男子";p.sex = '男';p.age = 23;//獲取屬性System.out.println(p.name);System.out.println(p.sex);System.out.println(p.age);//調用成員方法//注意：成員方法使用引用/對象調用對象p.eat();p.sleep();//調用靜態方法//注意：靜態方法使用類名調用Person.method();
}

2.關于成員屬性/成員變量的ps

注意：屬于對象的變量，系統會賦默認值，該類所有的成員方法都能使用該變量

成員變量的默認值：

? 整數類型：0

? 浮點類型：0.0

? 字符類型：’ ’

? 布爾類型：false

? 引用類型：null

public class Person {String name;char sex;int age;//成員方法public void eat(){//局部變量：方法里的變量，必須初始化后，才能使用，其作用域在方法內int i = 100;System.out.println("吃飯飯 -- " + i);}public void sleep(){System.out.println("睡覺覺");}//靜態方法//注意：靜態方法不能使用成員變量public static void method(){System.out.println("靜態方法");}}

面向對象理解圖、面向對象內存圖

見文件畫圖

1.小結

1.使用到類，JVM就會把該類的class文件加載到方法區，掃描該類的字面值常量，將字面值常量加載到常量池中
2.new對家會在堆中開辟空間，用于存儲對象里的成員變量，系統會賦默認值

3.引用中存儲的是對象在堆中的地址
4.調用方法，就會在棧開辟空間，該空間存放方法的局部變量，方法執行完畢該空間會立刻回收
5.class文件中存放了該類所有的信息(屬性、成員方法、靜態方法)

初識面相對象深入理解

1.需求：

創建人類的對象，并操作對象

分析：

人類 - Person

屬性：name、sex、age

方法：eat、sleep

場景：創建多個對象，去操作對象

public class Person {//成員變量
String name;
char sex;
int age;//成員方法
public void eat(){System.out.println(this.name + "吃飯飯");
}//成員方法
public void sleep(){System.out.println(this.name + "睡覺覺");
}//靜態方法
public static void method(){System.out.println("靜態方法");
}}

//測試類：該類中有main方法，測試我們寫好的代碼
public class Test01 {public static void main(String[] args) {Person p1 = new Person();Person p2 = new Person();p1.name = "奇男子";//一個一個賦值p1.sex = '男';p1.age = 22;p2.name = "星宮一花";p2.sex = '女';p2.age = 24;p1.eat();p1.sleep();p2.eat();p2.sleep();Person.method();}}

2.面向對象深入理解圖

見文件資料面向對象內存圖

小結
1.class文件只加載一次

? 2.class文件中包含了該類所有的信息

? 3.new對象會在堆中開辟空間，存放成員變量

? 4.成員變量系統會賦默認值

? 5.每個對象獨享一份成員變量

? 6.方法中的this表示調用該方法的對象

? 7.成員方法可以使用this
? 8.靜態方法使用類名調用，所以方法內不能使用this

二、構造方法

前言 - 創建對象的語法：類型 引用 = new 構造方法;

分類：

無參構造和有參構造

含義：

與類名相同，且沒有返回項的方法

作用：

? 1.和new關鍵字在一起表示創建對象

? 2.初始化數據

注意：

? 1.創建對象的過程(Person p = new Person()😉，也叫做實例化

? 2.當類中沒有有參構造時，系統會默認實現無參構造；反之不會默認實現

? 3.構造方法可以重載的

有參構造好處：創建對象時，把數據賦值給該對象

經驗：

類中編寫了有參構造，我們記得把無參構造加上

需求：創建人類，操作對象

public class Person {	//成員變量
String name;
char sex;
int age;//構造方法 - 無參構造
public Person(){System.out.println("無參構造");//初始化數據this.name = "默認值";//不寫this也是默認使用用thisthis.sex = '男';this.age = 0;
}//構造方法 - 有參構造
public Person(String name,char sex,int age){System.out.println("有參構造");this.name = name;//不寫this會報錯，將傳進來的參數賦值給對象的屬性this.sex = sex;this.age = age;
}//成員方法
public void eat(){System.out.println(this.name + "吃飯飯");
}//成員方法
public void sleep(){System.out.println(this.name + "睡覺覺");
}}

public class Test01 {public static void main(String[] args) {/*		//無參Person p = new Person();p.name = "奇男子";p.sex = '男';p.age = 22;*///類型 引用 = new 構造方法;Person p = new Person("奇男子", '男', 22);//有參構造方法，new對象時給屬性賦值System.out.println(p.name);System.out.println(p.sex);System.out.println(p.age);p.eat();p.sleep();
}}

無參構造：new對象時，成員變量系統會賦默認值，之后會調用無參構造(可以進行初始化數據，測試類中一個一個給屬性賦值)，構造方法執行完，對象創建成功；

有參構造：new對象時，成員變量系統會賦默認值，之后會調用無參構造，再調用有參構造(可以進行初始化數據,將傳進來的參數賦值給對象的屬性),構造方法執行完，對象創建成功；

無參構造、有參構造內存圖

見文件資料構造方法內存圖1、2

三、private

含義：

私有化

private是訪問修飾符的一種，訪問修飾符規定了訪問權限

作用：

? 1. 修飾屬性：私有化屬性，不能讓外界使用

2. 修飾方法：私有化方法，不能讓外界使用

應用場景：

不讓讓外界訪問的屬性和方法就用private修飾

案例

public class A {private String str = "用良心做教育";private void method01(){System.out.println("aaabbbccc -- " + str);
}public void method02(){method01();
}}

public class Test01 {public static void main(String[] args) {A a = new A();a.method02();
}
}

注意：

通過公有的方法調用類中私有的方法、屬性

四、封裝

理解：

不能直接操作屬性，可以添加get/set方法

步驟：

1.私有化屬性

2.添加get-獲取/set-設置方法

好處：

外界不能直接操作屬性(有風險)，通過get/set方法操作屬性，可以在方法內添加額外的功能

需求：

模擬銀行用戶操作余額的功能

分析：

操作余額（存錢、取錢、查看）

import java.time.LocalDateTime;public class User {String username;
String password;
String name;
String phone;
char sex;
private double surplus;//余額public User() {
}public User(String username, String password, String name, String phone, char sex, double surplus) {this.username = username;this.password = password;this.name = name;this.phone = phone;this.sex = sex;this.surplus = surplus;
}//設置余額
public void setSurplus(double surplus){//額外的功能double num = (surplus - this.surplus);System.out.println(LocalDateTime.now() + " -- " + this.name + "用戶操作了金額：" + ((num>0)?"+":"") + num);//設置屬性this.surplus = surplus;
}//獲取余額
public double getSurplus(){//額外的功能System.out.println(LocalDateTime.now() + " -- " + this.name + "用戶獲取了金額");//返回余額return surplus;
}}

public class Test01 {public static void main(String[] args) {User user = new User("1234567891", "123123", "奇男子", "17823466612", '男', 2000);//存錢//user.surplus = user.surplus+200;user.setSurplus(user.getSurplus() + 200);//取錢//user.surplus = user.surplus-1800;user.setSurplus(user.getSurplus() -1800);//查看//System.out.println(user.surplus);//400.0System.out.println(user.getSurplus());//400.0
}}

思考題：操作屬性有什么功能？

1.設置屬性 – set

2.獲取屬性 – get

面向對象五子棋

見文件代碼Gobang02

五、this - 本對象

概念：

表示本對象

理解：哪個對象調用該方法，該方法里的this就表示該對象

含義：

代表本對象，this出現方法里，表示調用該方法的對象

作用：

1. this.屬性：調用本對象的成員變量
2. this.方法：調用本對象的成員方法
3. this()：調用本對象的構造方法（在一個構造方法中的第一句調用另外一個構造方法）

案例

import java.time.LocalDateTime;public class User {private String username;
private String password;
private String name;
private String phone;
private char sex;
private double surplus;//余額public User() {//在當前構造方法中調用另一個構造方法this("默認賬號", "默認密碼", "亞當", "12345678901", '男', 0.0);
}public User(String username, String name, String phone, char sex, double surplus) {//在當前構造方法中調用另一個構造方法this(username,"000000", name, phone, sex, surplus);
}public User(String username, String password, String name, String phone, char sex, double surplus) {this.username = username;this.password = password;this.name = name;this.phone = phone;this.sex = sex;this.surplus = surplus;
}//設置余額
public void setSurplus(double surplus){//額外的功能double num = (surplus - this.surplus);System.out.println(LocalDateTime.now() + " -- " + this.name + "用戶操作了金額：" + ((num>0)?"+":"") + num);//設置屬性this.surplus = surplus;
}//獲取余額
public double getSurplus(){//額外的功能System.out.println(LocalDateTime.now() + " -- " + this.name + "用戶獲取了金額");//返回余額return surplus;
}public String getUsername() {return username;
}public void setUsername(String username) {this.username = username;
}public String getPassword() {return password;
}public void setPassword(String password) {this.password = password;
}public String getName() {return name;
}public void setName(String name) {this.name = name;
}public String getPhone() {return phone;
}public void setPhone(String phone) {this.phone = phone;
}public char getSex() {return sex;
}public void setSex(char sex) {this.sex = sex;
}/*** 轉賬* @param username 對方的賬號* @param money 轉賬的金額*/public void transferAccounts(String username,double money){//獲取本對象的余額，判斷是否比轉賬的金額更多if(this.getSurplus() > money){//將當前用戶的余額的money部分轉給對方賬號//this.setSurplus(this.getSurplus()-money);setSurplus(getSurplus()-money);System.out.println("已經給" + username + "轉賬成功");}else{System.out.println("余額不足");}}}

經驗

私有化屬性：eclipse工具欄 ------->Source------->Select getters and setters to create—>勾選需要生成屬性的get和set方法；

Source中還有一些自動生成，如構造方法等等；

六、分包

基本作用：防止了類的重名問題

項目作用：項目中有眾多的類，把相同功能的類放在同一個包中，方便管理

工具類：com.dream.util/tool

實體類：com.dream.vo/bean/entity/bto/pojo

數據庫類：com.dream.dao/mapper

七、static - 靜態的

含義：

靜態的

關鍵字

作用：

1.修飾屬性

概念區分：

1.成員屬性：每個對象獨享一份

	String str1;

2.靜態屬性：每個對象共享一份

	static String str2;

3.靜態屬性何時創建？

? 使用到類，JVM會判斷方法區中是否有該類的class文件，如果沒有，就把該類的class文件加載到方法區

? JVM會掃描該類的所有屬性，并把屬性添加到靜態區中（1.開辟空間 2.賦系統的默認值）

4.靜態屬性何時銷毀？

? 項目結束時，靜態屬性才會被銷毀，所以靜態屬性的生命周期很長，項目中使用時需警慎

5.靜態屬性的應用場景？

? 該類所有的對象需要共享的屬性，就可以設置為靜態

靜態屬性內存圖

見文件畫圖

由于靜態屬性存在靜態區，其屬性不允許重復，不同調用賦值會覆蓋掉

小結

? 類加載到方法區時，JVM會掃描該類的所有屬性
? 并把靜態屬性加載到靜態區中，靜態屬性屬于類屬性，
? 該類所有的對象都共享該屬性
? 靜態屬性直到項目結束時才會被回收

? 注意：靜態屬性使用類名調用

A.str2 = "xxx";

//注意：靜態屬性屬于類的屬性，直接使用類名調用。使用對象調用會出現警告,但可以運行
//a1.str2 = "xxx";

成員屬性對象調用

a1.str1 = "aaa";

2.修飾方法

概念區分

靜態方法屬于類方法，直接用類名調用

成員方法 vs 靜態方法 應用場景

成員方法：必須使用對象調用，也就是說調用成員方法之前必須創建對象(開辟空間)

靜態方法：屬于類的方法，直接使用類名調用，純功能的方法就可以設計成靜態方法(工具類)，比如MyArrays

應用場景：工具類

jar包導入并添加路徑，jar包導出，導出API

(1)Java項目打成jar包：選中項目(也可以先點Export再選項目，多個項目導出)---->eclipse的工具的File或右鍵---->Export------>java–JAR file---->保存路徑

【Web項目同理WAR file】

(2)Java項目導入jar包：先選中項目新建一個文件夾(Folder)命名如lib----->將jar所需扔到lib---->再選中改jar右鍵Build Path選add to Build Path---->就會多出一個第三方jar包文件夾(原來有一個自帶的)

導入jar到該項目就可以使用里面的工具類

(3)Java項目導出API：選中項目---->eclipse的工具的File或右鍵---->Export------>java–Javadoc---->Java comand添加工具路徑【ps：C:\Program Files\Java\jdk1.8.0_144\bin\javadoc.exe】---->Destination選保存路徑【生成的是一個個的html網頁，所以需要選中文件夾，或者在路徑后面加一個文件名ps：UtilsAPI，反正沒有收納很亂】

查看API就點擊index.html首頁進入查看【文檔注釋才可以顯示，注意文檔注釋和多行注釋】

eclipse注釋快捷鍵

單行注釋:Ctrl + /【 添加/消除//注釋 】

多行注釋： Ctrl+Shift+/ 【 添加/**/注釋 】Ctrl+Shift+\【取消/* */注釋】

文檔注釋： ALT + SHIFT +J 或者多行注釋再加個*號

在類上面(直接按ALT + SHIFT +J )

/*** @author 奇男子
*
*/

方法上面的(鼠標焦點放在方法里，然后 ALT + SHIFT +J )

/**

• 刪除學生
• @param classId 目標班級號
• @param id 目標學號
• @return 刪除狀態碼
  */
  public int delete(String classId,String id);

需求：

模仿Java的MyArrays，編寫自己的MyMyArrays

目的：

1.掌握工具類的概念

2.回顧之前的知識點

3.理解文檔注釋的作用

代碼見Utils

3.靜態代碼塊

概念區分

靜態代碼塊是類加載到方法區時才會被調用，該代碼塊只能初始化靜態變量

代碼塊是創建對象時優先于構造方法調用，該代碼塊可以初始化成員變量和靜態變量

構造方法是創建對象時調用，該方法可以初始化成員變量和靜態變量

成員變量 vs 靜態變量

成員變量：屬于對象的變量，每個對象獨享一份

靜態變量：屬于類的變量，每個對象都共享一份

public class A {String str1;//成員屬性
static String str2;//靜態屬性//靜態代碼塊：class文件加載到方法區時調用
//作用：操作靜態屬性，不能操作成員屬性
static{A.str2 = "eee";//底層實現：A.str2 = "eee";System.out.println("靜態代碼塊 --" + A.str2);
}//代碼塊：創建對象時優先于構造方法調用
//作用：操作成員屬性和靜態屬性
{str1 = "ccc";//底層實現：this.str1 = "ccc";str2 = "ddd";//底層實現：A.str2 = "ddd";System.out.println("代碼塊-- " + str1 + " -- " + str2);
}//構造方法：創建對象時調用構造方法
//作用：操作成員屬性和靜態屬性
public A() {str1 = "aaa";//底層實現：this.str1 = "aaa";str2 = "bbb";//底層實現：A.str2 = "bbb";System.out.println("構造方法 -- " + str1 + " -- " + str2);
}
}

經驗：

1.創建對象時，在構造方法中初始化數據

2.項目中可以在靜態代碼塊中初始化靜態屬性

八、類加載機制

類加載機制內存圖

見文件畫圖

加載過程

面試題

1.面試題1輸出結果

public class A {static A a = new A();static int value1;static int value2 = 0;public A() {value1++;value2++;}}
public class Test01 {public static void main(String[] args) {System.out.println(A.value1);//1System.out.println(A.value2);//0
}
}

準備階段1：JVM給靜態屬性在靜態區中開辟空間
//A a;
//int value1;
//int value2;

準備階段2：JVM給靜態屬性賦系統默認值
//A a = null;
//int value1 = 0;
//int value2 = 0;

初始化階段：java程序代碼才開始真正執行
//A a = new A();
//int value1 = 1;
//int value2 = 0;

new對象調用無參構造方法value1和value2都得1，然后執行賦值語句value1不變，value2賦值為0

2.面試題1輸出結果

public class A {static int value1;static int value2 = 0;static A a = new A();public A() {value1++;value2++;}}
public class Test01 {public static void main(String[] args) {System.out.println(A.value1);//1System.out.println(A.value2);//1
}
}

準備階段1：JVM給靜態屬性在靜態區中開辟空間
//int value1;
//int value2;
//A a;

準備階段2：JVM給靜態屬性賦系統默認值
//int value1 = 0;
//int value2 = 0;//0是系統賦的默認值
//A a = null;

初始化階段：java程序代碼才開始真正執行
//int value1 = 1;
//int value2 = 1;
//A a = new A();

先執行賦值語句value1不改變系統默認賦值的0，value2被語句賦值為0；再new對象調用無參構造方法value1和value2都得1

深入類加載機制

見文件資料的深入類加載機制.md

九、繼承

概念

Java中的繼承是一個對象獲取父對象的所有屬性和行為的機制

理解：繼承是指一個類(子類)可以繼承另一個類(父類)的屬性和方法

關鍵字extends

優點：減少代碼的冗余

缺點：繼承會增加類與類之間的關系，會增加代碼的維護難度

繼承的使用

使用場景：多個類似的類，有相同的屬性和方法，就可以把相同屬性和方法抽取到父類

需求：編寫中國人和日本人的類，創建各自的對象

分析：

人類：

屬性：姓名、性別、年齡

方法：吃飯飯、睡覺覺

中國人的類 繼承 人類 ：

屬性：身份證

方法：打太極

日本人的類 繼承 人類：

屬性：年號

方法：拍電影

ps：（省略部分代碼）

public class Person {String name;
char sex;
int age;public void eat(){System.out.println(this.name + "吃飯飯");
}public void sleep(){System.out.println(this.name + "睡覺覺");
}}

//            子類           繼承        父類
public class Chinese extends Person{String id;public void playTaiJi(){System.out.println("中國人打太極");
}}

	//創建對象Chinese c = new Chinese();//操作父類屬性c.name = "奇男子";c.sex = '男';c.age = 22;System.out.println(c.name);System.out.println(c.sex);System.out.println(c.age);//操作子類屬性c.id = "1234567890";System.out.println(c.id);//調用父類方法c.eat();c.sleep();//調用子類方法c.playTaiJi();

繼承內存圖

見文件畫圖

super

理解：

super表示父類

作用：

1.super.屬性：在子類中，調用父類的非私有化的成員屬性

2.super.方法：在子類中，調用父類的非私有化的成員方法

3.super()：在子類構造方法中的第一句調用父類的非私有化的構造方法

案例：

繼承的使用的需求案例

封裝父類，添加無參構造、有參構造、get、set方法(都由eclipse直接生成)，成員方法保留

經驗

私有化屬性：eclipse工具欄 ------->Source------->Select getters and setters to create—>勾選需要生成屬性的get和set方法；

Source中還有一些自動生成，如構造方法等等；

子類繼承父類，封裝子類，super使用

public class Chinese extends Person{private String id;public Chinese() {
}public Chinese(String name, char sex, int age, String id) {super(name, sex, age);this.id = id;
}public String getId() {return id;
}public void setId(String id) {this.id = id;
}public void playTaiJi(){System.out.println(super.getName() + "打太極");
}}

測試類，有有參構造直接賦值，不用一個個賦值

	//創建對象Chinese c = new Chinese("奇男子", '男', 22, "1234567890");//調用父類方法c.eat();c.sleep();//調用子類方法c.playTaiJi();

小結

編寫一個類的步驟：

1.屬性

2.私有化屬性

3.無參構造

4.有參構造

5.get/set方法

6.其他的方法

深入繼承：

思考題：

1. 創建子類對象，會不會調用父類構造方法？
   會

2. 創建子類對象，會不會創建父類對象？
   不會

3. 創建子類對象，為什么會調用父類構造方法？
   目的是將父類的屬性存放在子類對象中(因為會在子類對象中開辟空間，用于存儲父類的成員屬性)

4. 創建子類對象，先調用父類構造方法還是子類構造方法？
   先調用子類構造方法

5. 創建子類對象，先完成父類構造方法還是子類構造方法？
   先完成父類構造方法

6. 子類可以繼承父類私有化的屬性和方法嗎？

? 可以，但是只能間接調用

7. 子類對象是否能繼承父類所有的屬性和方法？

? Java官網上，明確表示子類不能繼承父類私有化的屬性和方法，這是站在使用的角度

? 實際上，子類能繼承父類私有化的屬性方法，但是不能直接使用，可以在父類中編寫公有方法去調用私有的屬性和方法

案例：

public class Father {private String fatherAttr = "父類私有化屬性";public Father() {System.out.println("調用父類的構造方法");
}public String getFatherAttr() {return fatherAttr;
}public void setFatherAttr(String fatherAttr) {this.fatherAttr = fatherAttr;
}private void method01(){System.out.println("父類私有化方法");
}public void method02(){method01();
}}

public class Son extends Father{public Son() {//super();//默認實現：調用父類的構造方法System.out.println("調用子類的構造方法");
}}

public class Test01 {public static void main(String[] args) {	Son son = new Son();System.out.println(son.getFatherAttr());son.method02();
}}

重寫/復寫

含義：

重寫也叫做復寫，將父類中方法在子類中重新編寫一遍

應用場景：

父類方法不滿足子類需求時，子類就可以重復父類的方法

條件：

1.在子類中重寫父類的方法

2.返回值、方法名、參數列表必須跟父類重寫的方法一致

3.訪問修飾符不能比父類更嚴格

需求：

編寫中國人和日本人的類，創建各自的對象

public class Chinese extends Person{
//省略一部分//@Override -- 重寫的注解
//注解：給程序員和系統解釋代碼信息
@Override
public void eat(){System.out.println(super.getName() + "吃山珍海味");
}
//在測試類new對象調用輸出

十、訪問修飾符

含義：

修飾類、方法、屬性，定義使用的范圍

理解：給類、方法、屬性定義訪問權限的關鍵字

注意：

? 1.修飾類只能使用public和默認的訪問權限

? 2.修飾方法和屬性可以使用所有的訪問權限

訪問修飾符	本類	本包	其他包子類	其他包
private	OK
默認的	OK	OK
protected	OK	OK	OK
public	Ok	OK	OK	Ok

做實驗

兩個包下分別父類和子類，測試類進行實驗

經驗：

1.屬性一般使用private修飾，因為封裝

2.屬性或者方法如果需要被子類使用，一般使用protected修飾

3.方法如果不需要被外界使用，一般使用private修飾

4.方法一般使用public修飾

十一、Object

概念：

所有類的基類或者超類

理解：如果一個類沒有明確繼承的類，默認繼承Object，所以說Object是所有類的祖先類

方法

equals：

作用：比較兩個對象內存地址是否相同

public boolean equals(Object obj){return this == obj;}

注意：equals和==

a.基本數據類型：==比較的是值是否相同

b.引用數據類型：==比較的是內存地址

查看equals底層

鼠標放在equals上按ctrl點擊----->點擊Attach Source------>選擇外部路徑External location----->ps：C:\Program Files\Java\jdk1.8.0_144\src.zip

equals內存圖

見文件畫圖

擴展
1.Java方法的參數是值傳遞
2.如果方法中參數是基本類型直接將實參的值傳入該方法

? 3.如果方法中的參數是引用類型將對象的內存地址作為值傳入該廣法

hashCode：

作用：獲取對象的hash值

hash值不等于內存地址，hash值是對象的內存地址+散列算法，算出來的一個數值

		System.out.println(obj1.hashCode());//366712642

getClass：

作用：獲取類的字節碼文件對象

注意：

使用到類，會把該類的class文件加載到方法區，并且在堆中創建該類的class對象

該類的class對象作為class文件的訪問入口

class文件只加載1次，所以該類的class對象在內存中也只有一個

		Object obj1 = new Object();//0x001Object obj2 = new Object();//0x002Class<? extends Object> class1 = obj1.getClass();//獲取的是Object類的class對象Class<? extends Object> class2 = obj2.getClass();//獲取的是Object類的class對象System.out.println(class1 == class2);//true

toString：

作用：獲取對象的字符串表示(將對象轉換為字符串)

toString底層：

public String toString(){
//java.lang.Object @ 15db9742
return getClass().getName() + “@” + Integer.toHexString(hashCode());

  	//getClass().getName() - class對象的全路徑(報名+類名)//Integer.toHexString(hashCode()) - 獲取對象的十六進制hash值

}

	Object obj1 = new Object();//0x001Object obj2 = new Object();//0x002System.out.println(obj1.toString());//java.lang.Object@15db9742System.out.println(obj2.toString());//java.lang.Object@6d06d69c

方法的使用

Object方法標桿作用

Object方法標桿作用：Object作為所有類的父類，定義了幾個方法，方便子類去重寫

equals：比較兩個對象是否相同，不同子類比較兩個對象的規則不一樣，所以子類重寫即可

toString：每個子類都有不同的屬性，重寫toString直接打印該對象中所有的屬性，方便觀察數據

getClass()：在反射的知識點中使用

hashCode()：在集合的知識點中使用

equals和toString使用

需求：編寫用戶類，比較兩個對象是否相同，并打印

封裝User(默認繼承Object)，重寫equals、toString

	@Overridepublic boolean equals(Object obj) {if(this == obj){//比較兩個對象的內存地址是否一致return true;}//兩個對象的內存地址不一致User use = (User) obj;//需要強轉，java的參數是值傳遞//當前對象的賬號和傳進來對象的賬號，此處是String類型的equals()if(this.username.equals(use.username)){return true;}return false;}@Overridepublic String toString() {//打印所有屬性return this.username + " -- " + this.password + " -- " + this.nickName + " -- " + this.name;}//測試類User user1 = new User("1445584980", "123123", "撕裂的憂傷", "彭于晏");//0x001User user2 = new User("1445584980", "123123", "撕裂的憂傷", "彭于晏");//0x002System.out.println(user1.equals(user2));System.out.println(user1.toString());System.out.println(user2.toString());

深入String的equals()

MyString

重寫方法(@Override)，String的equals底層原理

首先toCharArray()將字符串轉換為字符數組

重寫equals

? a.比較內存地址是否相同

? b.比較字符長度是否相同

? c.比較字符的Unicode碼是否相同

重寫toString

? valueOf()將字符數組轉為字符串

注意：打印對象，默認調用toString()

public class MyString {private char[] value;public MyString(String original) {//"abc"//['a','b','c']value = original.toCharArray();//將字符串轉換為字符數組
}@Override
public boolean equals(Object obj) {if(this == obj){return true;}MyString my = (MyString) obj;char[] v1 = this.value;char[] v2 = my.value;//比較字符長度if(v1.length != v2.length){return false;}for (int i = 0; i < v1.length; i++) {//比較字符的Unicode碼是否相同if(v1[i] != v2[i]){return false;}}return true;
}@Override
public String toString() {return String.valueOf(value);//將字符數組轉為字符串
}}

2.面試題：String是如何比較兩個字符串是否相同的

1.比較兩個字符串的地址是否相同

2.比較兩個字符串的字符個數

3.循環比較字符的Unicode碼

//String和MyString都可以實現，表明重寫的MyString符合要求

	String str1 = new String("abc");String str2 = new String("abc");System.out.println(str1 == str2);//falseSystem.out.println(str1.equals(str2));//trueSystem.out.println(str1);System.out.println(str2);System.out.println("-------------------------------");MyString m1 = new MyString("abc");MyString m2 = new MyString("abc");System.out.println(m1 == m2);//falseSystem.out.println(m1.equals(m2));//true//注意：打印對象，默認調用toString()System.out.println(m1);System.out.println(m2);

十二、final

含義：

最終的

關鍵字

作用：

1. 修飾類：該類不能被繼承
2. 修飾方法：該方法不能被重寫
3. 修飾變量：變成常量，不能重新賦值

注意：

1.常量在常量池中聲明，項目結束時才會被銷毀

2.常量的命名規范：全部單詞大寫，單詞之間使用下劃線隔開

3.常量的生命周期：存在常量池中，直到項目結束才會被銷毀

經驗：
如果不想讓該類有子類（不想該類有擴展），就是用final修飾

final和static一般一起修飾屬性，該屬性變成靜態常量

做實驗

//final修飾類，該類不能被繼承
//public final class A {
public class A {//final修飾方法，該方法不能被子類重寫
//public final void method(){
public void method(){System.out.println("父類的方法");
}}

public class B extends A{@Override
public void method() {System.out.println("子類重寫父類的方法");//final修飾變量，變量變為常量，不能重新賦值final int i = 100;System.out.println(i);
}}

十三、抽象類及抽象方法

//抽象類
public abstract class 類名{//抽象方法public abstract void method();
}

abstract

關鍵字，用來修飾類和方法

不能與final，static，private一起修飾，不能被重寫

抽象類

1.概念：

被abstract修飾的類，包含抽象方法的類就是抽象類

2.抽象類的特征：

1. 抽象類不能實例化，即不能用new來實例化抽象類
2. 抽象類中包含有構造方法，但構造方法不能用來new實例，只能用來被子類調用
3. 抽象類中可以包含成員變量，成員方法，靜態方法，構造方法，final 修飾的方法，抽象方法
4. 抽象類只能用來被繼承

3.應用場景：

當一個方法必須在父類中出現，但是這個方法又不好實現，就把該方法變成抽象方法，交給非抽象的子類去實現

抽象方法

1.概念

使用abstract修飾的方法，沒有方法體，只有聲明，交給非抽象的子類去實現（重寫）

理解：

將共性的行為(方法)抽取到父類之后。由于每一個子類執行的內容是不一樣的,在父類中不能確定具體的方法體。 即正向實現反向抽取。

2.抽象方法的特征：

1. 抽象類中可以包含 0 個或多個抽象方法
2. 抽象方法必須被子類實現
3. 抽象類中可以有屬性、構造方法、成員方法、靜態方法、抽象方法
4. 有抽象方法的類只能定義成抽象類(含有抽象方法的類必須是抽象類)
5. 只有當子類實現了抽象超類中的所有抽象方法，子類才不是抽象類，才能產生實例
6. 如果子類中仍有抽象方法未實現，則子類也只能是抽象類

抽象類及抽象方法的使用

需求：

編寫人類為父類，編寫兩個子類(ps:中國人、日本人)，中國人的子類(ps:四川人、廣東人)

封裝Person類并為抽象類，寫一個抽象方法eat()

	public abstract void eat();

Japanese類繼承Person類，重寫eat()

public class Japanese extends Person{private String yearNum;public Japanese() {
}public Japanese(String name, char sex, int age, String yearNum) {super(name, sex, age);this.yearNum = yearNum;
}public String getYearNum() {return yearNum;
}public void setYearNum(String yearNum) {this.yearNum = yearNum;
}@Override
public void eat() {System.out.println(super.getName() + "吃生魚片");
}}

Chinese類繼承Person類，但是并沒有實現eat()，所以Chinese類為抽象類，交給他的子類去實現。這里擴展添加了一個抽象方法hobbies()

public abstract class Chinese extends Person{private String id;public Chinese() {
}public Chinese(String name, char sex, int age, String id) {super(name, sex, age);this.id = id;
}public String getId() {return id;
}public void setId(String id) {this.id = id;
}public abstract void hobbies();}

SiChuan類繼承Chinese類，去實現了eat()，他可以實例化

public class SiChuan extends Chinese{public SiChuan() {
}public SiChuan(String name,char sex,int age,String id){super(name, sex, age, id);
}@Override
public void hobbies() {System.out.println(super.getName() + "喜歡打麻將、炸金花");
}@Override
public void eat() {System.out.println(super.getName() + "吃火鍋、串串香");
}}

抽象類及抽象方法的深入

面試題：

1.抽象類不能有構造方法？

抽象類可以有構造方法

2.抽象類中只能有抽象方法？

抽象類中有非抽象方法（成員方法和靜態方法）

3.抽象類中不可以沒有抽象方法？

抽象類中可以沒有抽象方法，但是毫無意義

4.如果父類是抽象類，則子類必須實現父類的抽象方法？

不一定，子類如果是抽象類，可以不實現父類的抽象方法

5.可以使用new關鍵字來創建抽象類對象？

不可以，創建的是匿名內部類的對象

抽象類及抽象方法的使用的擴展

匿名內部類

匿名內部類理解圖見文件畫圖

  I1 i1 = new Person() {@Overridepublic void i1Method() {System.out.println("用良心做教育");}};

在需要創建一個臨時對象來實現特定抽象類的情況下，可以直接通過匿名內部類來完成。這樣不必單獨編寫一個新的類文件，節省了開發工作量。

public class Test02 {public static void main(String[] args) {Person p = new Person("弗羅茲·甘地",'男',23) {//繼承父類屬性@Overridepublic void eat() {System.out.println(super.getName() + "吃咖喱");}};p.eat();}
}

接口

1.概念：

Java中一種引用類型，是方法的集合

特殊的抽象類

關鍵字interface

理解：

1. 特殊的抽象類
2. JDK1.7時，接口中只能有靜態常量和抽象方法
3. JDK1.8開始，接口中添加了靜態方法和默認方法

注意：

? 1.接口中的抽象方法默認添加public abstract（經驗：一般把abstract去掉）

? 2.接口中的屬性默認添加public static final

? 3.接口中的默認方法默認添加public

2.應用場景：

接口相當于是制定規則(標準)，再讓實現類去實現

抽象類 vs 接口

抽象類：成員變量、靜態變量、靜態常量、成員方法、靜態方法

接口：靜態常量、靜態方法(JDK1.8)、默認方法(JDK1.8)

3.類 - 接口的關系：

? 類 - 類：單繼承（一個類只能繼承另一個類，不能繼承多個類）

? 類 - 接口：多實現（一個類可以實現多個接口）

? 接口 - 接口：多繼承（一個接口可以繼承多個接口）

做代碼實驗驗證

4.實現

關鍵字implements，子類實現接口

需求：設計學生管理系統項目的接口
分析：
學生管理系統管理一個一個的學生對象
管理 - 數據的操作：增、刪、改、查

(1)封裝一個學生類，里面重寫toString()

(2)寫一個學生管理系統的接口

public interface IStudentManagerSystem {	//靜態常量
//默認使用public static final修飾
int NAME = 1;
int SEX = 2;
int AGE = 3;
int CLASS_ID = 4;
int ID = 5;//抽象方法
//默認使用public abstract修飾
public void add(Student stu);public void delete(String classId,String id);public void update(String classId,String id,int type,Object val);public Student getStu(String classId,String id);//靜態方法
public static void method01(){System.out.println("IStudentManagerSystem接口中的靜態方法");
}//默認方法
//默認使用public修飾
default void method02(){System.out.println("IStudentManagerSystem接口中的默認方法");
}
}

(3)寫學生管理系統的實現類實現接口生管理系統，當寫完類名時就會報紅提示實現接口里的抽象方法，點擊就會自動需要實現的方法，之后去完善就可以了

public class StudentManagerSystemImpl implements IStudentManagerSystem{@Override
public void add(Student stu) {
}@Override
public void delete(String classId, String id) {
}@Override
public void update(String classId, String id, int type, Object val) {
}@Override
public Student getStu(String classId, String id) {return null;
}}

(4)測試類調用方法

	StudentManagerSystemImpl sms = new StudentManagerSystemImpl();//調用實現類實現的方法sms.add(new Student());//調用默認方法sms.method02();//調用靜態方法，類名調用IStudentManagerSystem.method01();
}

5.面試題：

1.一個類可以實現多個接口？

可以
2.一個接口可以實現多個接口？

不可以，接口與接口的關系是多繼承
3.接口里面的方法不一定都是抽象的？

是的，因為JDK1.7時接口里只能有抽象方法，JDK1.8時接口可以有抽象方法和默認方法
4.接口解決了類的單繼承問題？

是的，因為類與類是單繼承，類與接口是多實現
5.一個類是否可以繼承一個類并同時實現多個接口？

可以
6.接口可以new對象？

不可以，因為接口是特殊的抽象類，但是本質還是抽象類，抽象類是不可以new對象的，接口也是不能new對象，new出來的匿名類內部類的對象

6.接口的使用擴展

(匿名內部類)匿名實現類

匿名內部類理解圖見文件畫圖

  I1 i1 = new I1() {@Overridepublic void i1Method() {System.out.println("用良心做教育");}};

十四、多態

概念

多態性是指同一操作或方法可以在不同的對象上具有不同的行為。它允許我們通過使用基類或接口類型的引用變量來調用子類或實現類的方法。

理解：多種形態

分類：

? 類的多態：子類對象指向父類引用（父類引用中存儲的是子類對象在堆中開辟的地址）

? 接口的多態：實現類對象指向接口的引用（接口的引用中存儲的是實現類對象在堆中開辟的地址）

設計

設計原則：前人總結的經驗，告訴我們什么不該做

設計模式：前人總結的經驗，告訴我們一步一步的怎么做

ps：OCP原則：

? O - Open - 在需求升級時，對于創建類是歡迎的

? (因為創建類對于原來代碼的影響幾乎為0)

? C - Close - 在需求升級時，對于改動原有類是拒絕的

? (因為原有類之間的關系是趨于穩定狀態，如果改動原有類，

? 很有可能打破這種平衡，導致bug的出現)

? P - Principle - 原則

優缺點：

? 優點：提高程序的維護性，在需求升級/迭代時，不違反OCP原則

? 缺點：不能調用子類獨有的屬性和方法

類的多態：

1.概念：

子類對象指向父類引用
理解：父類引用中存儲的是子類對象在堆中開辟的內存地址

2.需求

需求：使用代碼描述出老師騎著自行車上班
分析：老師類、自行車類

步驟：

? 1.創建Bick類，編寫open、close

? 2.創建Teacher，編寫start、stop

Teacher類start、stop方法里面調用Bick類的start、stop方法，操作具體的車

需求升級：自行車 -> 小汽車
步驟：
1.創建Car類，編寫open、close
2.改動原來的Teacher，編寫start、stop

同理Teacher類重載start、stop方法

需求升級：自行車 -> 小汽車 -> 飛機

步驟：

? 1.創建Vehicles類，編寫抽象方法open、close

? 2.創建Plane類，改動Bick、Car類繼承Vehicles，重寫open、close

? 3.改動原來的Teacher，改動start、stop操作交通工具

測試類：

	Teacher t = new Teacher();//類的多態：子類對象指向父類引用//理解：父類引用中存儲的是子類對象在堆中開辟的內存地址Vehicles v = new Plane();t.start(v);System.out.println("欣賞沿途的風景");t.stop(v);

接口的多態

1.概念

實現類對象指向接口的引用
理解：接口的引用存儲的是實現類對象在堆中開辟的地址

2.需求：

使用代碼描述出電腦連接外部設備

分析：電腦類、USB接口、鼠標類、硬盤類、鍵盤類

步驟：

? 1.創建IUSB接口，抽象方法use

? 2.創建鼠標類Mouse、硬盤類Disk、鍵盤類KeyBoard、都實現接口，并且都重寫抽象方法use；

? 3.電腦類Computer寫一個連接方法connection操作接口

測試類：

	Computer computer = new Computer();//接口的多態：實現類對象指向接口的引用//理解：接口的引用存儲的是實現類對象在堆中開辟的地址IUSB usb = new KeyBoard();computer.connection(usb);
}

十五、對象轉型

前提：有繼承關系

自動轉型 - 向上轉型：

子類類型 轉 父類類型

注意：

1. 向上轉型就是多態！！！

     	2. 向上轉型后，可以調用父類屬性、方法 3. 向上轉型后，不可以調用子類獨有的屬性、方法 4. 向上轉型后，可以調用子類重寫父類的方法
   

需求：父類，子類

寫一個Father類、一個Son類繼承Father

測試類進行驗證

	//向上轉型Father father = new Son();System.out.println(father.fatherAttr);father.fatherMethod();

強制轉型 - 向下轉型：

父類類型 轉 子類類型

注意：

1. 向下轉型是不安全的 – ClassCastException類型轉換異常
2. 出現ClassCastException，一定要看錯誤信息
3. 父類對象不能賦值給子類引用 – Dog dog = (Dog) new Animal();
4. 向下轉型之前必須先向上轉型
5. 向下轉型之前，使用instanceof判斷類型

ps：MyString

	if(obj instanceof MyString){MyString my = (MyString) obj;}

需求:動物類，貓類，狗類

創建動物類Animal；創建貓類Cat、狗Dog繼承Animal

測試類驗證：

  //前提：向上轉型Animal an = new Cat();//向下轉型if(an instanceof Dog){//判斷引用an中指向的對象是否是Dog類型Dog dog = (Dog) an;dog.shout();}else if(an instanceof Cat){//判斷引用an中指向的對象是否是Cat類型Cat cat = (Cat) an;cat.eat();}

應用場景

對象轉型的應用包括但不限于以下幾個方面:
1.多態性的實現:Java中的多態性是通過對象轉型來實現的。通過向上轉型，將子類對象賦值給父類類型的變量，可以實現對多個子類對象的統一處理，從而實現多態性。
2.接口的實現:接口是Java中重要的面向對象編程概念，對象轉型可以用于實現接口。將一個實現了某個接口的類類型對象轉換為該接口類型，就可以通過接口類型調用實現類中實現的方法。
3.繼承關系的處理:Java中的繼承關系是通過對象轉型來實現的。將一個子類類型的對象轉換為一個父類類型的對象，就可以實現父類和子類之間的繼承關系。
總之，Java中的對象轉型是java面向對象編程的重要特性之一，可以幫助程序員更好地實現面向對象編程的思想，提高代碼的可復用性和可維護性。

案例：MyString(參考day15)

更新MyString(代碼，向下轉型之前，使用instanceof判斷類型

	if(obj instanceof MyString){MyString my = (MyString) obj;

測試類：測試MyString達到要求

	String str1 = new String("abc");System.out.println(str1.equals(new Student()));//false	System.out.println("-------------------------------");MyString m1 = new MyString("abc");System.out.println(m1.equals(new Student()));//false

十六、內部類

理解：

一個類中再聲明另外一個類

應用場景：

1. B類的對象只在A類中使用，并且B類對象使用到了A類所有的屬性，就可以將B類作為A類的成員內部類
2. B類的對象只在A類中使用，并且B類對象使用到了A類靜態的屬性，就可以將B類作為A類的靜態內部類
3. 抽象類的子類只創建一次對象，就沒必要創建子類，直接使用匿名內部類（new 抽象類）
4. 接口的實現類只創建一次對象，就沒必要創建實現類，直接使用匿名內部類（new 接口）

分類：

1. 成員內部類

2. 靜態內部類

3. 接口內部類

4. 局部內部類

5. 匿名內部類

//外部類
public class Outter {//成員內部類class Inner01{}//靜態內部類static class Inner02{}public void method(){//局部內部類class Inner03{}	}
}
//接口
public interface I1 {//接口內部類class Inner{}
}

成員內部類

需求：創建成員內部類的對象，操作對象的方法

注意：

1. 創建成員內部類對象之前，必須創建外部類對象

2. 成員內部類可以調用外部類所有的屬性

3. 在成員內部類中調用指定的外部類屬性：外部類.this.屬性

ps：測試類

	//創建成員內部類的對象Inner inner = new Outter().new Inner();//調用方法inner.innerMethod();

//外部類
public class Outter {private 		String str1 = "外部類屬性1";String str2 = "外部類屬性2";
protected 		String str3 = "外部類屬性3";
public 			String str4 = "外部類屬性4";
final 			String str5 = "外部類屬性5";
static 			String str6 = "外部類屬性6";
static final 	String str7 = "外部類屬性7";//成員內部類
class Inner{String str1 = "內部類屬性";public void innerMethod(){System.out.println("成員內部類的方法");System.out.println(str1);//this.str1，就近原則,調內部類屬性System.out.println(Outter.this.str1);//調外部類屬性System.out.println(str2);//Outter.this.str2System.out.println(str3);//Outter.this.str3System.out.println(str4);//Outter.this.str4System.out.println(str5);//Outter.this.str5System.out.println(str6);//Outter.str6,調外部類靜態屬性，外部類名調用System.out.println(str7);//Outter.str7}
}
}

靜態內部類

需求：創建靜態內部類的對象，操作對象的方法

注意：

1. 創建靜態內部類對象，不用創建外部類對象
2. 靜態內部類只能調用外部類靜態的屬性

測試類

//創建靜態內部類的對象Inner inner = new Outter.Inner();//調用方法inner.innerMethod();

//外部類
public class Outter {	static 			String str1 = "外部類屬性1";
static final 	String str2 = "外部類屬性2";//靜態內部類
static class Inner{public void innerMethod(){System.out.println("靜態內部類的方法");System.out.println(str1);//Outter.str1System.out.println(str2);//Outter.str2}
}
}

接口內部類

需求：創建接口內部類的對象，操作對象的方法

注意：

1. 接口內部類默認使用public static修飾
2. 接口內部類的使用方式和靜態內部類一致

測試類

  //創建靜態內部類的對象Inner inner = new Outter.Inner();//調用方法inner.innerMethod();

//外部接口
public interface Outter {//接口內部類//默認使用public static修飾class Inner{public void innerMethod(){System.out.println("接口內部類的方法");}}}

局部內部類

1.使用

需求：調用局部內部類的方法

注意：

1. 局部內部類不能使用訪問修飾符
2. 局部內部類的作用域就在外部類方法中
3. 常量：存放在常量池中，項目銷毀時，常量才會被回收；局部變量：調用方法，方法在棧中開辟空間，用于存放局部變量，方法執行完畢，該空間會立刻回收

測試類：

  Outter outter = new Outter();outter.method();

//外部類
public class Outter {	public void method(){	//局部內部類class Inner{public void innerMethod(){System.out.println("局部內部類的方法");}}//創建局部內部類對象Inner inner = new Inner();//調用方法inner.innerMethod();	}
}

2.局部內部類理解圖

見文件畫圖

3.面試題：

局部內部類使用到外部類的局部變量時，為什么局部變量會變為常量？

答：局部變量變成常量，是讓該變量的生命周期變長，是讓方法以外還能找的到該數據，如果該變量是局部變量，方法執行完畢就直接被回收，在方法就不能使用該數據

匿名內部類

匿名內部類理解圖

見文件畫圖匿名內部類理解圖*2

應用場景：

作為接口或者抽象類的實現類：在需要創建一個臨時對象來實現特定接口或者抽象類的情況下，可以直接通過匿名內部類來完成。這樣不必單獨編寫一個新的類文件，節省了開發工作量。

創建匿名內部類的對象

（匿名子類，父類）

1. 底層創建一個匿名類(Test01$1.class)，繼承A類，重寫method方法
2. 創建匿名子類的對象
3. 賦值給父類的引用（類的多態）

【Test01$1.class是系統默認命名，通過查看class文件就可以看到；eclipse里查看：的工具欄---->window—>showview---->Navigator—顯示bin目錄的class文件】

（匿名子類實現類，父類接口）

1. 底層創建一個匿名類(Test01$1.class)，實現I1接口，重寫method方法
2. 創建匿名實現類的對象
3. 賦值給接口的引用（接口的多態）