201871010119-帖佼佼《面向對象程序設計（java）》第十週學習總結

時間 2019-11-08

原文原文鏈接

博文正文開頭格式：（2分）html

項目java	內容程序員
這個做業屬於哪一個課程編程	https://www.cnblogs.com/nwnu-daizh/設計模式
這個做業的要求在哪裏數組	https://www.cnblogs.com/nwnu-daizh/p/11435127.html安全
做業學習目標網絡	(1) 掌握接口定義方法；app (2) 掌握實現接口類的定義要求；less (3) 掌握實現了接口類的使用要求； (4) 掌握程序回調設計模式； (5) 掌握Comparator接口用法； (6) 掌握對象淺層拷貝與深層拷貝方法； (7) 掌握Lambda表達式語法； (8) 瞭解內部類的用途及語法要求。

第一部分：總結第五章理論知識（30分）

一、概念：異常，異常類型、聲明拋出異常、異常拋出、異常捕獲。

二、異常的概念：程序執行過程當中所發生的異常事件，它中斷指令的正常執行。

例如：

package chart7;

public class HelloWorld {

public static void main(String[] args) {

// TODO Auto-generated method stub

int i = 0;

String greetings[]= {"Hello World!", "Hello!", "HELLLO WORLD!!"};

while(i < 3) {

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

}

（1）Java的異常處理機制能夠控制程序從錯誤產生的位置轉移到可以進行錯誤處理的位置。

（2）程序中出現的常見錯誤和問題有：

1）用戶輸入錯誤；

2）設備錯誤；

3）物理錯誤；

4）代碼錯誤；

三、異常分類：

Java把程序運行時可能遇到的錯誤分紅了兩類：

1）非致命異常：經過某種修正後程序還能繼續執行（異常），如：文件不存在，無效的數組下標，空引用，網絡斷開，打印機脫機，磁盤滿等。Java中提供了一種獨特的異常處理機制來處理這類問題；

2）致命異常：程序遇到了很是不正常的狀態，不嫩那個簡單恢復執行，是致命的錯誤。如：內存耗盡，系統內部錯誤等。這種錯誤程序自己沒法解決。

四、Java的異常類直接或間接地繼承於Throwable類。除內置異常類外，程序員可自定義異常類。

Java的異常類可分爲兩大類：

（1）Error

Error類層次結構描述了Java運行時系統的內部錯誤和資源耗盡錯誤。應用程序不該該捕獲這類異常，也不會拋出這種異常；

（2）Exception

Exception類是需重點掌握的異常類。Exception層次結構又分解爲兩個分支：1）一個分支派生於RuntimeException：2)另外一個分支包含其餘異常。

a、RuntimeException爲運行時異常類，通常是程序錯誤產生；

A、派生於RuntimeException的異常包含下面幾種狀況：

1）錯誤的類型轉換；

　　　　2)數組訪問越界；

　　　　3)訪問空指針；

B、Java將派生於Error類或RuntimeException類的全部異常稱爲未檢查異常，編譯器容許不對它們異常處理。

注意：「若是出現RuntimeException異常，就必定是程序員的問題！！！」

　　C、非運行時異常中程序員自己沒有問題，但因爲某種狀況的變化，程序不能正常運行，致使異常出現。

D、除運行時異常外，其餘繼承自Exception類的異常類包括：

一、試圖在文件尾部後面讀取數據；

二、試圖打開一個錯誤格式的URL;

編譯器要求程序必須對這類異常進行處理，稱爲已檢查異常

三、RuntimeException類（運行時異常）包括：算數異常類；數組存儲異常類；類型強制轉換異常類；下標越界異常類；空指針異常類；違背安全原則異常類，輸入輸出異常類。

異常小結：

Error: 很難恢復的嚴重錯誤，通常不禁程序處理；

RuntimeException: 程序設計或實現上的問題，如數組越界等；

其餘異常：一般是由環境因素引發的，而且能夠被處理。如文件不存在，無效URL等。

五、聲明拋出異常（已檢查異常）

（1）聲明拋出異常：若是一個方法可能會生成一些異常，可是該方法並不確切知道如何對這些異常事件進行處理，此時，這個方法就需聲明拋出這些異常。

「一個方法不只須要告訴編譯器將要返回什麼值，還要告訴編譯器可能發生什麼異常」。

（2）聲明拋出異常在方法聲名中用throws子句來指明。

例如：

public FileInputStream（String name） throws FileNotFoundException

throws子句能夠同時指明多個異常，說明該方法將不對這些異常進行處理，而是聲明拋出它們。

（3）一下四種狀況須要方法用throws子句聲明拋出異常：

A、方法調用了一個拋出已檢查異常的方法；

B、程序運行過程當中可能會發生錯誤，而且利用子句throw語句拋出一個已檢查異常對象；

C、程序出現錯誤；

D、Java虛擬機和運行時庫出現的內部異常。

注意：一個方法必須聲明該方法全部可能拋出的已檢查異常，而未檢查異常要麼不可控制（Error）,要麼避免發生（RuntimeException）。

若是方法沒有聲明全部可能發生的已檢查異常，編譯器會給出一個錯誤信息。

六、拋出異常

（1）當Java應用程序出現錯誤時，會根據錯誤類型產生一個異常對象，這個對象包含了異常的類型和錯誤出現時程序所處的狀態信息。把異常對象遞交給Java編譯器的過程稱爲拋出。

（2）拋出異常要生成異常對象，異常對象可由某些類的實例生成，也能夠由JVM生成。

（3）拋出異常對象經過throw語句來實現。

（4）如何拋出異常：

1）首先要決定拋出異常的類型。

2）對於已存在的異常類，拋出該類的異常對象很是容易，步驟是：

a、找到一個合適的異常類；

b、建立這個類的一個對象；

c、將該對象拋出。

3）一個方法拋出了異常後，它就不會返回調用者了。

七、建立異常類：

1）自定義異常類：

定義一個派生於Exception的直接或間接子類。如一個派生於IOException的類。

2）自定義異常類應該包括兩個構造器：

默認構造器；

帶有詳細描述信息的構造器（超類Throwable的toString方法會打印出這些詳細的信息，有利於代碼調試）

八、捕獲異常：

程序運行期間，異常發生時，Java運行系統從異常生成的代碼塊開始，尋找相應的異常處理代碼，並將異常交給該方法處理，這一過程叫作捕獲。

某個異常發生時，若程序沒有在任何地方進行該異常的捕獲，則程序就會終止執行，並在控制檯上輸出異常信息。

若捕獲一個異常，須要在程序中設置一個try/catch/finally塊：

——try語句括住可能拋出異常的代碼塊；

——catch語句指明要捕獲的異常類及相應的處理代碼；

——finally語句指明必須執行的代碼塊。

（1） try子句：

捕獲異常的第一步是用try{……}子句選定捕獲異常的代碼範圍，由try所限定的代碼塊中的語句在執行過程當中可能會自動生成異常對象並拋出。

對於異常處理能夠捕獲，也能夠只聲明拋出不做任何處理；

（2） catch子句：

1） catch塊是對異常對象進行處理的代碼：

2）每一個try代碼塊能夠伴隨一個或多個catch語句，用於處理try代碼塊中所生成的各種異常事件；

3） Catch語句只須要一個形式參數指明它所能捕獲的異常類對象，這個異常類必須是Throwable類的子類，運行時系統經過參數值把被拋出的異常對象傳遞給catch塊：

4） Catch塊能夠經過異常對象調用類Throwable所提供的方法，

getMessage（）：用來獲得有關異常事件的信息；

printStackTrace（）：用來跟蹤異常事件發生時執行堆棧的內容；

5）能夠在一個try塊中不或多個異常類型，每一個異常類型須要一個單獨的catch子句；

6）catch語句的順序：

捕獲異常的順序和不一樣catch語句的順序有關，當捕獲到一個異常時，剩下的catch語句就再也不進行匹配；

所以在安排catch語句的順序時，首先應該捕獲最特殊的異常，而後再逐一通常化，也就是通常先安排子類，再安排父類；

再次拋出異常與異常鏈：

Catch子句也能夠拋出一個異常，這樣作的目的時改變一剎那過的類型。

（3） finally子句：

捕獲異常的最後一步就是經過finally語句爲異常處理提供一個有統一的出口，使得控制流程再轉到程序其餘部分之前，可以對程序狀態作統一的管理。

不論在try代碼塊中是否發生了異常事件，finally塊中的語句都會被執行。

九、異常處理中分析堆棧跟蹤元素：

堆棧跟蹤是程序執行中一個方法調用過程當中的列表，它包括了程序執行過程當中方法調用的特定位置；

十、使用異常機制的建議：

　　程序編碼時已成處理的兩種方式

　　（1）積極處理方式：確切知道如何如何處理的異常應該捕獲；

//積極處理方式　　

import java.io.*;

class ExceptionTest {

public static void main (string args[])

{

try{

FileInputStream fis=new FileInputStream("text.txt");

}

catch（FileNotFoundExcption e）

{ …… }

……

}

　　（2）消極處理方式：不知道如何去處理的異常聲明拋出；

//消極處理方式

import java.io.*;

class ExceptionTest {

public static void main (string args[]) throws FileNotFoundExcption

{

FileInputStream fis=new FileInputStream("text.txt");

}

異常處理的原則

（1）異常處理不能代替簡單的條件檢測，只在異常狀況下使用異常機制。

（2）程序代碼不要過度細化異常，儘可能將有可能產生異常的語句放在一個try語句塊中；

　　（3）拋出的異常儘量明確；

　　（4）不要壓制異常，對於不多發生的異常，應該將其關閉；

　　（5）早拋出，晚捕獲，儘可能讓高層次的方法通告用戶發生了錯誤。

十一、斷言：

　　斷言是程序開發和測試階段用於插入一些代碼錯誤檢測語句的工具。

　　斷言語法以下：

　　　　assert 條件或者 assert 條件：表達式

這兩個形式都會對布爾「條件」進行判斷，若是判斷結果爲假（false），說明程序已經處於不正確的狀態下，系統則拋出AssertionError，給出警告而且退出，在第二種形式中，「表達式」會傳入AssertionError的構造函數中並轉成一個消息字符串；

第二部分：實驗部分

實驗1：用命令行與IDE兩種環境下編輯調試運行源程序ExceptionDemo一、ExceptionDemo2，結合程序運行結果理解程序，掌握未檢查異常和已檢查異常的區別。（5分）

public class ExceptionDemo1 {
	public static void main(String args[]) {
		int a = 0;
		System.out.println(5 / a);    //分母爲零，程序報錯。
	}
}

　　運行結果以下：

import java.io.*;

public class ExceptionDemo2 {
	public static void main(String args[]) throws IOException 
     {
          FileInputStream fis = new FileInputStream("text.txt");//JVM自動生成異常對象
          int b;
          while((b=fis.read())!=-1)
          {
              System.out.print(b);
          }
          fis.close();
      }
}

　　運行結果以下：

實驗2：

導入如下示例程序，測試程序並進行代碼註釋。

測試程序1：（5分）

l 在elipse IDE中編輯、編譯、調試運行教材281頁7-1，結合程序運行結果理解程序；

l 在程序中相關代碼處添加新知識的註釋；

l 掌握Throwable類的堆棧跟蹤方法；

實驗代碼以下：

package stackTrace;

import java.util.*;

/**
 * A program that displays a trace feature of a recursive method call.
 * @version 1.10 2017-12-14
 * @author Cay Horstmann
 */
public class StackTraceTest
{
   /**
    * Computes the factorial of a number
    * @param n a non-negative integer
    * @return n! = 1 * 2 * . . . * n
    */
   public static int factorial(int n)     //求n的階乘
   {
      System.out.println("factorial(" + n + "):");
      StackWalker walker = StackWalker.getInstance();    //建立一個表示指定執行點的堆棧跟蹤元素walker，調用getInstance()方法
      walker.forEach(System.out::println);      
      int r;
      if (n <= 1) r = 1;
      else r = n * factorial(n - 1);     //遞歸調用
      System.out.println("return " + r);
      return r;
   }

   public static void main(String[] args)
   {
      try (Scanner in = new Scanner(System.in))   //try子句
      {
         System.out.print("Enter n: ");
         int n = in.nextInt();
         factorial(n);
      }
   }
}

　　運行結果以下：

實驗2：測試程序2

l Java語言的異常處理有積極處理方法和消極處理兩種方式；

//積極處理方式　　
import java.io.*;

class ExceptionTest {
	public static void main (string args[])
   {
       try{
	       FileInputStream fis=new FileInputStream("text.txt");
       }
       catch（FileNotFoundExcption e）
    	{   ……  }
	……
    }
}

//消極處理方式

import java.io.*;
class ExceptionTest {
	public static void main (string args[]) throws  FileNotFoundExcption
     {
 	    FileInputStream fis=new FileInputStream("text.txt");
     }
}

l 下列兩個簡單程序範例給出了兩種異常處理的代碼格式。在elipse IDE中編輯、調試運行源程序ExceptionTest.java，將程序中的text文件更換爲身份證號.txt，要求將文件內容讀入內容，並在控制檯顯示；

l 掌握兩種異常處理技術的特色。（10分）

實驗代碼以下：

//積極處理方式
import java.io.*;

class ExceptionTest {
    public static void main (String args[])
   {
        
       try{
           FileInputStream fis=new FileInputStream("D:\\身份證號.txt");
           BufferedReader in = new BufferedReader(new InputStreamReader(fis));
           String s = new String();
           while ((s = in.readLine()) != null) {
               System.out.println(s);
           }
           in.close();
           fis.close();
       }
       catch (FileNotFoundException e) {
           System.out.println("文件找不到");
           e.printStackTrace();
       } catch (IOException e) {
           System.out.println("文件讀取錯誤");
           e.printStackTrace();
       }
}
}

　　運行結果以下：

//消極處理方式
import java.io.*;

public class ExceptionTest {
    public static void main (String args[]) throws IOException
   {
         
       try{
           FileInputStream fis=new FileInputStream("D:\\身份證號.txt");
           BufferedReader in = new BufferedReader(new InputStreamReader(fis));
           String s = new String();
           while ((s = in.readLine()) != null) {
               System.out.println(s);
           }
           in.close();
           fis.close();
       }
       finally {
    	   
       }
 
   }
}

實驗3：編程練習（25分）

l 編寫一個計算器類，能夠完成加、減、乘、除的操做；

l 利用計算機類，設計一個小學生100之內數的四則運算練習程序，由計算機隨機產生10道加減乘除練習題，學生輸入答案，由程序檢查答案是否正確，每道題正確計10分，錯誤不計分，10道題測試結束後給出測試總分；

l 將程序中測試練習題及學生答題結果輸出到文件，文件名爲test.txt；

| 在以上程序適當位置加入異常捕獲代碼。

實驗代碼以下：

import java.util.Scanner;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Random;

public class Demo {
    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        Number counter = new Number();
        PrintWriter out = null;
        //try——catch語句
        try {
            out = new PrintWriter("text.txt");
            } 
        catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        int sum = 0;

        for (int i = 1; i <= 10; i++) {

            int a = (int) Math.round(Math.random() * 100);
            int b = (int) Math.round(Math.random() * 100);
            int m = (int) Math.round(Math.random() * 3);

            switch (m) {
            case 0:
                System.out.println(i + ": " + a + "/" + b + "=");

                while (b == 0) {
                    b = (int) Math.round(Math.random() * 100);
                }

                int c = in.nextInt();
                out.println(a + "/" + b + "=" + c);
                if (c == counter.division(a, b)) {
                    sum += 10;
                    System.out.println("回答正確");
                } else {
                    System.out.println("回答錯誤");
                }

                break;

            case 1:
                System.out.println(i + ": " + a + "*" + b + "=");
                int c1 = in.nextInt();
                out.println(a + "*" + b + "=" + c1);
                if (c1 == counter.multiplication(a, b)) {
                    sum += 10;
                    System.out.println("回答正確");
                } else {
                    System.out.println("回答錯誤");
                }
                break;
            case 2:
                System.out.println(i + ": " + a + "+" + b + "=");
                int c2 = in.nextInt();
                out.println(a + "+" + b + "=" + c2);
                if (c2 == counter.add(a, b)) {
                    sum += 10;
                    System.out.println("回答正確");
                } else {
                    System.out.println("回答錯誤");
                }

                break;
            case 3:
                System.out.println(i + ": " + a + "-" + b + "=");
                int c3 = in.nextInt();
                out.println(a + "-" + b + "=" + c3);
                if (c3 == counter.reduce(a, b)) {
                    sum += 10;
                    System.out.println("回答正確");
                } else {
                    System.out.println("回答錯誤");
                }
                break;

            }

        }
        System.out.println("總分爲：" + sum);
        out.println("總分:" + sum);
        out.close();

    }
}

public class Number {
    private int a;
    private int b;

    public int add(int a, int b) {   //定義加法方法
        return a + b;
    }

    public int reduce(int a, int b) {   //定義減法方法
        return a - b;
    }

    public int multiplication(int a, int b) {    //定義乘法方法
        return a * b;
    }

    public int division(int a, int b) {     ////定義除法方法
        if (b != 0)       //分母不爲0
            return a / b; 
        else
            return 0;
    }
}

運行結果以下：

實驗代碼以下：

public class TestHello {

	public static void main(String[] args) {
		  TestHello  test = new TestHello();
		  int sum = test.sum(8,9);
		  int subduction = test.subduction(52,12);
		  int multiplication= test.multiplication(3, 7);
		  double division = test.division(81, 9);
		  System.out.println("加法運算的結果爲：" + sum);
		  System.out.println("減法運算的結果爲：" + subduction);
		  System.out.println("乘法運算的結果爲：" + multiplication);
		  System.out.println("除法運算的結果爲：" + division);
	}	
          //System.out.println("總分爲：" + score);
public int sum(int a, int b) {  //定義加法方法
	  int resultsum = a + b;
      return resultsum;
  }

public int subduction(int a, int b) {  //定義減法方法
	  int resultsubduction = a - b;
      return resultsubduction;
  }

public int multiplication(int a, int b) {    //定義乘法方法
  int resultmultiplication =  a * b;
  return resultmultiplication;
}

public double division(int a, int b) {     //定義除法方法
	double resultdiv = 0;
  if (b != 0) {      //分母不爲0
  	resultdiv = a / b; 
  }
  else {
  	resultdiv = 0;
 }
	return resultdiv;
 }
}

　　運行結果以下：

程序步驟分析：

新建一個TestHello類，定義加法的方法。定義方式爲聲明兩個變量，而後相加，賦給第三個變量，並使用return返回出來；

一樣地，定義減法，乘法以及除法的方法。不一樣的是，在定義除法方法時，再也不是int型的，而是double類型的變量，除數不能爲0，因此判斷一下。

最後在main函數中，實例化該TestHello類，並經過實例化的別名點方法名實現調用加減乘除的方法，　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

實驗4：：斷言、日誌、程序調試技巧驗證明驗。

測試程序1

l 在elipse下調試程序AssertDemo，結合程序運行結果理解程序；

l 註釋語句test1(-5);後從新運行程序，結合程序運行結果理解程序；

l 掌握斷言的使用特色及用法。（5分）

實驗代碼以下：

//斷言程序示例
public class AssertDemo {
    public static void main(String[] args) {        
        test1(-5);
        test2(-3);
    }
    
    private static void test1(int a){
        assert a > 0;
        System.out.println(a);
    }
    private static void test2(int a){
       assert a > 0 : "something goes wrong here, a cannot be less than 0";
        System.out.println(a);
    }
}

　　運行結果以下：

實驗4：測試程序2

l 用JDK命令調試運行教材298頁-300頁程序7-2，結合程序運行結果理解程序；

l 並掌握Java日誌系統的用途及用法。（5分）

實驗代碼以下：

//斷言程序示例
public class AssertDemo {
    public static void main(String[] args) {        
        //test1(-5);
        test2(-3);
    }
    
    private static void test1(int a){
        assert a > 0;
        System.out.println(a);
    }
    private static void test2(int a){
       assert a > 0 : "something goes wrong here, a cannot be less than 0";
        System.out.println(a);
    }
}

　　運行結果以下：

實驗4：

l 用JDK命令調試運行教材298頁-300頁程序7-2，結合程序運行結果理解程序；

l 並掌握Java日誌系統的用途及用法。

實驗代碼以下：

package logging;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.logging.*;
import javax.swing.*;

/**
 * A modification of the image viewer program that logs various events.
 * @version 1.03 2015-08-20
 * @author Cay Horstmann
 */
public class LoggingImageViewer
{
   public static void main(String[] args)
   {
      if (System.getProperty("java.util.logging.config.class") == null
            && System.getProperty("java.util.logging.config.file") == null)
      {
         try
         {
            Logger.getLogger("com.horstmann.corejava").setLevel(Level.ALL);
            final int LOG_ROTATION_COUNT = 10;
            FileHandler handler = new FileHandler("%h/LoggingImageViewer.log", 0, LOG_ROTATION_COUNT);
            Logger.getLogger("com.horstmann.corejava").addHandler(handler);
         }
         catch (IOException e)
         {
            Logger.getLogger("com.horstmann.corejava").log(Level.SEVERE,
               "Can't create log file handler", e);
         }
      }
      EventQueue.invokeLater(() ->
            {
               WindowHandler windowHandler = new WindowHandler();
               windowHandler.setLevel(Level.ALL);
               Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);

               ImageViewerFrame frame = new ImageViewerFrame();
               frame.setTitle("LoggingImageViewer");
               frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

               Logger.getLogger("com.horstmann.corejava").fine("Showing frame");
               frame.setVisible(true);
            });
   }
}

/**
 * The frame that shows the image.
 */
class ImageViewerFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 400;   

   private JLabel label;
   private static Logger logger = Logger.getLogger("com.horstmann.corejava");

   public ImageViewerFrame()
   {
      logger.entering("ImageViewerFrame", "<init>");      
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

      // set up menu bar
      JMenuBar menuBar = new JMenuBar();
      setJMenuBar(menuBar);

      JMenu menu = new JMenu("File");
      menuBar.add(menu);

      JMenuItem openItem = new JMenuItem("Open");
      menu.add(openItem);
      openItem.addActionListener(new FileOpenListener());

      JMenuItem exitItem = new JMenuItem("Exit");
      menu.add(exitItem);
      exitItem.addActionListener(new ActionListener()
         {
            public void actionPerformed(ActionEvent event)
            {
               logger.fine("Exiting.");
               System.exit(0);
            }
         });

      // use a label to display the images
      label = new JLabel();
      add(label);
      logger.exiting("ImageViewerFrame", "<init>");
   }

   private class FileOpenListener implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         logger.entering("ImageViewerFrame.FileOpenListener", "actionPerformed", event);

         // set up file chooser
         JFileChooser chooser = new JFileChooser();
         chooser.setCurrentDirectory(new File("."));

         // accept all files ending with .gif
         chooser.setFileFilter(new javax.swing.filechooser.FileFilter()
            {
               public boolean accept(File f)
               {
                  return f.getName().toLowerCase().endsWith(".gif") || f.isDirectory();
               }

               public String getDescription()
               {
                  return "GIF Images";
               }
            });

         // show file chooser dialog
         int r = chooser.showOpenDialog(ImageViewerFrame.this);

         // if image file accepted, set it as icon of the label
         if (r == JFileChooser.APPROVE_OPTION)
         {
            String name = chooser.getSelectedFile().getPath();
            logger.log(Level.FINE, "Reading file {0}", name);
            label.setIcon(new ImageIcon(name));
         }
         else logger.fine("File open dialog canceled.");
         logger.exiting("ImageViewerFrame.FileOpenListener", "actionPerformed");
      }
   }
}

/**
 * A handler for displaying log records in a window.
 */
class WindowHandler extends StreamHandler
{
   private JFrame frame;

   public WindowHandler()
   {
      frame = new JFrame();
      JTextArea output = new JTextArea();
      output.setEditable(false);
      frame.setSize(200, 200);
      frame.add(new JScrollPane(output));
      frame.setFocusableWindowState(false);
      frame.setVisible(true);
      setOutputStream(new OutputStream()
         {
            public void write(int b)
            {
            } // not called

            public void write(byte[] b, int off, int len)
            {
               output.append(new String(b, off, len));
            }
         });
   }

   public void publish(LogRecord record)
   {
      if (!frame.isVisible()) return;
      super.publish(record);
      flush();
   }
}

　　運行結果以下：

測試程序3

l 用JDK命令調試運行教材298頁-300頁程序7-2，結合程序運行結果理解程序；

l 按課件66-77內容練習並掌握Elipse的經常使用調試技術。

①條件斷點 –在Eclipse Java 編輯區的行頭雙擊就會獲得一個斷點，代碼會運行到此處時中止。

–條件斷點，顧名思義就是一個有必定條件的斷點，只有知足了用戶設置的條件，代碼纔會在運行到斷點處時中止。

–在斷點處點擊鼠標右鍵，選擇後一個「Breakpoint Properties」.（5分）

實驗代碼以下：

package logging;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.logging.*;
import javax.swing.*;

/**
 * A modification of the image viewer program that logs various events.
 * @version 1.03 2015-08-20
 * @author Cay Horstmann
 */
public class LoggingImageViewer
{
   public static void main(String[] args)
   {
      if (System.getProperty("java.util.logging.config.class") == null
            && System.getProperty("java.util.logging.config.file") == null)
      {
         try
         {
            Logger.getLogger("com.horstmann.corejava").setLevel(Level.ALL);
            final int LOG_ROTATION_COUNT = 10;
            FileHandler handler = new FileHandler("%h/LoggingImageViewer.log", 0, LOG_ROTATION_COUNT);
            Logger.getLogger("com.horstmann.corejava").addHandler(handler);
         }
         catch (IOException e)
         {
            Logger.getLogger("com.horstmann.corejava").log(Level.SEVERE,
               "Can't create log file handler", e);
         }
      }
      EventQueue.invokeLater(() ->
            {
               WindowHandler windowHandler = new WindowHandler();
               windowHandler.setLevel(Level.ALL);
               Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);

               ImageViewerFrame frame = new ImageViewerFrame();
               frame.setTitle("LoggingImageViewer");
               frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

               Logger.getLogger("com.horstmann.corejava").fine("Showing frame");
               frame.setVisible(true);
            });
   }
}

/**
 * The frame that shows the image.
 */
class ImageViewerFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 400;   

   private JLabel label;
   private static Logger logger = Logger.getLogger("com.horstmann.corejava");

   public ImageViewerFrame()
   {
      logger.entering("ImageViewerFrame", "<init>");      
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

      // set up menu bar
      JMenuBar menuBar = new JMenuBar();
      setJMenuBar(menuBar);

      JMenu menu = new JMenu("File");
      menuBar.add(menu);

      JMenuItem openItem = new JMenuItem("Open");
      menu.add(openItem);
      openItem.addActionListener(new FileOpenListener());

      JMenuItem exitItem = new JMenuItem("Exit");
      menu.add(exitItem);
      exitItem.addActionListener(new ActionListener()
         {
            public void actionPerformed(ActionEvent event)
            {
               logger.fine("Exiting.");
               System.exit(0);
            }
         });

      // use a label to display the images
      label = new JLabel();
      add(label);
      logger.exiting("ImageViewerFrame", "<init>");
   }

   private class FileOpenListener implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         logger.entering("ImageViewerFrame.FileOpenListener", "actionPerformed", event);

         // set up file chooser
         JFileChooser chooser = new JFileChooser();
         chooser.setCurrentDirectory(new File("."));

         // accept all files ending with .gif
         chooser.setFileFilter(new javax.swing.filechooser.FileFilter()
            {
               public boolean accept(File f)
               {
                  return f.getName().toLowerCase().endsWith(".gif") || f.isDirectory();
               }

               public String getDescription()
               {
                  return "GIF Images";
               }
            });

         // show file chooser dialog
         int r = chooser.showOpenDialog(ImageViewerFrame.this);

         // if image file accepted, set it as icon of the label
         if (r == JFileChooser.APPROVE_OPTION)
         {
            String name = chooser.getSelectedFile().getPath();
            logger.log(Level.FINE, "Reading file {0}", name);
            label.setIcon(new ImageIcon(name));
         }
         else logger.fine("File open dialog canceled.");
         logger.exiting("ImageViewerFrame.FileOpenListener", "actionPerformed");
      }
   }
}

/**
 * A handler for displaying log records in a window.
 */
class WindowHandler extends StreamHandler
{
   private JFrame frame;

   public WindowHandler()
   {
      frame = new JFrame();
      JTextArea output = new JTextArea();
      output.setEditable(false);
      frame.setSize(200, 200);
      frame.add(new JScrollPane(output));
      frame.setFocusableWindowState(false);
      frame.setVisible(true);
      setOutputStream(new OutputStream()
         {
            public void write(int b)
            {
            } // not called

            public void write(byte[] b, int off, int len)
            {
               output.append(new String(b, off, len));
            }
         });
   }

   public void publish(LogRecord record)
   {
      if (!frame.isVisible()) return;
      super.publish(record);
      flush();
   }
}

實驗總結：（15分）

這周主要學習了異常以及異常的處理方法。異常是程序執行過程當中所發生的異常事件，它中斷指令的正常執行。所以在編寫代碼時須要及時處理這些錯誤。對於異常處理，老師用兩節理論課給咱們講，在課下總結有關異常以及異常處理的知識點時，感受上課聽的不是太懂。知道了用拋出異常和將可能出錯的語句放入try子句中兩種方法，try——catch子句是一塊兒存在的。對於斷言以及日誌等內容，也學的不明白，本身在講以前看了課本內容，徹底不理解。在運行最後一個實驗程序時，對程序不理解，沒看懂爲何運行結果是那樣的。還有就是老師佈置的編程題，我本身能作出來的就是第二種了，雖然不符合老師的要求，可是是本身盡力作的，以後我會好好看網上給出的答案，盡力去理解。

獲獎感言：對於期中考試以後得到小黃衫，我很榮幸。可能本身真正學到的有關Java編程的知識不是很好，在具體應用學到的知識這一方面還很欠缺。小黃衫，它不只是一種獎勵，是一種動力，同時它也給我一種壓力，它讓我意識到接下來的學習要更加的努力，纔不會辜負老師的指望，才能對得起小黃衫的價值。在接下來的學習中，我會堅持，盡力而爲。