Java实验03 面向对象（下）
實驗三 面向對象（下）
實驗3-1 類的繼承
一、實驗描述
1、 考核知識點
名稱：類的繼承
2、 練習目標
? 了解類繼承的意義和作用
? 掌握如何實現類的繼承
3、 需求分析
在程序中，繼承描述的是事物之間的所屬關系，通過繼承可以使多種事物之間形成一種關系體系。
為了讓初學者熟悉類的繼承，本實驗將演示類的繼承并編寫測試類驗證子類是否擁有父類的可繼承成員。
4、 設計思路（實現原理）
1）設計兩個類Student和Teacher
2）抽取兩個類共同的內容（如：吃飯、睡覺）封裝到一個類Person中，各自特有的部分保留在各自類中。
3）讓學生類繼承Person類，老師類也繼承Person。
4）編寫測試類Example01，測試Student類和Teacher是否繼承了Person類的成員。
二、實驗實現
1、抽取父類Person，實現繼承關系，代碼如下：
2、定義測試類Example01，代碼如下：
package Example01;class Person{String name;int age;public void eat(){System.out.println(name + "在吃飯");}public void sleep(){System.out.println(name + "在睡覺");} }class Student extends Person{public Student(String name,int age){this.name = name;this.age = age;}public void speak(){System.out.println("我叫"+this.name+"我今年"+age+"歲了，我是一個學生。");} }class Teachar extends Person{public Teachar(String name,int age){this.name = name;this.age = age;}public void speak(){System.out.println("我叫"+this.name+"我今年"+age+"歲了，我是一個老師。");} }public class Example01 {public static void main(String[] args) {Student s = new Student("小明",18);Teachar t = new Teachar("大明",25);s.speak();s.eat();s.sleep();t.speak();t.eat();t.sleep();} }運行結果如圖3-1所示。
圖3-1 運行結果
三、實驗總結
1、在Java中，多個類可以繼承一個父類，但是一個類不能直接繼承多個類，一個類只能有一個直接父類。
2、父類是由子類不斷抽取而來的，不斷地抽取就形成了體系結構，這個結構稱為繼承體系結構。
3、子類在繼承父類的時候，會自動擁有父類所有的成員。
4、繼承的好處是劃分了類的層次性，實現了代碼重用、擴展了程序功能。
實驗3-2 方法的重寫
一、實驗描述
1、 考核知識點
名稱：方法的重寫
2、 練習目標
? 了解方法重寫的意義和作用
? 掌握如何進行方法重寫
3、 需求分析
在繼承關系中，子類會自動繼承父類中定義的方法，但有時在子類中需要對繼承的方法進行一些
修改，即對父類的方法進行重寫。為了讓初學者掌握方法的重寫，本實驗將編寫一個類NewPhone，該類繼承Phone類并對Phone類的call()方法進行重寫。
4、 設計思路（實現原理）
1）定義一個類Phone，編寫方法call()，表示打電話功能
2）定義一個Phone的子類NewPhone，重寫父類call()方法，讓它除了打電話功能外還具有開啟語言和關閉語言功能。
3）編寫一個測試類Example02，分別調用重寫前和重寫后的call()方法
二、實驗實現
1、定義Phone及其子類NewPhone，子類對父類中的call()方法重寫，代碼如下：
2、定義測試類Example02，代碼如下：
package Example02;import java.util.Scanner;class Phone{public void call(){System.out.println("輸入：1.打電話");Scanner in = new Scanner(System.in);int flag = in.nextInt();if(flag == 1){System.out.println("正在打電話");}} }class NewPhone extends Phone{public void call(){System.out.println("輸入：1.打電話,2.開啟語言功能，3.關閉語言功能");Scanner in = new Scanner(System.in);int flag = in.nextInt();if(flag == 1){System.out.println("正在打電話!");}else if(flag == 2){System.out.println("開啟語言功能成功!");}else if(flag == 3){System.out.println("關閉語言功能成功!");}} }public class Example02 {public static void main(String[] args) {Phone p = new Phone();NewPhone n = new NewPhone();System.out.println("Phone類測試");p.call();System.out.println("NewPhon類測試");n.call();} }運行結果如圖3-2所示。
圖3-2 運行結果
三、實驗總結
1、子類中需要對繼承自父類的方法進行一些修改，這時就用到方法重寫。
2、在子類中重寫的方法需要和父類被重寫的方法具有相同的方法名、參數列表以及返回值類型。
3、子類方法的訪問修飾權限不能小于父類的。
4、重寫的主要優點是能夠定義子類特有的特征。
實驗3-3 super訪問父類成員變量
一、實驗描述
1、 考核知識點
名稱：super關鍵字
2、 練習目標
? 掌握使用super關鍵字訪問父類成員變量
3、 需求分析
子類可以繼承父類的非私有成員變量，如果在子類中修改了繼承自父類的成員變量的值，再想要訪問父類的該成員變量時，可以通過super.成員變量來實現。為了讓初學者熟悉super關鍵字的用法，本實驗將分別設計Fu類及其子類Zi，并在Zi類的方法中使用super關鍵字訪問Fu類的成員變量。
4、 設計思路（實現原理）
1）編寫一個Fu類，在類中定義無參構造和一個初始值為20的num成員變量。
2）Zi類繼承Fu類，在子類中對num值進行了修改，同時在子類中定義無參構造和一個無返回值的method()方法，method()方法中使用super關鍵字調用了Fu類的num成員變量。
3）定義測試類Example03。
二、實驗實現
1、編寫Fu類及其子類Zi，在Zi類中使用super關鍵字調用Fu類成員變量，代碼如下
2、定義測試類Example03，代碼如下：
package Example03;class Fu{int num = 20;public Fu(){} }class Zi extends Fu{public Zi() {}int num = 10;public void method(){System.out.println("super.num = "+super.num);} }public class Example03 {public static void main(String[] args) {Fu f = new Fu();Zi z = new Zi();System.out.println("父類中的num = "+f.num);System.out.println("子類中的num = "+z.num);z.method();} }運行結果如圖3-3所示。
圖3-3 運行結果
三、實驗總結
1、使用super關鍵字調用父類的成員方法。具體格式如下：
super.成員變量
2、被調用的父類成員變量，必須是非private的。
實驗3-4 super訪問父類成員方法
一、實驗描述
1、 考核知識點
名稱：super關鍵字
2、 練習目標
? 掌握使用super關鍵字訪問父類成員方法
3、 需求分析
子類重寫父類的方法后，子類對象將無法訪問父類被重寫的方法，為了解決這個問題，在Java中專門提供了一個super關鍵字用于訪問父類的成員。為了讓初學者熟悉super關鍵字的用法，本實驗將分別設計Fu類及其子類Zi，在Zi類的方法中使用super關鍵字訪問Fu類的成員方法。
4、 設計思路（實現原理）
1）編寫一個Fu類，在類中定義無參構造和一個無返回值的show()方法。
2）Zi類繼承Fu類，子類中定義無參構造和一個無返回值的method()方法，method()方法中使用super關鍵字調用了Fu類的show()方法。
3）定義測試類Example04。
二、實驗實現
1、編寫Fu類及其子類Zi，在Zi類中使用super關鍵字調用Fu類成員方法，代碼如下：
2、定義測試類Example04，代碼如下：
package Example04;class Fu{public Fu(){}public void show(){System.out.println("執行了Fu類show()方法");} }class Zi extends Fu {public Zi() {}public void method(){System.out.println("調用了super.show()方法");super.show();} }public class Example04 {public static void main(String[] args) {Fu f = new Fu();Zi z = new Zi();System.out.println("調用父類中的show()方法");f.show();System.out.println("調用子類中的method()方法");z.method();} }運行結果如圖3-4所示。
圖3-4 運行結果
三、實驗總結
1、使用super關鍵字調用父類的成員方法。具體格式如下：
super.成員方法([參數1,參數2…])
2、被調用的父類成員方法，必須是非private的。
實驗3-5 super訪問父類構造方法
一、實驗描述
1、 考核知識點
名稱：super關鍵字
2、 練習目標
? 掌握如何在子類構造方法中使用super關鍵字訪問父類構造方法
3、 需求分析
在子類的構造方法中一定會調用父類的某個構造方法，如果想指定調用類父類中的哪個構造方法，可以使用super關鍵字來實現。為了讓初學者掌握super關鍵字的用法，本實驗將分別設計Fu類及其子類Zi，在Zi類的構造方法中使用super關鍵字訪問Fu類的構造方法。
4、 設計思路（實現原理）
1）編寫一個Fu類，在類中定義無參構造。
2）Zi類繼承Fu類，子類中也定義無參構造方法，在構造方法中使用super關鍵字調用Fu類的構造方法。
3）定義測試類Example05。
二、實驗實現
1、編寫Fu類及其子類Zi，在Zi類構造中使用super關鍵字調用Fu類構造方法，代碼如下：
2、定義測試類Example05，代碼如下：
package Example05;class Fu{public Fu(){System.out.println("調用了Fu類的構造方法。。。");} }class Zi extends Fu {public Zi() {super();System.out.println("調用了Zi類的構造方法。。。");} }public class Example05 {public static void main(String[] args) {System.out.println("實例化Fu對象");Fu f = new Fu();System.out.println("實例化Zi對象");Zi z = new Zi();} }運行結果如圖3-5所示。
圖3-5 運行結果
三、實驗總結
1、通過super調用父類構造方法的代碼必須位于子類構造方法的第一行，并且只能出現一次。
2、在子類的構造方法中通過super指定調用父類的哪個構造方法，如果沒有指定，在實例化子類對象時，會自動調用父類無參的構造方法。
3、被調用的父類構造方法，必須是非private的。
實驗3-6 final修飾類
一、實驗描述
1、 考核知識點
名稱：final關鍵字
2、 練習目標
? 了解final關鍵字修飾類的特點
? 掌握final關鍵字修飾類的用法
3、 需求分析
Java中的類被final關鍵字修飾后，該類將不可以被繼承，也就是不能夠派生子類。為了讓初學者熟悉final關鍵字修飾類的用法，本實驗將分別設計兩個類，一個是使用final關鍵字修飾的Fu類，另一個是繼承Fu類的Zi類，驗證final關鍵字修飾的類是否能被繼承。
4、 設計思路（實現原理）
1）編寫一個final關鍵字修飾的Fu類，類體可以為空
2）編寫Zi類，Zi類繼承于Fu類，類體可以為空
3）定義測試類Example06。
二、實驗實現
1、編寫final修飾的Fu類，Zi類繼承Fu類，代碼如下：
2、定義測試類Example06，代碼如下：
package Example06;final class Fu{public Fu(){System.out.println("調用了Fu類的構造方法。。。");} }class Zi extends Fu {public Zi() {System.out.println("調用了Zi類的構造方法。。。");} }public class Example06 {public static void main(String[] args) {System.out.println("實例化Fu對象");Fu f = new Fu();System.out.println("實例化Zi對象");Zi z = new Zi();} }運行結果如圖3-6所示。
圖3-6 運行結果
三、實驗總結
在Java中，被final關鍵字修飾的類為最終類，不能被其它類繼承。
實驗3-7 final修飾方法
一、實驗描述
1、 考核知識點
名稱：final關鍵字
2、 練習目標
? 掌握使用final關鍵字修飾方法
3、 需求分析
子類可以繼承父類的成員方法，并在必要時對方法進行重寫，增加了方法的擴展的同時也打破了方法的封裝，如果我們希望父類中的某些方法不能被重寫，這時就可以使用final關鍵字來修飾。為了讓初學者掌握使用final關鍵字修飾方法，本實驗將分別設計兩個類，一個是Fu類，其中定義了final修飾的show()方法，另一個是繼承Fu類的Zi類，在Zi類中對show()方法進行重寫。
4、 設計思路（實現原理）
1）編寫一個Fu類，類中定義final修飾的show()方法。
2）編寫Zi類，Zi類繼承于Fu類，在Zi類中對show()方法進行重寫
3）定義測試類Example07，創建Zi類對象，并調用Zi類show()方法。
二、實驗實現
1、編寫Fu類及其子類Zi類，在Zi類中對show()方法重寫，代碼如下：
2、定義測試類Example07，代碼如下：
package Example07;class Fu{public Fu(){System.out.println("調用了Fu類的構造方法。。。");}public final void show(){System.out.println("執行了Fu類show()方法");} }class Zi extends Fu {public Zi() {System.out.println("調用了Zi類的構造方法。。。");}public void show(){System.out.println("執行了Zi類show()方法");} }public class Example07 {public static void main(String[] args) {System.out.println("實例化Fu對象");Fu f = new Fu();System.out.println("實例化Zi對象");Zi z = new Zi();System.out.println("調用Zi類的show()方法");z.show();} }運行結果如圖3-7所示。
圖3-7 運行結果
三、實驗總結
當一個類的方法被final關鍵字修飾后，這個類的子類將不能重寫該方法。
實驗3-8 final修飾局部變量
一、實驗描述
1、 考核知識點
名稱：final關鍵字
2、 練習目標
? 掌握使用final關鍵字修飾局部變量
3、 需求分析
Java中被final修飾的變量為常量，它只能被賦值一次，也就是說final修飾的變量一旦被賦值，其值不能改變。為了讓初學者掌握使用final關鍵字修飾局部變量，本實驗將在類的方法中定義一個final修飾的局部變量，并試著對該變量重新賦值。
4、 設計思路（實現原理）
1）編寫一個Example08類，類中定義類一個final修飾的局部變量age，為其賦初始值為18。
2）為age重新賦值為20。
二、實驗實現
1、編寫類Example08，代碼如下
編譯錯誤，如圖3-8所示。
圖3-8 錯誤提示
三、實驗總結
final修飾的變量表示常量，一經定義就不能重新賦值。
實驗3-9 final修飾成員變量
一、實驗描述
1、 考核知識點
名稱：final關鍵字
2、 練習目標
? 掌握使用final關鍵字修飾成員變量
3、 需求分析
在Java中，final修飾的變量表示常量，一經定義就不能重新賦值。為了讓初學者熟悉final修飾變量的情況，本實驗將使用final關鍵字修飾成員變量，觀察其是否能夠再次賦值。
4、 設計思路（實現原理）
1）編寫一個Fu類，父類中定義一個變量X，并用final關鍵字修飾變量。
2）編寫Zi類，Zi類繼承于Fu類，在子類中對常量再賦新值。
3）定義測試類Example09，觀察運行結果。
二、實驗實現
1、編寫Fu類及其子類Zi類，在Zi類中對X再賦值，代碼如下：
2、定義測試類Example09，代碼如下：
package Example09;class Fu{public final int x = 12; }class Zi extends Fu {public void show(){x = 11;System.out.println(x);} }public class Example09 {public static void main(String[] args) {Fu f = new Fu();Zi z = new Zi();z.show();} }編譯錯誤，結果如圖3-9所示。
圖3-9 錯誤提示
三、實驗總結
在本實驗中Zi類中對變量X再次賦值，運行結果報錯。這是因為Java中被final修飾的變量為常量，它只能被賦值一次，也就是說final修飾的變量一旦被賦值，其值不能改變。如果再次對該變量進行賦值，則程序會在編譯時報錯。
實驗3-10 接口的實現
一、實驗描述
1、 考核知識點
名 稱：接口
2、 練習目標
? 掌握如何實現接口
3、 需求分析
由于接口中的方法都是抽象方法，因此不能通過實例化對象的方式來調用接口中的方法。此時需要定義一個類，并使用implements關鍵字實現接口中所有的方法。為了讓初學者掌握如何實現接口，本實驗將設計一個類，使用關鍵字implements實現Inter接口中的方法。
4、 設計思路（實現原理）
1）設計名為Inter的接口，接口中定義一個初始值為20的num常量和method()抽象方法。
2）編寫Inter接口的實現類InterImpl，使用implements關鍵字實現接口中的方法。
3）編寫測試類Example10，測試類中對接口的實現類進行實例化，并調用接口中的方法。
二、實驗實現
1、編寫接口Inter，InterImpl類使用implements實現了接口，代碼如下：
2、定義測試類Example10，代碼如下：
package Example10;interface Inter{int num = 20;void method(); }class InterImpl implements Inter{public void method() {System.out.println("調用了在InterImpl類里實現的Inter接口里的method()方法");} }public class Example10 {public static void main(String[] args) {InterImpl i = new InterImpl();System.out.println("Inter里的num = " + i.num);i.method();} }運行結果如圖3-10所示。
圖3-10 運行結果
三、實驗總結
1、接口使用interface關鍵字來定義。
2、接口沒有構造方法，接口中的變量缺省都是使用public static final修飾的，即全局常量，接口中的方法都是public abstract修飾的，即抽象方法。
3、定義一個類，并使用implements關鍵字實現接口中的方法，一個類可以實現多個接口。
4、由于接口中的方法都是抽象方法，因此不能直接通過實例化對象的方式來調用接口中的方法，需要在類實現接口后借助類來間接實例化。
實驗3-11 接口的繼承
一、實驗描述
1、 考核知識點
名 稱：接口的繼承與多實現
2、 練習目標
? 掌握接口繼承的方式及其特點
3、 需求分析
在程序中，可以定義一個接口使用extends關鍵字去繼承另一個接口。為了加深初學者對結果的理解，本實驗將演示接口與接口、類與接口的繼承和實現關系。
4、 設計思路（實現原理）
1）設計接口Phone代表傳統手機，在接口中定義receiveMessages()和call()抽象方法。
2）設計接口SmartPhone代表智能手機，在接口中定義faceTime()方法，并使用extends關鍵字繼承Phone接口，使其具有Phone接口的所有功能。
3）設計類MIPhone表示小米手機，類中定義useMIUI()方法，并實現SmartPhone接口的所有方法。
4）編寫測試類Example11，測試類中對MIPhone進行實例化，并訪問小米手機具有的各種功能。
二、實驗實現
1、編寫接口Phone和SmartPhone、類MIPhone。代碼如下：
運行結果如圖3-11所示。
圖3-11 運行結果
三、實驗總結
接口與接口之間的繼承關系，可以是單繼承，也可以是多繼承；一個接口可以通過extends關鍵字繼承多個接口，接口之間用逗號隔開。
實驗3-12 Object類
一、實驗描述
1、 考核知識點
名 稱：Object類
2、 練習目標
? 了解什么是Object類
? 掌握Object類中常用方法的使用
3、 需求分析
在JDK中提供了一個Object類，它是所有類的父類，即每個類都直接或間接繼承自該類。Object類自身的equals()方法比較的是內存地址值，相當于“”，但是在實際開發中我們很少比較兩個對象的地址值，這時候常常就需要根據自身需求來重寫equals()方法。為了方便初學者學習Object類，本實驗將演示如何重寫equals()方法。
4、 設計思路（實現原理）
1）設計Student類，定義sid變量表示學號，重寫equals()方法，判斷進行比較的兩個學生對象學號是否相同，相同即為同一個學生，否則不是。
2）編寫測試類Example12，創建兩個Student的對象Lily和Lucy，并分別調用setter方法為學號賦值，最后通過打印語句，輸出這兩個對象通過“”和重寫后的equals()方法比較后的結果。
二、實驗實現
1、編寫Student類，重寫equals()方法。代碼如下：
2、定義測試類Example12，為學號賦值，并打印使用“==”和重寫equals()方法的比較結果，代碼如下：
package Example12;class Student{private int sid;public void setter(int sid){this.sid = sid;}public boolean equals(Student s){if(this.sid == s.sid) return true;else return false;} }public class Example12 {public static void main(String[] args) {Student Lily = new Student();Student Lucy = new Student();Lily.setter(123456);Lucy.setter(123456);System.out.println("Lily 和 Lucy 的學號均為 123456");System.out.println("Lily.equals(Lucy) = "+Lily.equals(Lucy));System.out.println("Lily == Lucy = "+(Lily == Lucy));} }運行結果如圖3-12所示。
圖3-12 運行結果
三、實驗總結
1、Object類是Java中所有類的父類，每個類都直接或間接繼承自該類。
2、Object類中的equals()方法比較的是內存地址值，和“==”比較結果一致。底層代碼如下：
public boolean equals(Object obj) {
return (this == obj);
}
實際開發中很少比較內存地址值，所以我們常常會根據自身需求重寫equals()方法。
實驗3-13 多態的作用
一、實驗描述
1、 考核知識點
名 稱：多態
2、 練習目標
? 了解多態的概念、多態的好處和弊端
? 掌握如何實現多態
3、 需求分析
在Java中為了實現多態，允許使用一個父類類型的變量來引用一個子類類型的對象，根據被引用子類對象特征的不同，得到不同的運行結果。多態提高代碼了的擴展性和可維護性。為了幫助初學者掌握如何實現多態，本實驗將實現一個多態程序來演示如何實現多態。
4、 設計思路（實現原理）
1）編寫Animal接口，接口中定義sleep()方法。
2）Cat類實現Animal接口的方法，并定義另一個方法catchMouse()
3）編寫測試類Example13，使Cat對象指向父類Animal的引用 ，并通過該引用調用sleep()方法。
二、實驗實現
1、編寫Animal接口及其實現類Cat。代碼如下：
2、定義測試類Example13，Cat對象指向Animal引用，并使用父類Animal引用調用sleep()方法。代碼如下：
package Example13;interface Animal{void sleep(); }class Cat implements Animal{public void sleep(){System.out.println("調用了sleep()方法。。。");}public void catchMouse(){System.out.println("調用了catchMouse()方法。。。");} }public class Example13 {public static void main(String[] args) {Animal c = new Cat();c.sleep();} }運行結果如圖3-13所示。
圖3-13 運行結果
三、實驗總結
1、多態是指對象在不同時刻表現出來的不同狀態，在Java中，允許使用一個父類類型的變量來引用一個子類類型的對象。
2、多態的前提：
(1) 要有繼承關系。
(2) 要有方法重寫。
(3) 要有父類引用指向子類對象。
3、多態的好處是提高代碼的擴展性和可維護性。
4、多態的弊端是父類或者接口只能調用自己具備的成員，不能訪問子類特有的成員。
實驗3-14 對象的類型轉換
一、實驗描述
1、 考核知識點
名 稱：對象的類型轉換
2、 練習目標
? 掌握如何實現對象的類型轉換
3、 需求分析
在多態的學習中，涉及到將子類對象當做父類類型使用的情況，這時進行強制類型轉換可能會出現出錯。為了讓初學者熟悉對象的類型轉換，本實驗將演示一個子類與父類之間類型轉換過程中出現的錯誤。
編寫一個接口Animal，接口中定義sleep()方法，編寫兩個類Cat和Pig分別實現接口，再編寫一個測試類Example14實現對象的類型轉換。
4、 設計思路（實現原理）
1）編寫Animal接口，接口中定義sleep()方法。
2）Cat類和Pig類分別實現Animal接口的方法
3）編寫測試類Example14對對象的類型進行轉換，使Cat向上轉型為Animal類型，然后再讓Animal類型轉換為Pig類型。
二、實驗實現
1、編寫Animal接口及其實現類Cat。代碼如下：
2、定義測試類Example14，Cat對象指向Animal引用，并使用父類Animal引用調用sleep()方法。代碼如下：
package Example14;interface Animal{void sleep(); }class Cat implements Animal {public void sleep(){System.out.println("調用了Cat.sleep()方法。。。");} }class Pig implements Animal {public void sleep(){System.out.println("調用了Pig.sleep()方法。。。");} }public class Example14 {public static void main(String[] args) {Animal a = new Cat();Pig p = a;p.sleep();} }運行結果如圖3-14所示。
圖3-14 錯誤提示
三、實驗總結
1、向下類型轉換時，需要注意被轉換對象的真實類型是否和需要轉換的對象類型相同，否則容易報類型轉換異常(java.lang.ClassCastException)。
2、Java提供了一個關鍵字instanceof，它可以判斷一個對象是否為某個類(或接口)的實例或者子類實例，語法格式如下：
對象(或者對象引用變量) instanceof 類(或接口)
3、進行向上類型轉換，子類對象當做父類類型使用時，不能通過父類變量去調用子類中某些方法，否則會拋出編譯異常。
實驗3-15 匿名內部類
一、實驗描述
1、 考核知識點
名 稱：匿名內部類
2、 練習目標
? 了解什么是匿名內部類
? 掌握如何使用匿名內部類
3、 需求分析
在學習接口時，如果方法的參數被定義為一個接口類型，那么就需要定義一個類來實現接口。除此之外，還可以使用匿名內部類來實現接口。為了讓初學者能更好地理解什么是匿名內部類，本實驗將演示如何實現一個匿名內部類。
4、 設計思路（實現原理）
1）設計一個Inter接口，接口中定義show()和method()方法。
2）設計一個Outer類，在類的function()方法中使用匿名內部類實現Inter接口并實例化，并調用show()和method()方法。
3）最后編寫一個測試類Example15，創建Outer的對象并調用function()方法。
二、實驗實現
1、編寫Inter接口及Outer類，使用匿名內部類實現接口并創建對象。代碼如下：
2、定義測試類Example15。代碼如下：
package Example15;interface Inter{void show();void method(); }class Outer implements Inter{public void function(){Inter in = new Inter() {@Overridepublic void show() {System.out.println("調用了Inter.show()方法。。。");}@Overridepublic void method() {System.out.println("調用了Inter.method()方法。。。");}};in.show();in.method();}@Overridepublic void show() {}@Overridepublic void method() {} }public class Example15 {public static void main(String[] args) {Outer ou = new Outer();ou.function();} }運行結果如圖3-15所示。
圖3-15 運行結果
三、實驗總結
1、匿名內部類的格式，具體如下：
new 父類(參數列表) 或 父接口(){
//匿名內部類實現部分
}
2、匿名內部類是實現接口的一種簡便寫法，在程序中不一定非要使用匿名內部類。
3、什么時候使用匿名內部類：通常在使用方法是接口類型參數，并該接口中的方法不超過三個時，可以將匿名內部類作為參數傳遞。
4、內部類：
(1) 將一個類B定義在另一個類A的里面，那么B類就稱為內部類(嵌套類)，內部類定義在成員位置上。
(2) 內部類可以直接訪問外部類中的成員，包括私有成員，而外部類要訪問內部類中的成員必須要建立內部類的對象。
實驗3-16 try…catch語句
一、實驗描述
1、 考核知識點
名 稱：try…catch和finally
2、 練習目標
? 掌握如何使用try…catch語句進行異常處理
3、 需求分析
Java中提供了一種對異常進行處理的方式——異常捕獲，異常捕獲通常使用try…catch語句。為了讓初學者熟悉try…catch語句，本實驗將演示如何使用try…catch語句處理遍歷時可能出現的數組角標越界異常。
4、 設計思路（實現原理）
1） 編寫測試類Example16，
2） 在類Example16中定義名為arr的int類型一維數組，遍歷數組輸出每次遍歷出的值，結束輸出“over”。
2）使用try…catch語句處理遍歷時可能出現的數組角標越界異常，如果出現異常輸出“角標越界”。
二、實驗實現
運行結果如圖3-16所示。
圖3-16 運行結果
三、實驗總結
1、try代碼塊中編寫可能發生異常的Java語句，catch代碼塊中編寫針對異常進行處理的代碼。在try代碼塊中，發生異常語句后面的代碼是不會被執行的。
2、可能發生多個異常時，可以使用多個try…catch或者用一個try多個catch。
3、 Throwable:是異常體系的超類.
|–Error 重大的錯誤，這個問題發生后，一般我們處理不了，一般不處理，而是要程序進行修正 。(內存溢出)
|–Exception 可以處理的問題，這個問題需要我們編寫針對性的代碼進行處理。(異常處理)
實驗3-17 finally語句
一、實驗描述
1、 考核知識點
名 稱：try…catch和finally
2、 練習目標
? 掌握如何使用finally語句
3、 需求分析
在程序中，有時候我們希望有些語句無論程序是否發生異常都要執行，這時就可以在try…catch語句后，加一個finally代碼塊。為了讓初學者熟悉finally代碼塊，本實驗將演示如何使用finally語句來保證不論是否異常都輸出一句話。
4、 設計思路（實現原理）
1） 編寫Example17類
2） 在main方法中使用try…catch…finally…語句，其中try語句塊中編寫可能發生異常的語句10/0，如果不異常輸出“程序繼續”，如果異常在catch語句塊中會輸出“出異常類”
3） 在finally語句塊中輸出“釋放資源”，保證保證不論是否異常一定輸出此語句
二、實驗實現
運行結果如圖3-17所示。
圖3-17 錯誤提示
三、實驗總結
無論是否發生異常，finally代碼塊是一定會執行的。但是需要注意的是，finally中的代碼塊在一種情況下不會執行，那就是在執行到finally語句之前執行了System.exit(0)語句。
實驗3-18 throws關鍵字
一、實驗描述
1、 考核知識點
名 稱：throws關鍵字
2、 練習目標
? 掌握如何使用throws關鍵字
3、 需求分析
Java中允許在方法的后面使用throws關鍵字對外聲明該方法有可能發生的異常，這樣調用者在調用方法時，就明確地知道該方法有異常，并且必須在程序中對異常進行處理，否則編譯無法通過。為了讓初學者熟悉throws關鍵字，本實驗將演示如何使用throws關鍵字。
4、 設計思路（實現原理）
1） 編寫一個類Example18
2） 在該類中定義方法div()用于進行除法運算，運算前對被除數進行判斷，如果等于0，使用throws拋出異常對象，否則進行正常的除法運算。
3） 由于throw拋出了非運行時異常，為了保證編譯通過，我們需要在方法名后面使用throws聲明拋出異常類。
2）在main方法中調用div()方法，并通過try…catch…語句處理拋出的異常。
二、實驗實現
運行結果如圖3-18所示。
圖3-18 運行結果
三、實驗總結
1、throws關鍵字聲明拋出異常的語法格式如下：
修飾符 返回值類型 方法名([參數1，參數2…])throws ExceptionType1[,ExceptionType2…]{
}
2、throws關鍵字需要寫在方法聲明的后面，throws后面需要聲明方法中發生異常的類型，通常將這種做法稱為方法聲明拋出一個異常。
實驗3-19 自定義異常
一、實驗描述
1、 考核知識點
名 稱：自定義異常
2、 練習目標
? 掌握如何自定義異常
3、 需求分析
Java中定義的異常有限，如果想描述程序中特有的異常情況，就需要自定義異常。為了讓初學者熟悉自定義異常，本實驗將自定義一個名為MyException的異常類來演示如何自定義異常。
4、 設計思路（實現原理）
1）自定義名為MyException的異常類，繼承自Exception類。
2）在Example19類中進行除法運算，判斷當除數為零時，拋出自定義的異常類
3）在main()方法中處理異常。
二、實驗實現
1、編寫自定義異常類，代碼如下：
2、拋出異常和處理異常，代碼如下：
package Example19;class MyException extends Exception{public MyException(){super();}public MyException(String message){super(message);} }public class Example19 {public static int div(int a,int b) throws MyException{MyException e = new MyException("除數為零");if(b == 0) throw e;return a/b;}public static void main(String[] args) {try{int x = div(10,0);System.out.println(x);} catch (MyException e) {System.out.println("捕獲的異常是："+e.getMessage());}} }運行結果如圖3-19所示。
圖3-19 運行結果
三、實驗總結
1、在Java中允許用戶自定義異常，但自定義的異常類必須繼承自Exception或其子類。
2、throw關鍵字用于在方法中聲明拋出異常的實例對象，其語法格式如下：
throw Exception異常對象
3、main()方法中，定義了一個try…catch語句用于捕獲divide()方法拋出的異常。在調用divide()方法時由于傳入的被除數不能為零，程序會拋出一個自定義異常MyException，該異常被捕獲后最終被catch代碼塊處理，并打印出異常信息。
實驗3-20 import引入指定類
一、實驗描述
1、 考核知識點
名 稱：import語句
2、 練習目標
? 掌握如何使用import引入指定類
3、 需求分析
不同包下的類互相調用時，一般會使用import關鍵字引入包。為了方便初學者的學習，本實驗將演示如何使用import引入指定類。
4、 設計思路（實現原理）
1） 在D:\samplePackage\chapter04 文件夾下新建Student.java文件
2） 打開文件編寫Student類，類中定義int類型的變量sid，String類型的變量name和double類型的變量score，分別表示學生id，學生姓名和分數。
2）Student類定義構造器及一個evaluation()方法，該方法用于評定學生是否為三好學生，得分大于90分為三好學生，否則為普通學生。Student類編譯后位于cn.itcast.domain包下。
3）在D:\samplePackage\chapter04 文件夾下新建Example20.java文件，打開文件編寫Example20類，在main方法中使用有參構造創建Student類的對象并調用evaluation()方法
4）Example20類編譯后位于cn.itcast.example包下，在類中使用import cn.itcast.domain.Student;引入Student類。
二、實驗實現
1、編寫Student類，該類位于cn.itcast.domain包下，代碼如下所示：
2、編寫Example20類，該類位于cn.itcast.example包下，代碼如下所示：
package cn.itcast.example; import cn.itcast.domain.Student;public class Example20 {public static void main(String[] args) {Student s = new Student(123456,"李明",91);s.evaluation();} }運行結果如圖3-20所示。
圖3-20 運行結果
三、實驗總結
1、當處于不同包下的類互相調用時，需要使用被調用類的完整類名，即包名加上類名。為了簡化代碼，Java中提供了import關鍵字，用于引入某個指定包下的類。
2、import通常出現在package語句之后，類定義之前。
3、當需要引入同一包下的多個類時，可以使用“import包名.*;”的方式，引入包下所有的類。
總結
以上是生活随笔為你收集整理的Java实验03 面向对象（下）的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Ubuntu 20.04 安装 Apac
- 下一篇： 盘点Python的6个优势与特点