Java內部類和異常類的示例分析

這篇文章將為大家詳細講解有關Java內部類和異常類的示例分析，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

1 內部類

Java支持在一個類中聲明另一個類，這樣的類稱作內部類，而包含內部類的類成為內部類的外嵌類。

內部類的類體中不可以聲明類變量和類方法。外嵌類的類體中可以用內部類聲明對象，作為外嵌類的成員。

內部類的使用規則:
（1）聲明內部類如同在類中聲明方法或變量一樣，一個類把內部類看作是自己的成員。
（2）外嵌類的類體中可以用內部類聲明的對象，作為外嵌類的成員。
（3）外嵌類的成員變量在內部類中仍然有效，內部類中的方法也可以調用外嵌類中的方法。
（4）內部類的類體中不可以聲明類變量和方法。
（5）外嵌類和內部類在編譯時，生成兩個.class文件。

例如:某種類型的農場飼養了一種特殊種類的牛，但不希望其他農場飼養這種特殊種類的牛，那么這種類型的農場就可以將創建這種特殊種牛的類作為自己的內部類。
下面的例子1(Example1.1.java)中有一個RedCowForm(紅牛農場)類，該類中有一個名字為RedCow (紅牛)的內部類。

RedCowForm.java

public class RedCowForm {
    static String formName;
    RedCow cow;  //內部類聲明對象

    RedCowForm() {
    }

    RedCowForm(String s) {
        cow = new RedCow(150, 112, 5000);
        formName = s;
    }

    public void showCowMess() {
        cow.speak();
    }

    class RedCow {  //內部類的聲明
        String cowName = "紅牛";
        int height, weight, price;

        RedCow(int h, int w, int p) {
            height = h;
            weight = w;
            price = p;
        }

        void speak() {
            System.out.println("偶是" + cowName + ",身高:" + height + "cm 體重:" + weight + "kg,生活在" + formName);
        }
    }    //內部類結束
}
115526523

Example1.1.java

public class Example1_1 {
    public static void main(String[] args) {
        RedCowForm form = new RedCowForm("紅牛農場");
        form.showCowMess();
        form.cow.speak();
    }
}

需要特別注意的是，Java編譯器生成的內部類的字節碼文件的名字和通常的類不同，內部類對應的字節碼文件的名字格式是“外嵌類名$ 內部類名”，例如，例子1中內部類的字節碼文件是RedCowForm$RedCow.class。因此，當需要把字節碼文件復制給其他開發人員時，不要忘記了內部類的字節碼文件。
內部類可以被修飾為static 內部類，例如，例子1中的內部類聲明可以是static classRedCow。類是一種數據類型，那么static內部類就是外嵌類中的一-種靜 態數據類型，這樣一來，程序就可以在其他類中使用static內部類來創建對象了。但需要注意的是，static 內部類不能操作外嵌類中的實例成員變量。

假如將例子1中的內部類RedCow更改成static內部類，就可以在例子1的Example1_ 1
主類的main方法中增加如下的代碼。

RedCowForm.RedCow redCow = new RedCowForm.RedCow(180,119,6000);
        redCow.speak();

注意：非內部類不可以是static類

2 匿名類

2.1 和子類有關的匿名類

創建子類對象時，除了使用父類的構造方法外還有類體，此類體被認為是一個子類去掉類聲明后的類體，稱作匿名類。

假設Bank是類，那么下列代碼就是用Bank的一個子類(匿名類)創建對象:

new Bank() {
	匿名類的類體
};

和子類有關的匿名類：
（1）匿名類是一個子類，由于無名可用，所以不可能用匿名類聲明對象，但卻可以直接用匿名類創建一個對象。
（2）匿名類可以繼承父類的方法也可以重寫父類的方法。
（3）使用匿名類時，必然是在某個類中直接用匿名類創建對象，以此，匿名類一定是內部類。
（4）匿名類可以訪問外嵌類中的成員變量和方法，匿名類的類體中不可以聲明static成員變量和static方法。
（5）由于匿名類是一個子類，但沒有類名，所以在用匿名類創建對象時，要直接使用父類的構造方法。

例子2:該類共有4個類: (Example2_1. java)、ShowBoard類、
OutputAlphabet類型、 OutputEnglish. java 。該匿名類的對象負責輸出希臘字母表。

OutputAlphabet.java

abstract class OutputAlphabet {
    public abstract void output();
}

OutputAlphabet .java

public class OutputEnglish extends OutputAlphabet { //輸出英文字母子類
    public void output(){
        for (char c='a';c<='z';c++){
            System.out.printf("%3c",c);
        }
    }
}

ShowBoard .java

public class ShowBoard {
    void showMess(OutputAlphabet show) { //參數show是OutputAlphabet類型的對象
        show.output();
    }
}

Example2_1.java

public class Example2_1 {
    public static void main(String[] args) {
        ShowBoard board = new ShowBoard();
        board.showMess(new OutputEnglish());//向參數傳遞OutputAlphabet的子類OutputEnglish的對象

        board.showMess(new OutputAlphabet() {   //向參數傳遞OutputAlphabet的匿名子類的對象
            @Override
            public void output() {
                for (char c = 'α'; c <= 'ω'; c++)  //輸出希臘字母
                    System.out.printf("%3c", c);
            }
        });//分號在這里
    }
}

2.2 和接口有關的匿名類

和接口有關的匿名類
假設Computable是一個接口，那么，Java允許直接用接口名和一個類體創建一個匿名對象，此類體被認為是實現了Computable接口的類去掉類聲明后的類體，稱作匿名類。

下列代碼就是用實現了Computable接口的類(匿名類)創建對象:

new Computable(){
	實現接口的匿名類的類體
};

下面例子演示了和接口有關的匿名類的用法：

interface SpeakHello {
    void speak();
}

class HelloMachine {
    public void turnOn(SpeakHello hello) {
        hello.speak();
    }
}

public class Example7_3 {
    public static void main(String[] args) {
        HelloMachine machine = new HelloMachine();
        machine.turnOn(new SpeakHello() {
            @Override
            public void speak() {
                System.out.println("hello,you are welcome!");
            }
        });
        machine.turnOn(new SpeakHello() {
            @Override
            public void speak() {
                System.out.println("你好，歡迎光臨!");
            }
        });
    }
}

3 異常類

所謂異常就是程序運行時可能出現一些錯誤，比如試圖打開一個根本不存在的文件等，異常處理將會改變程序的控制流程，讓程序有機會對錯誤作出處理。程序運行出現異常時，Java運行環境就用異常類Exception的相應子類創建一個異常對象，并等待處理。異常對象可以調用如下方法得到或輸出有關異常的信息:

異常對象可以調用如下方法得到或輸出有關異常的信息：

public String getMessage();
public void printStackTrace();
public String toString();

3.1 try-catch語句

Java使用try-catch語句來處理異常，將可能出現的異常操作放在try-catch語句的try部分，將發生異常后的處理放在catch部分。
try-catch語句的格式如下:

try{
	包含可能發生異常的語句
}
catch(ExceptionSubClass1 e){
	...
}
catch(ExceptionSubClass2 e){
	...
}

下面一個例子給出了try-catch語句的用法：

public class Example3_1 {
    public static void main(String[] args) {
        int n = 0, m = 0, t = 1000;

        try {
            m = Integer.parseInt("8888");
            n = Integer.parseInt("ab89"); //發生異常,轉向catch
            t = 7777;  //t沒有機會被賦值
        } catch (NumberFormatException e) {
            System.out.println("發生異常:" + e.getMessage());
        }
        System.out.println("n=" + n + ",m=" + m + ",t=" + t);

        try {
            System.out.println("故意拋出I/O異常！");
            throw new java.io.IOException("我是故意的");
            //System.out.println("這個輸出語句肯定沒有機會執行,所以必須注釋掉，否則編譯出錯");
        } catch (java.io.IOException e) {
            System.out.println("發生異常:" + e.getMessage());
        }
    }
}

帶finally子語句的try~catch語句，語法格式如下:

try{ }
catch(ExceptionSubClass e){ }
finally{}

其執行機制是在執行try~catch語句后，執行finally 子語句，也就是說，無論在try部分是否發生過異常，finally 子語句都會被執行

3.2 自定義異常類

（1）一個方法不處理它產生的異常，而是沿著調用層次向上傳遞,由調用它的方法來處理這些異常，叫聲明異常.

聲明異常的方法:
在產生異常的方法名后面加上要拋出(throws)的異常的列表:

如: void compute(int x) throwsAri thmeticException
{//這里有異常發生，但是并沒有處理…}

（2）我們也可以擴展Exception類定義自己的異常類，然后規定哪些方法產生這樣的異常。一個方法在聲明時可以使用throws關鍵字聲明要產生的若干個異常，并在該方法的方法體中具體給出產生異常的操
作，即用相應的異常類創建對象，并使用throw關鍵字拋出該異常對象，導致該方法結束執行。

（3）通常情況下，計算兩個整數之和的方法不應當有任何異常放出，但是，對某些特殊應程序，可能不允許同號的整數做求和運算，比如當一個整數代表收入，一個整數代表支出時，這兩個整數就不能是同號。

例子 (Example3_2. java)中，Bank類中有一個income(int in, int out)方法，對象調用該方法時，必須向參數in傳遞正整數、向參數out傳遞負數，并且int+out必須大于等于0，否則該方法就拋出異常( BankException. java )。因此，Bank類在聲明income(int in, int out)方法時，使用throws關鍵字聲明要產生的異常。

BankException.java

public class BankException extends Exception {
    String message;

    public BankException(int m, int n) {
        message = "入賬資金" + m + "是負數或支出" + n + "是正數，不符合系統要求.";
    }

    public String warnMess() {
        return message;
    }
}

Bank.java

public class Bank {
    private int money;

    public void income(int in, int out) throws BankException {
        if (in <= 0 || out >= 0 || in + out <= 0) {
            throw new BankException(in, out); //方法拋出異常，導致方法結束
        }
        int netIncome = in + out;
        System.out.printf("本次計算出的純收入是:%d元\n", netIncome);
        money = money + netIncome;
    }

    public int getMoney() {
        return money;
    }
}

Example3_2.java

public class Example3_2 {
    public static void main(String[] args) {
        Bank bank = new Bank();
        try {
            bank.income(200, -100);
            bank.income(300, -100);
            bank.income(400, -100);
            System.out.printf("銀行目前有%d元\n", bank.getMoney());
            bank.income(200, 100);
            bank.income(99999, -100);
        } catch (BankException e) {
            System.out.println("計算收益的過程出現如下問題:");
            System.out.println(e.warnMess());
        }
        System.out.printf("銀行目前有%d元\n", bank.getMoney());
    }
}

4 斷言

斷言語句用于調試代碼階段。在調試代碼階段讓斷言語句發揮作用，這樣就可以發現一些致命的錯誤，當程序正式運行時就可以關閉斷言語句，但仍把斷言語句保留在源代碼中，如果以后應用程又需要調試，可以重新啟用斷言語句。

使用關鍵字assert聲明一條斷言語句，斷言語句有以下兩種格式:

assert booleanExpression;

assert booleanExpression:messagelException;

啟用與關閉斷言語句
當使用Java解釋器直接運行應用程序時，默認地關閉斷言語句，在調試程序時可以使用-ea啟用斷言語句，例如:
java -ea mainClass

例子4中，使用一個數組放著某學生5門課程的成績，程序準備計算學生的成績的總和。在調試程序時使用了斷言語句，如果發現成績有負數，程序立刻結束執行。程序調試開啟斷言語句運行效果如圖4.1，關閉斷言語句運行效果如圖4.2。

import java.util.Scanner;
public class Example4 {
  public static void main (String args[ ]) {
       int [] score={-120,98,89,120,99};
       int sum=0;
       for(int number:score) {
          assert number>0:"負數不能是成績";
          sum=sum+number;
       } 
       System.out.println("總成績:"+sum);    
   }
}

圖4.1

圖4.2

5 綜合案例

下面的例子5中模擬向貨船上裝載集裝箱，如果貨船超重，那么貨船認為這是一個異常將拒絕裝載集裝箱，但無論是否發生異常，貨船都需要正點啟航

DangerException.java

public class DangerException extends Exception {
    final String message = "超重";
    public String warnMess() {
        return message;
    }
}

CargoBoat.java

public class CargoBoat {
    int realContent;  //裝載的重量
    int maxContent;   //最大裝載量
    public void setMaxContent(int c) {
        maxContent = c;
    }
    public void loading(int m) throws DangerException {
        realContent += m;
        if(realContent>maxContent) {
            throw new DangerException();
        }
        System.out.println("目前裝載了"+realContent+"噸貨物");
    }
}

Example5.java

public class Example5 {
    public static void main(String[] args) {
        CargoBoat ship = new CargoBoat();
        ship.setMaxContent(1000);
        int m =600;
        try{
            ship.loading(m);
            m = 400;
            ship.loading(m);
            m = 367;
            ship.loading(m);
            m = 555;
            ship.loading(m);
        }
        catch(DangerException e) {
            System.out.println(e.warnMess());
            System.out.println("無法再裝載重量是"+m+"噸的集裝箱");
        }
        finally {
            System.out.printf("貨船將正點啟航");
        }
    }
}

關于“Java內部類和異常類的示例分析”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。