201871010114李岩松《面向对象程序设计（java）》第十周学习总结

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11435127.html
作业学习目标	1.掌握java异常处理技术； 2.了解断言的用法； 3.了解日志的用途； 4.掌握程序基础调试技巧。

第一部分：总结第七章关于异常处理相关理论知识

1.1 异常概念

异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是：

  异常 ：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.

1.2 异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是 java.lang.Throwable ，其下有两个子类：java.lang.Error 与 java.lang.Exception ，平常所说的异常指 java.lang.Exception 。

Throwable体系：

  Error:严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。

  Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。

Throwable中的常用方法：

public void printStackTrace() :打印异常的详细信息。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

public String getMessage() :获取发生异常的原因。

提示给用户的时候,就提示错误原因。

public String toString() :获取异常的类型和异常描述信息(不用)。

 出现异常,不要紧张,把异常的简单类名,拷贝到API中去查。

1.3 异常分类

 我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常?

  编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)

  运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)

1.4         异常的产生过程解析

 先运行下面的程序，程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。

 

public class ArrayTools {

//    对给定的数组通过给定的角标获取元素。

public static int getElement(int[] arr, int index) { int element = arr[index];

return element;

}

}

工具类

ublic class ExceptionDemo {

public static void main(String[] args) {

int[] arr = { 34, 12, 67 };

intnum = ArrayTools.getElement(arr, 4)

System.out.println("num=" + num);

System.out.println("over");

}

}

上述程序执行过程图解：

 第二章 异常的处理

 

Java异常处理的五个关键字：try、catch、finally、throw、throws

 

2.1 抛出异常throw

 

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

 在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

 1.创建一个异常对象。封装一些提示信息(信息可以自己编写)。

 2.需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，

并结束当前方法的执行。

 使用格式:

throw new 异常类名(参数);

例如：

throw new NullPointerException("要访问的arr数组不存在");

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

我们通过下面程序演示下throw的使用。

public class ThrowDemo {

public static void main(String[] args) {

//创建一个数组

int[] arr = {2,4,52,2};

//根据索引找对应的元素

int index = 4;

int element = getElement(arr, index);

System.out.println(element);

System.out.println("over");

}

/*

*    根据 索引找到数组中对应的元素

*/

public static int getElement(int[] arr,int index){

//判断    索引是否越界

if(index<0 || index>arr.length‐1){

/*

判断条件如果满足，当执行完throw抛出异常对象后，方法已经无法继续运算。

这时就会结束当前方法的执行，并将异常告知给调用者。这时就需要通过异常来解决。

*/

throw new ArrayIndexOutOfBoundsException("哥们，角标越界了~~~");

}

int element = arr[index];

return element;

}

}

2.3 声明异常throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。

 关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

 声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{    }

声明异常的代码演示：

public class ThrowsDemo {

public static void main(String[] args) throws FileNotFoundException { read("a.txt");

}

//    如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明 public static void read(String path) throws FileNotFoundException {

if (!path.equals("a.txt")) {//如果不是 a.txt这个文件

//    我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw

throw new FileNotFoundException("文件不存在");

}

}

}

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

public class ThrowsDemo2 {

public static void main(String[] args) throws IOException { read("a.txt");

}

public static void read(String path)throws FileNotFoundException, IOException { if (!path.equals("a.txt")) {//如果不是 a.txt这个文件

//    我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw throw new FileNotFoundException("文件不存在");

}

if (!path.equals("b.txt")) {

throw new IOException();

}

}

}

2.4 捕获异常try…catch

 

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

1.该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。

2.在方法中使用try-catch的语句块来处理异常。

try-catch的方式就是捕获异常。

 捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

捕获异常语法如下：

try{

编写可能会出现异常的代码

}catch(异常类型    e){

处理异常的代码

//记录日志/打印异常信息/继续抛出异常

}

try：该代码块中编写可能产生异常的代码。

 

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

 

注意:try和catch都不能单独使用,必须连用。

 

演示如下：

public class TryCatchDemo {

public static void main(String[] args) {

try {// 当产生异常时，必须有处理方式。要么捕获，要么声明。

read("b.txt");

} catch (FileNotFoundException e) {// 括号中需要定义什么呢？

//try中抛出的是什么异常，在括号中就定义什么异常类型

System.out.println(e);

}

System.out.println("over");

}

/*

*

*    我们 当前的这个方法中 有异常 有编译期异常

*/

public static void read(String path) throws FileNotFoundException { if (!path.equals("a.txt")) {//如果不是 a.txt这个文件

//    我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw throw new FileNotFoundException("文件不存在");

}
}

}

1、实验目的与要求

(1) 掌握java异常处理技术；

(2) 了解断言的用法；

(3) 了解日志的用途；

(4) 掌握程序基础调试技巧；

；

2、实验内容和步骤

实验1：用命令行与IDE两种环境下编辑调试运行源程序ExceptionDemo1、ExceptionDemo2，结合程序运行结果理解程序，掌握未检查异常和已检查异常的区别

package week11.test;

    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[]) 
     {
          FileInputStream fis=new FileInputStream("text.txt");//JVM自动生成异常对象
          int b;
          while((b=fis.read())!=-1)
          {
              System.out.print(b);
          }
          fis.close();
      }
}

运行结果：

实验2： 导入以下示例程序，测试程序并进行代码注释。

测试程序1：

l  在elipse IDE中编辑、编译、调试运行教材281页7-1，结合程序运行结果理解程序；

l  在程序中相关代码处添加新知识的注释；

l  掌握Throwable类的堆栈跟踪方法；

package week11.test;

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)
   {

//调用Throwable类的getStackTrace方法访问栈堆轨迹的文本描述信息

      System.out.println("factorial("+n+"):");

       Throwable t=new Throwable();

       StackTraceElement[] frames=t.getStackTrace();
       for(StackTraceElement f:frames)//遍历fames数组
           System.out.println(f);
       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)
   {
       Scanner in=new Scanner(System.in);
       System.out.print("Enter n:");
       int n=in.nextInt();
       factorial(n);
   }
}

运行结果：

测试程序2：

l  Java语言的异常处理有积极处理方法和消极处理两种方式；

l  下列两个简单程序范例给出了两种异常处理的代码格式。在elipse IDE中编辑、调试运行源程序ExceptionTest.java，将程序中的text文件更换为身份证号.txt，要求将文件内容读入内容，并在控制台显示；

l  掌握两种异常处理技术的特点。

//积极处理方式　　

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");

     }

}

//积极处理
import java.io.*;
class ExceptionDemo1 {
public static void main (String args[])
{
File fis=new File("身份证号.txt");
try{

FileReader fr = new FileReader(fis);
BufferedReader br = new BufferedReader(fr);
try {
String s, s2 = new String();
while ((s = br.readLine()) != null) {
s2 += s + "\n ";
}
br.close();
System.out.println(s2);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

//消极处理方式

import java.io.*;
class ExceptionDemo1 {
    public static void main (String args[]) throws  IOException
       {
        File fis=new File("身份证号.txt");
        FileReader fr = new FileReader(fis);
        BufferedReader br = new BufferedReader(fr);
        String s, s2 = new String();

            while ((s = br.readLine()) != null) {
                s2 += s + "\n ";
            }
            br.close();
            System.out.println(s2);
       }
}

运行结果：

积极处理方式：

 消极处理方式：

实验3: 编程练习

l  编写一个计算器类，可以完成加、减、乘、除的操作；

l  利用计算机类，设计一个小学生100以内数的四则运算练习程序，由计算机随机产生10道加减乘除练习题，学生输入答案，由程序检查答案是否正确，每道题正确计10分，错误不计分，10道题测试结束后给出测试总分；

l  将程序中测试练习题及学生答题结果输出到文件，文件名为test.txt；

l  在以上程序适当位置加入异常捕获代码。

注：以下实验课后完成

package week11.test;

public class Calculation {
    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 mutli(int a,int b)
    {
        return a*b;
    }
    public int division(int a,int b)
    {
        if(b!=0)
        {
            return a/b;
        }
        return 0;
    }


}

package week11.test;

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

public class CaclusionTest {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        Calculation  result=new Calculation();
        PrintWriter out=null;
        try {
                out=new  PrintWriter("test.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);
        
            Random n=new Random();
        
        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==result.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==result.mutli(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==result.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==result.reduce(a,b)) {
                sum+=10;
                System.out.println("回答正确");
            }else {
                System.out.println("回答错误");
            }
            break;
           }
        }
        System.out.println("你的总分是:"+sum);
        out.println("成绩："+sum);
        out.close();
        
    }
}
        

运行结果：

 

实验4：断言、日志、程序调试技巧验证实验。

实验程序1：

//断言程序示例

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);

    }

}

l  在elipse下调试程序AssertDemo，结合程序运行结果理解程序；

l  注释语句test1(-5);后重新运行程序，结合程序运行结果理解程序；

l  掌握断言的使用特点及用法。

public class AssertDemo {
    public static void main(String[] args) {        
        test1(-5);
        test2(-3);
    }
    
    private static void test1(int a){
        assert a > 0;//assert宏的原型定义在<assert.h>中，作用是如果它的条件返回错误，则终止程序执行
        System.out.println(a);
    }
    private static void test2(int a){
       assert a > 0 : "这里出错了，a不能小于0";
        System.out.println(a);
    }
}

注释前结果：

 注释后断言开启结果：

实验程序2：

l  用JDK命令调试运行教材298页-300页程序7-2，结合程序运行结果理解程序；

l  并掌握Java日志系统的用途及用法。

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;
            Handler 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(() ->//使事件派发线程上的可运行对象排队
            {
               Handler windowHandler = new WindowHandler();
               windowHandler.setLevel(Level.ALL);
               Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);

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

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

/**
 * 显示图像的帧。
 */
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);

      //设置菜单栏
      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);
            }
         });

      //使用标签显示图像
      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);

         //设置文件选择器
         JFileChooser chooser = new JFileChooser();
         chooser.setCurrentDirectory(new File("."));

         //接受以.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";
               }
            });

         //显示文件选择器对话框
         int r = chooser.showOpenDialog(ImageViewerFrame.this);

         // 如果图像文件被接受，将其设置为标签的图标
         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");
      }
   }
}

/**
 * 用于在窗口中显示日志记录的处理程序。
 */
class WindowHandler extends StreamHandler//继承
{
   private JFrame frame;

   public WindowHandler()
   {
      frame = new JFrame();
      final 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)
            {
            } 

            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的常用调试技术。

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;
            Handler 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(() ->//使事件派发线程上的可运行对象排队
            {
               Handler windowHandler = new WindowHandler();
               windowHandler.setLevel(Level.ALL);
               Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);

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

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

/**
 * 显示图像的帧。
 */
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);

      //设置菜单栏
      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);
            }
         });

      //使用标签显示图像
      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);

         //设置文件选择器
         JFileChooser chooser = new JFileChooser();
         chooser.setCurrentDirectory(new File("."));

         //接受以.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";
               }
            });

         //显示文件选择器对话框
         int r = chooser.showOpenDialog(ImageViewerFrame.this);

         // 如果图像文件被接受，将其设置为标签的图标
         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");
      }
   }
}

/**
 * 用于在窗口中显示日志记录的处理程序。
 */
class WindowHandler extends StreamHandler//继承
{
   private JFrame frame;

   public WindowHandler()
   {
      frame = new JFrame();
      final 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();
   }
}

1）条件断点（有一定条件的断点）：在Eclipse Java 编辑区的行头双击就会得到一个断点，代码会运行到此处时停止。

在断点处点击鼠标右键，选择最后一个“Breakpoint Properties”。

2）变量断点：在变量的值初始化，或是变量值改变时可以停止。

3）方法断点：方法断点就是将断点打在方法的入口处。

4）异常断点：当异常发生时，代码会停在异常发生处。

5）重新调试：回退时，请在需要回退的线程方法上点右键，选择“Drop to Frame”。

6）单步执行程序 

7）检查变量

8）改变变量值

实验总结：在本周学习了程序产生的异常以及如何解决程序中产生的异常。异常时在程序的执行过程中所发生的非正常事件，它中断指令的正常执行。因此在编写代码时需要及时处理这些错误。基本理解了异常的产生的原因和解决方法。但对于断言以及日志等内容不太理解。因此在运行后面几个相关程序时，对程序不是很理解。以后自己也会多练习程序去了解这些知识。

获奖感想与Java阶段性学习总结

获奖感想

• 对于期中考试后获得小黄衫倍感意外，学习java的过程刚开始是很枯燥的，但慢慢的发现其中的一些乐趣以后，就能够慢慢的去发现去探索各种java程序的应用，更是感谢助教牛百泉学长每周五坚持开直播 为我们答疑解惑，通过实践来让我们掌握学习内容，更没有想到经过自己不懈的努力，我亦有荣幸获得一件属于我的小黄衫。
• 收获这份殊荣，喜悦之余我也感到了很大的压力。其一，小黄衫不但意味着代老师对我现阶段学习态度的肯定，也意味着更高的期望，想要不辜负这份期望与鞭策，就要继续努力做到更好。其二，小黄衫的获得者，无论是助教牛百泉学长，还是本学期的前几位同学，都是非常值得学习的人，他们的每周的博客园写的非常好，对于知识点的总结更是十分细心，以后应该更应该向他们学习，如果不更加坚实自己的脚步，最终还是会落后于别人，后面学习要更加的认真才可以。

阶段性总结

1、自主学习

从这门课程一开始，代就给我传递了自主学习的思想。它不同于我们以往接受的填鸭式教学，而是以你自己为主导去学习。这样的学习方式中，你要自己分配时间，自己查找资料，在mooc中先完成自学，在代老师的课堂上很多疑惑就会感觉到迎刃而解，同时遇到问题要自己动手解决。如同字面意思一样，在一次又一次的”doing“中，你的知识概念从模糊到清晰。起初或许会感到有些麻烦，但你会真切的感到自己能力的提高，真正的尝试思考，每一点成果都有你的思考，并且通过实践掌握的语法点更加牢固。

2、多加练习

掌握了基本的语法点以后更重要的是去不断地练习，只有不断地去写程序，我们才能感受到java语言的好处，和这个语法点在实际中不同的用途，同时遇到问题时，我们不要急于求助他人，一定要先想想自己可以怎样解决，实践中出现的问题往往可以通过新的实践来找到解决的办法。但当你遇到瓶颈，无计可施时，不妨听听别人的思路，或者上CSDN、博客园上找找答案，或许会给你的一些启发。就在这样不断的发现问题，解决问题中，我们会迭代式的得到提升。

3、贵在坚持

编程没有捷径，只有不断地坚持，才能获得更好的提升，要合理规划好自己的学习任务，在前半学期还是缺少合理规划，自主学习时间缺少坚持，后面阶段的学习要坚持练习。