JAVA面向對象（下）

實驗三 面向對象（下）

實驗3-1  類的繼承

1、實驗描述

一、 考覈知識點

名稱：類的繼承

二、 練習目標

• 瞭解類繼承的意義和做用
• 掌握如何實現類的繼承

三、 需求分析

在程序中，繼承描述的是事物之間的所屬關係，經過繼承可使多種事物之間造成一種關係體系。

爲了讓初學者熟悉類的繼承，本實驗將演示類的繼承並編寫測試類驗證子類是否擁有父類的可繼承成員。

四、 設計思路（實現原理）

1）設計兩個類Student和Teacher

2）抽取兩個類共同的內容（如：吃飯、睡覺）封裝到一個類Person中，各自特有的部分保留在各自類中。

3）讓學生類繼承Person類，老師類也繼承Person。

4）編寫測試類Example01，測試Student類和Teacher是否繼承了Person類的成員。

 

2、實驗實現

1、抽取父類Person，實現繼承關係，代碼以下：

class Person{

int times;

void speak(){

System.out.println("我天天吃"+times+"次飯");

}

}

class Teacher extends Person{

String teacher="老師";

void speakt(){

System.out.println("我是"+teacher);

}

}

class Student extends Person{

String student="學生";

void speaks(){

System.out.println("我是"+student);

}

}

2、定義測試類Example01，代碼以下：

public class Example301 {

public static void main(String[] args) {

Student stu=new Student();

Teacher t=new Teacher();

stu.times=3;

stu.speaks();

stu.speak();

t.times=2;

t.speakt();

t.speak();

}

 

}

運行結果如圖3-1所示。

 

 

 

圖3-1 運行結果

3、實驗總結

1、在Java中，多個類能夠繼承一個父類，可是一個類不能直接繼承多個類，一個類只能有一個直接父類。

2、父類是由子類不斷抽取而來的，不斷地抽取就造成了體系結構，這個結構稱爲繼承體系結構。

3、子類在繼承父類的時候，會自動擁有父類全部的成員。

4、繼承的好處是劃分了類的層次性，實現了代碼重用、擴展了程序功能。

實驗3-2  方法的重寫

1、實驗描述

一、 考覈知識點

名稱：方法的重寫

二、 練習目標

• 瞭解方法重寫的意義和做用
  • 掌握如何進行方法重寫

三、 需求分析

在繼承關係中，子類會自動繼承父類中定義的方法，但有時在子類中須要對繼承的方法進行一些

修改，即對父類的方法進行重寫。爲了讓初學者掌握方法的重寫，本實驗將編寫一個類NewPhone，該類繼承Phone類並對Phone類的call()方法進行重寫。

四、 設計思路（實現原理）

1）定義一個類Phone，編寫方法call()，表示打電話功能

   2）定義一個Phone的子類NewPhone，重寫父類call()方法，讓它除了打電話功能外還具備開啓語言和關閉語言功能。

   3）編寫一個測試類Example02，分別調用重寫前和重寫後的call()方法

2、實驗實現

1、定義Phone及其子類NewPhone，子類對父類中的call()方法重寫，代碼以下：

class Phone{

void call(){

System.out.println("能夠打電話");

}

}

class NewPhone extends Phone{

void call(){

super.call();

System.out.println("開啓語音");

System.out.println("關閉語音");

}

}

2、定義測試類Example02，代碼以下：

public class Example402 {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

System.out.println("重寫以前：");

Phone phone=new Phone();

phone.call();

System.out.println("重寫以後：");

NewPhone n=new NewPhone();

n.call();

}

 

}

運行結果如圖3-2所示

 

 

圖3-2 運行結果

3、實驗總結

1、子類中須要對繼承自父類的方法進行一些修改，這時就用到方法重寫。

2、在子類中重寫的方法須要和父類被重寫的方法具備相同的方法名、參數列表以及返回值類型。

3、子類方法的訪問修飾權限不能小於父類的。

4、重寫的主要優勢是可以定義子類特有的特徵。

實驗3-3  super訪問父類成員變量

1、實驗描述

一、 考覈知識點

名稱：super關鍵字

二、 練習目標

• 掌握使用super關鍵字訪問父類成員變量

三、 需求分析

子類能夠繼承父類的非私有成員變量，若是在子類中修改了繼承自父類的成員變量的值，再想要訪問父類的該成員變量時，能夠經過super.成員變量來實現。爲了讓初學者熟悉super關鍵字的用法，本實驗將分別設計Fu類及其子類Zi，並在Zi類的方法中使用super關鍵字訪問Fu類的成員變量。

四、 設計思路（實現原理）

1）編寫一個Fu類，在類中定義無參構造和一個初始值爲20的num成員變量。

   2）Zi類繼承Fu類，在子類中對num值進行了修改，同時在子類中定義無參構造和一個無返回值的method()方法，method()方法中使用super關鍵字調用了Fu類的num成員變量。

   3）定義測試類Example03。

 

2、實驗實現

1、編寫Fu類及其子類Zi，在Zi類中使用super關鍵字調用Fu類成員變量，代碼以下

class Fu{

int num=20;

public  Fu(){

 

}

}

class Zi extends Fu{

int num=10;

public Zi(){

 

}

public void method(){

System.out.println(super.num);

}

}

2、定義測試類Example03，代碼以下：

public class Example403 {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

Zi z=new Zi();

z.method();

}運行結果如圖3-3所示。

 

 

圖3-3 運行結果

3、實驗總結

1、使用super關鍵字調用父類的成員方法。具體格式以下：

super.成員變量

2、被調用的父類成員變量，必須是非private的。

實驗3-4  super訪問父類成員方法

1、實驗描述

一、 考覈知識點

名稱：super關鍵字

二、 練習目標

• 掌握使用super關鍵字訪問父類成員方法

三、 需求分析

子類重寫父類的方法後，子類對象將沒法訪問父類被重寫的方法，爲了解決這個問題，在Java中專門提供了一個super關鍵字用於訪問父類的成員。爲了讓初學者熟悉super關鍵字的用法，本實驗將分別設計Fu類及其子類Zi，在Zi類的方法中使用super關鍵字訪問Fu類的成員方法。

四、 設計思路（實現原理）

1）編寫一個Fu類，在類中定義無參構造和一個無返回值的show()方法。

   2）Zi類繼承Fu類，子類中定義無參構造和一個無返回值的method()方法，method()方法中使用super關鍵字調用了Fu類的show()方法。

   3）定義測試類Example04。

2、實驗實現

1、編寫Fu類及其子類Zi，在Zi類中使用super關鍵字調用Fu類成員方法，代碼以下：

class Fu{

public  Fu(){

}

public void show(){

System.out.println("父類的方法被調用");

}

}

class Zi extends Fu{

public Zi(){

 

}

public void method(){

super.show();

}

}

2、定義測試類Example04，代碼以下：

public class Example404 {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

Zi z=new Zi();

z.method();

}

 

}

運行結果如圖3-4所示。

 

圖3-4 運行結果

3、實驗總結

1、使用super關鍵字調用父類的成員方法。具體格式以下：

super.成員方法([參數1,參數2…])

2、被調用的父類成員方法，必須是非private的。

實驗3-5  super訪問父類構造方法

1、實驗描述

一、 考覈知識點

名稱：super關鍵字

二、 練習目標

• 掌握如何在子類構造方法中使用super關鍵字訪問父類構造方法

三、 需求分析

在子類的構造方法中必定會調用父類的某個構造方法，若是想指定調用類父類中的哪一個構造方法，可使用super關鍵字來實現。爲了讓初學者掌握super關鍵字的用法，本實驗將分別設計Fu類及其子類Zi，在Zi類的構造方法中使用super關鍵字訪問Fu類的構造方法。

四、 設計思路（實現原理）

1）編寫一個Fu類，在類中定義無參構造。

   2）Zi類繼承Fu類，子類中也定義無參構造方法，在構造方法中使用super關鍵字調用Fu類的構造方法。

   3）定義測試類Example05。

2、實驗實現

1、編寫Fu類及其子類Zi，在Zi類構造中使用super關鍵字調用Fu類構造方法，代碼以下：

 class Fu{

public  Fu(){

System.out.println("父類構造方法被訪問");

}

}

class Zi extends Fu{

public Zi(){

super();

}

}

2、定義測試類Example05，代碼以下：

 

public class Example405{

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

Zi z=new Zi();

}

 

運行結果如圖3-5所示。

 

 

圖3-5 運行結果

3、實驗總結

1、經過super調用父類構造方法的代碼必須位於子類構造方法的第一行，而且只能出現一次。

2、在子類的構造方法中經過super指定調用父類的哪一個構造方法，若是沒有指定，在實例化子類對象時，會自動調用父類無參的構造方法。

3、被調用的父類構造方法，必須是非private的。

實驗3-6  final修飾類

1、實驗描述

一、 考覈知識點

名稱：final關鍵字

二、 練習目標

• 瞭解final關鍵字修飾類的特色
• 掌握final關鍵字修飾類的用法

三、 需求分析

Java中的類被final關鍵字修飾後，該類將不能夠被繼承，也就是不可以派生子類。爲了讓初學者熟悉final關鍵字修飾類的用法，本實驗將分別設計兩個類，一個是使用final關鍵字修飾的Fu類，另外一個是繼承Fu類的Zi類，驗證final關鍵字修飾的類是否能被繼承。

四、 設計思路（實現原理）

1）編寫一個final關鍵字修飾的Fu類，類體能夠爲空

   2）編寫Zi類，Zi類繼承於Fu類，類體能夠爲空

   3）定義測試類Example06。

2、實驗實現

1、編寫final修飾的Fu類，Zi類繼承Fu類，代碼以下：

final class  Fu{

 

}

class Zi extends Fu{

 

 

}

2、定義測試類Example06，代碼以下：

public class Example406{

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

Zi z=new Zi();

}

 

}

運行結果如圖3-6所示。

 

 

圖3-6 運行結果

3、實驗總結

在Java中，被final關鍵字修飾的類爲最終類，不能被其它類繼承。

實驗3-7  final修飾方法

1、實驗描述

一、 考覈知識點

名稱：final關鍵字

二、 練習目標

• 掌握使用final關鍵字修飾方法

三、 需求分析

子類能夠繼承父類的成員方法，並在必要時對方法進行重寫，增長了方法的擴展的同時也打破了方法的封裝，若是咱們但願父類中的某些方法不能被重寫，這時就可使用final關鍵字來修飾。爲了讓初學者掌握使用final關鍵字修飾方法，本實驗將分別設計兩個類，一個是Fu類，其中定義了final修飾的show()方法，另外一個是繼承Fu類的Zi類，在Zi類中對show()方法進行重寫。

四、 設計思路（實現原理）

1）編寫一個Fu類，類中定義final修飾的show()方法。

   2）編寫Zi類，Zi類繼承於Fu類，在Zi類中對show()方法進行重寫

   3）定義測試類Example07，建立Zi類對象，並調用Zi類show()方法。

2、實驗實現

1、編寫Fu類及其子類Zi類，在Zi類中對show()方法重寫，代碼以下：

 

 class Fu{

public final void show(){

System.out.println("父類方法被訪問");

}

}

class Zi extends Fu{

public void show(){

 

}

2、定義測試類Example07，代碼以下：

public class Example407 {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

Zi z=new Zi();

z.show();

}

運行結果如圖3-7所示。

 

 

圖3-7 運行結果

3、實驗總結

當一個類的方法被final關鍵字修飾後，這個類的子類將不能重寫該方法。

實驗3-8  final修飾局部變量

1、實驗描述

一、 考覈知識點

名稱：final關鍵字

二、 練習目標

• 掌握使用final關鍵字修飾局部變量

三、 需求分析

Java中被final修飾的變量爲常量，它只能被賦值一次，也就是說final修飾的變量一旦被賦值，其值不能改變。爲了讓初學者掌握使用final關鍵字修飾局部變量，本實驗將在類的方法中定義一個final修飾的局部變量，並試着對該變量從新賦值。

四、 設計思路（實現原理）

1）編寫一個Example08類，類中定義類一個final修飾的局部變量age，爲其賦初始值爲18。

   2）爲age從新賦值爲20。

2、實驗實現

1、編寫類Example08，代碼以下

public class Example408{

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

 final int age=20;

 int age=18;

System.out.println(age);

}

}

編譯錯誤，如圖3-8所示。

 

 

圖3-8 錯誤提示

3、實驗總結

final修飾的變量表示常量，一經定義就不能從新賦值。

 

實驗3-9  final修飾成員變量

1、實驗描述

一、 考覈知識點

名稱：final關鍵字

二、 練習目標

• 掌握使用final關鍵字修飾成員變量

三、 需求分析

在Java中，final修飾的變量表示常量，一經定義就不能從新賦值。爲了讓初學者熟悉final修飾變量的狀況，本實驗將使用final關鍵字修飾成員變量，觀察其是否可以再次賦值。

四、 設計思路（實現原理）

1）編寫一個Fu類，父類中定義一個變量X，並用final關鍵字修飾變量。

   2）編寫Zi類，Zi類繼承於Fu類，在子類中對常量再賦新值。

   3）定義測試類Example09，觀察運行結果。

2、實驗實現

1、編寫Fu類及其子類Zi類，在Zi類中對X再賦值，代碼以下：

class Fu{

final int X=50;

 

}

class Zi extends Fu{

int X=20;

}

2、定義測試類Example09，代碼以下：

public class Example409 {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

Zi zi=new Zi();

System.out.println(X);

}

 

}

編譯錯誤，結果如圖3-9所示。

 

 

圖3-9 錯誤提示

3、實驗總結

在本實驗中Zi類中對變量X再次賦值，運行結果報錯。這是由於Java中被final修飾的變量爲常量，它只能被賦值一次，也就是說final修飾的變量一旦被賦值，其值不能改變。若是再次對該變量進行賦值，則程序會在編譯時報錯。

實驗3-10  接口的實現

1、實驗描述

一、 考覈知識點

名 稱：接口

二、 練習目標

• 掌握如何實現接口

三、 需求分析

因爲接口中的方法都是抽象方法，所以不能經過實例化對象的方式來調用接口中的方法。此時須要定義一個類，並使用implements關鍵字實現接口中全部的方法。爲了上初學者掌握如何實現接口，本實驗將設計一個類，使用關鍵字implements實現Inter接口中的方法。

四、 設計思路（實現原理）

1）設計名爲Inter的接口，接口中定義一個初始值爲20的num常量和method()抽象方法。

   2）編寫Inter接口的實現類InterImpl，使用implements關鍵字實現接口中的方法。

   3）編寫測試類Example10，測試類中對接口的實現類進行實例化，並調用接口中的方法。

2、實驗實現

1、編寫接口Inter，InterImpl類使用implements實現了接口，代碼以下：

 

interface Inter{

int num=20;

abstract void method();

}

 class InterImpl implements Inter{

 

public void method() {

System.out.println("定義的num是"+num);

}

2、定義測試類Example10，代碼以下：

public class shiyan410 {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

InterImpl I=new InterImpl();

I.method();

 

}

 

}

運行結果如圖3-10所示。

 

 

 

圖3-10 運行結果

3、實驗總結

1、接口使用interface關鍵字來定義。

2、接口沒有構造方法，接口中的變量缺省都是使用public static final修飾的，即全局常量，接口中的方法都是public abstract修飾的，即抽象方法。

3、定義一個類，並使用implements關鍵字實現接口中的方法，一個類能夠實現多個接口。

4、因爲接口中的方法都是抽象方法，所以不能直接經過實例化對象的方式來調用接口中的方法，須要在類實現接口後藉助類來間接實例化。

實驗3-11  接口的繼承

1、實驗描述

一、 考覈知識點

名 稱：接口的繼承與多實現

二、 練習目標

• 掌握接口繼承的方式及其特色

三、 需求分析

在程序中，能夠定義一個接口使用extends關鍵字去繼承另外一個接口。爲了加深初學者對結果的理解，本實驗將演示接口與接口、類與接口的繼承和實現關係。

四、 設計思路（實現原理）

1）設計接口Phone表明傳統手機，在接口中定義receiveMessages()和call()抽象方法。

   2）設計接口SmartPhone表明智能手機，在接口中定義faceTime()方法，並使用extends關鍵字繼承Phone接口，使其具備Phone接口的全部功能。

3）設計類MIPhone表示小米手機，類中定義useMIUI()方法，並實現SmartPhone接口的全部方法。

   4）編寫測試類Example11，測試類中對MIPhone進行實例化，並訪問小米手機具備的各類功能。

2、實驗實現

1、編寫接口Phone和SmartPhone、類MIPhone。代碼以下：

 

public interface Phone {

String namePhone="傳統手機";

void call();

}

public interface SmartPhone extends Phone {

String nameSmartPhone="智能手機";

void faceTime();

}

class MIPhone implements SmartPhone{

String nameMI="小米手機";

public void call(){

System.out.println("能打電話");

}

void receiveMessage(){

System.out.println("收發信息");

}

public void faceTime(){

System.out.println("能視頻");

}

public void useMIUI() {

}

{

call();

receiveMessage();

faceTime();

}

}

 

 

運行結果如圖3-11所示。

 

 

 

圖3-11 運行結果

3、實驗總結

接口與接口之間的繼承關係，能夠是單繼承，也能夠是多繼承；一個接口能夠經過extends關鍵字繼承多個接口，接口之間用逗號隔開。

實驗3-12  Object類

1、實驗描述

一、 考覈知識點

名 稱：Object類

二、 練習目標

• 瞭解什麼是Object類
• 掌握Object類中經常使用方法的使用

三、 需求分析

在JDK中提供了一個Object類，它是全部類的父類，即每一個類都直接或間接繼承自該類。Object類自身的equals()方法比較的是內存地址值，至關於「==」，可是在實際開發中咱們不多比較兩個對象的地址值，這時候經常就須要根據自身需求來重寫equals()方法。爲了方便初學者學習Object類，本實驗將演示如何重寫equals()方法。

四、 設計思路（實現原理）

1）設計Student類，定義sid變量表示學號，重寫equals()方法，判斷進行比較的兩個學生對象學號是否相同，相同即爲同一個學生，不然不是。

   2）編寫測試類Example12，建立兩個Student的對象Lily和Lucy，並分別調用setter方法爲學號賦值，最後經過打印語句，輸出這兩個對象經過「==」和重寫後的equals()方法比較後的結果。

2、實驗實現

1、編寫Student類，重寫equals()方法。代碼以下：

class Student{

long sid;

public boolean equals(Object a,Object b){

if(a==b)

return true;

else return false;

}

 

}

2、定義測試類Example12，爲學號賦值，並打印使用「==」和重寫equals()方法的比較結果，代碼以下：

public class Example412 {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

Student Lily=new Student();

Student Lucy=new Student();

Lily.sid= 1667111141;

Lucy.sid=1663104630;

System.out.println(Lily.equals(Lily, Lucy));

}

}

運行結果如圖3-12所示。

 

圖3-12 運行結果

3、實驗總結

1、Object類是Java中全部類的父類，每一個類都直接或間接繼承自該類。

2、Object類中的equals()方法比較的是內存地址值，和「==」比較結果一致。底層代碼以下：

public boolean equals(Object obj) {

        return (this == obj);

    }

   實際開發中不多比較內存地址值，因此咱們經常會根據自身需求重寫equals()方法。

實驗3-13  多態的做用

1、實驗描述

一、 考覈知識點

名 稱：多態

二、 練習目標

• 瞭解多態的概念、多態的好處和弊端
• 掌握如何實現多態

三、 需求分析

在Java中爲了實現多態，容許使用一個父類類型的變量來引用一個子類類型的對象，根據被引用子類對象特徵的不一樣，獲得不一樣的運行結果。多態提升代碼了的擴展性和可維護性。爲了幫助初學者掌握如何實現多態，本實驗將實現一個多態程序來演示如何實現多態。

四、 設計思路（實現原理）

1）編寫Animal接口，接口中定義sleep()方法。

2）Cat類實現Animal接口的方法，並定義另外一個方法catchMouse()

   3）編寫測試類Example13，使Cat對象指向父類Animal的引用 ，並經過該引用調用sleep()方法。

2、實驗實現

1、編寫Animal接口及其實現類Cat。代碼以下：

interface Animal{

public void sleep();

}

class Cat implements Animal{

public void sleep(){

System.out.println("在睡覺");

}

public void catchMouse(){

System.out.println("捉耗子");

}

}

2、定義測試類Example13，Cat對象指向Animal引用，並使用父類Animal引用調用sleep()方法。代碼以下：

public class Example413 {

public static void main(String[] args) {

Animal cat=new Cat();

cat.sleep();

}

}

運行結果如圖3-13所示。

 

 

圖3-13 運行結果

3、實驗總結

1、多態是指對象在不一樣時刻表現出來的不一樣狀態，在Java中，容許使用一個父類類型的變量來引用一個子類類型的對象。

2、多態的前提：

  (1) 要有繼承關係。

  (2) 要有方法重寫。

  (3) 要有父類引用指向子類對象。

3、多態的好處是提升代碼的擴展性和可維護性。

4、多態的弊端是父類或者接口只能調用本身具有的成員，不能訪問子類特有的成員。

實驗3-14  對象的類型轉換

1、實驗描述

一、 考覈知識點

名 稱：對象的類型轉換

二、 練習目標

• 掌握如何實現對象的類型轉換

三、 需求分析

在多態的學習中，涉及到將子類對象當作父類類型使用的狀況，這時進行強制類型轉換可能會出現出錯。爲了讓初學者熟悉對象的類型轉換，本實驗將演示一個子類與父類之間類型轉換過程當中出現的錯誤。 

編寫一個接口Animal，接口中定義sleep()方法，編寫兩個類Cat和Pig分別實現接口，再編寫一個測試類Example14實現對象的類型轉換。

四、 設計思路（實現原理）

1）編寫Animal接口，接口中定義sleep()方法。

2）Cat類和Pig類分別實現Animal接口的方法

   3）編寫測試類Example14對對象的類型進行轉換，使Cat向上轉型爲Animal類型，而後再讓Animal類型轉換爲Pig類型。

2、實驗實現

1、編寫Animal接口及其實現類Cat。代碼以下：

interface Animal{

public void sleep();

}

class Pig implements Animal{

public void sleep(){

System.out.println("豬在睡覺");

}

}

class Cat implements Animal{

public void sleep(){

System.out.println("貓在睡覺");

}

}

2、定義測試類Example14，Cat對象指向Animal引用，並使用父類Animal引用調用sleep()方法。代碼以下：

public class Example413 {

public static void main(String[] args) {

Animal cat=new Cat();

cat.sleep();

Pig pig=(Pig) new Animal();

pig.sleep();

}

}

運行結果如圖3-14所示。

 

圖3-14 錯誤提示

3、實驗總結

1、向下類型轉換時，須要注意被轉換對象的真實類型是否和須要轉換的對象類型相同，不然容易報類型轉換異常(java.lang.ClassCastException)。

2、Java提供了一個關鍵字instanceof，它能夠判斷一個對象是否爲某個類(或接口)的實例或者子類實例，語法格式以下：

對象(或者對象引用變量) instanceof 類(或接口)

3、進行向上類型轉換，子類對象當作父類類型使用時，不能經過父類變量去調用子類中某些方法，不然會拋出編譯異常。

實驗3-15  匿名內部類

1、實驗描述

一、 考覈知識點

名 稱：匿名內部類

二、 練習目標

• 瞭解什麼是匿名內部類
• 掌握如何使用匿名內部類

三、 需求分析

在學習接口時，若是方法的參數被定義爲一個接口類型，那麼就須要定義一個類來實現接口。除此以外，還可使用匿名內部類來實現接口。爲了讓初學者能更好地理解什麼是匿名內部類，本實驗將演示如何實現一個匿名內部類。

四、 設計思路（實現原理）

1）設計一個Inter接口，接口中定義show()和method()方法。

2）設計一個Outer類，在類的function()方法中使用匿名內部類實現Inter接口並實例化，並調用show()和method()方法。

   3）最後編寫一個測試類Example15，建立Outer的對象並調用function()方法。

2、實驗實現

1、編寫Inter接口及Outer類，使用匿名內部類實現接口並建立對象。代碼以下：

 

interface Inter{

public void show();

public void method();

}

 

2、定義測試類Example15。代碼以下：

public class Example41 {

 

/**

 * @param args

 */

public static void main(String[] args) {

class Outer implements Inter{

 

public void show() {

System.out.println("show方法");

}

 

public void method() {

System.out.println("method方法");

 

}

}

 function(new Outer());

}

static public void function(Inter i){

i.show();

i.method();

}

}

運行結果如圖3-15所示。

 

 

圖3-15 運行結果

3、實驗總結

1、匿名內部類的格式，具體以下：

new 父類(參數列表) 或 父接口(){

    //匿名內部類實現部分

}

2、匿名內部類是實現接口的一種簡便寫法，在程序中不必定非要使用匿名內部類。

3、何時使用匿名內部類：一般在使用方法是接口類型參數，並該接口中的方法不超過三個時，能夠將匿名內部類做爲參數傳遞。

4、內部類：

(1) 將一個類B定義在另外一個類A的裏面，那麼B類就稱爲內部類(嵌套類)，內部類定義在成員位置上。

(2) 內部類能夠直接訪問外部類中的成員，包括私有成員，而外部類要訪問內部類中的成員必需要創建內部類的對象。

實驗3-16  try...catch語句

1、實驗描述

一、 考覈知識點

名 稱：try...catch和finally

二、 練習目標

• 掌握如何使用try...catch語句進行異常處理

三、 需求分析

Java中提供了一種對異常進行處理的方式——異常捕獲，異常捕獲一般使用try…catch語句。爲了讓初學者熟悉try…catch語句，本實驗將演示如何使用try...catch語句處理遍歷時可能出現的數組角標越界異常。

四、 設計思路（實現原理）

1） 編寫測試類Example16，

2） 在類Example16中定義名爲arr的int類型一維數組，遍歷數組輸出每次遍歷出的值，結束輸出「over」。

2）使用try...catch語句處理遍歷時可能出現的數組角標越界異常，若是出現異常輸出「角標越界」。

2、實驗實現

package shiyan416;

 

public class Example416 {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

 

try{

int[]arr=new int[4];

arr[0]=0;

arr[1]=1;

arr[2]=2;

arr[3]=4;

arr[4]=5;

int i;

for(i=0;i<5;i++)

System.out.println(arr[i]);

System.out.println("over!");

}catch(Exception e){

System.out.println(e.getMessage()+"角標越界");

}

 

}

 

}

運行結果如圖3-16所示。

 

 

圖3-16 運行結果

3、實驗總結

1、try代碼塊中編寫可能發生異常的Java語句，catch代碼塊中編寫針對異常進行處理的代碼。在try代碼塊中，發生異常語句後面的代碼是不會被執行的。

2、可能發生多個異常時，可使用多個try...catch或者用一個try多個catch。

3、 Throwable:是異常體系的超類.

|--Error 重大的錯誤，這個問題發生後，通常咱們處理不了，通常不處理，而是要程序進行修正 。(內存溢出)

|--Exception 能夠處理的問題，這個問題須要咱們編寫針對性的代碼進行處理。(異常處理)

 

實驗3-17  finally語句

1、實驗描述

一、 考覈知識點

名 稱：try...catch和finally

二、 練習目標

• 掌握如何使用finally語句

三、 需求分析

在程序中，有時候咱們但願有些語句不管程序是否發生異常都要執行，這時就能夠在try…catch語句後，加一個finally代碼塊。爲了讓初學者熟悉finally代碼塊，本實驗將演示如何使用finally語句來保證不管是否異常都輸出一句話。

四、 設計思路（實現原理）

1） 編寫Example17類

2） 在main方法中使用try…catch…finally…語句，其中try語句塊中編寫可能發生異常的語句10/0，若是不異常輸出「程序繼續」，若是異常在catch語句塊中會輸出「出異常類」

3） 在finally語句塊中輸出「釋放資源」，保證保證不管是否異常必定輸出此語句

2、實驗實現

package shiyan416;

 

public class Example416 {

 

/**

 * @param args

 * @return

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

 

try{

int result= Divide(10,0);

System.out.println(result);

}catch(Exception e){

System.out.println("拋出的異常是"+e.getMessage());

return;

}

finally{

System.out.println("進入finally");

}

System.out.println("程序繼續執行....");

}

 

private static int Divide(int x, int y) {

// TODO Auto-generated method stub

int result;

result=x/y;

return result;

 

}

 

}

運行結果如圖3-17所示。

 

 

圖3-17 錯誤提示

3、實驗總結

不管是否發生異常，finally代碼塊是必定會執行的。可是須要注意的是，finally中的代碼塊在一種狀況下不會執行，那就是在執行到finally語句以前執行了System.exit(0)語句。

 

實驗3-18  throws關鍵字

1、實驗描述

一、 考覈知識點

名 稱：throws關鍵字

二、 練習目標

• 掌握如何使用throws關鍵字

三、 需求分析

Java中容許在方法的後面使用throws關鍵字對外聲明該方法有可能發生的異常，這樣調用者在調用方法時，就明確地知道該方法有異常，而且必須在程序中對異常進行處理，不然編譯沒法經過。爲了讓初學者熟悉throws關鍵字，本實驗將演示如何使用throws關鍵字。

四、 設計思路（實現原理）

1） 編寫一個類Example18

2） 在該類中定義方法div()用於進行除法運算，運算前對被除數進行判斷，若是等於0，使用throws拋出異常對象，不然進行正常的除法運算。

3） 因爲throw拋出了非運行時異常，爲了保證編譯經過，咱們須要在方法名後面使用throws聲明拋出異常類。

2）在main方法中調用div()方法，並經過try…catch…語句處理拋出的異常。

2、實驗實現

package shiyan416;

 

import javax.xml.ws.handler.MessageContext;

 

public class Example416 {

 

/**

 * @param args

 * @return

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

 

try{

int result= Divide(10,0);

System.out.println(result);

}catch(Exception e){

e.printStackTrace();

}

}

 

private static int Divide(int x, int y)throws Exception{

// TODO Auto-generated method stub

if(y==0)

{

System.out.println("除數爲0");

}

int result;

result=x/y;

return result;

 

}

 

}

 

運行結果如圖3-18所示。

 

 

圖3-18 運行結果

3、實驗總結

1、throws關鍵字聲明拋出異常的語法格式以下：

修飾符 返回值類型 方法名([參數1，參數2.....])throws ExceptionType1[,ExceptionType2.....]{

}

2、throws關鍵字須要寫在方法聲明的後面，throws後面須要聲明方法中發生異常的類型，一般將這種作法稱爲方法聲明拋出一個異常。

 

實驗3-19  自定義異常

1、實驗描述

一、 考覈知識點

名 稱：自定義異常

二、 練習目標

• 掌握如何自定義異常

三、 需求分析

Java中定義的異常有限，若是想描述程序中特有的異常狀況，就須要自定義異常。爲了讓初學者熟悉自定義異常，本實驗將自定義一個名爲MyException的異常類來演示如何自定義異常。

四、 設計思路（實現原理）

1）自定義名爲MyException的異常類，繼承自Exception類。

2）在Example19類中進行除法運算，判斷當除數爲零時，拋出自定義的異常類

3）在main()方法中處理異常。

2、實驗實現

1、編寫自定義異常類，代碼以下：

 

 

 class Divide extends Exception{

public Divide(){

super();

}

 public Divide(String message){

 super(message);

 }

 }

2、拋出異常和處理異常，代碼以下：

public class Example419 {

 

public static void main(String[] args) {

// TODO Auto-generated method stub

try{

int result=divide(10,0);

System.out.println(result);

}catch(Divide e){

System.out.println(e.getMessage());

}

 

}

public static int divide(int x,int y)throws Divide{

if(y==0){

throw  new Divide("被除數是0");

}

int result =x/y;

return result;

}

 

}

運行結果如圖3-19所示。

 

圖3-19 運行結果

3、實驗總結

1、在Java中容許用戶自定義異常，但自定義的異常類必須繼承自Exception或其子類。

2、throw關鍵字用於在方法中聲明拋出異常的實例對象，其語法格式以下：

throw Exception異常對象

3、main()方法中，定義了一個try…catch語句用於捕獲divide()方法拋出的異常。在調用divide()方法時因爲傳入的被除數不能爲零，程序會拋出一個自定義異常MyException，該異常被捕獲後最終被catch代碼塊處理，並打印出異常信息。

實驗3-20  import引入指定類

1、實驗描述

一、 考覈知識點

名 稱：import語句

二、 練習目標

• 掌握如何使用import引入指定類

三、 需求分析

不一樣包下的類互相調用時，通常會使用import關鍵字引入包。爲了方便初學者的學習，本實驗將演示如何使用import引入指定類。

四、 設計思路（實現原理）

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類。

2、實驗實現

1、編寫Student類，該類位於cn.itcast.domain包下，代碼以下所示：

package shiyan420;

 

public class Student {

int sid;

String name;

double score;

public Student(int s,String n,double sc){

sid=s;

name=n;

score=sc;

}

public void evalustion(){

if(score>90){

System.out.println("學號爲"+sid+"的"+name+"是三好學生");

}

else System.out.println("學號爲"+sid+"的"+name+"不是三好學生");

}

}

 

2、編寫Example20類，該類位於cn.itcast.example包下，代碼以下所示：

package shiyan414;

import shiyan420.Student;

public class Example420 {

 

/**

 * @param args

 */

public static void main(String[] args) {

// TODO Auto-generated method stub

Student student=new Student(141,"範敏",98);

student.evalustion();

 

}

 

}

運行結果如圖3-20所示。

 

圖3-20 運行結果

3、實驗總結

1、當處於不一樣包下的類互相調用時，須要使用被調用類的完整類名，即包名加上類名。爲了簡化代碼，Java中提供了import關鍵字，用於引入某個指定包下的類。

2、import一般出如今package語句以後，類定義以前。

3、當須要引入同一包下的多個類時，可使用「import包名.*;」的方式，引入包下全部的類。