201871010106丁宣元 《面向对象程序设计（java)》第十周学习总结

                                                            201871010106-丁宣元 《面向对象程序设计（java)》第九周学习总结

正文开头:

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

正文内容:

第一部分：总结第七章理论知识

　　7-1异常

  　　　　(1)   异常：程序的执行过程中发生的异常，中断指令的正常执行。eg:数组越界

　　　　（2）任务:将控制权从错误产生的地方转移给能够处理这种情况的错误处理器。

　　　　（3）可能出现的错误和问题：用户输入错误;设备错误;物理限制;代码错误

 　　　　 (4）分类：非致命异常：修正后程序可继续执行。eg：文件不存在，无效的数组下标

　　　　　　　　     致命异常：不正常的状态，不能简单执行恢复。eg：内存耗尽，系统内部错误

　　　　异常类都直接或间接地继承于Throwable类。除内置异常类外，程序员可自定义异常类。

  　　　　（5）Java的异常类分为两大类：Error类：系统的内部错误和资源耗尽错误。一般不由程序处理

　　　　　　　　　　　　　　　　　　　Exception类：一.派生于Runtime Exception：运行时异常类，程序错误产生：eg:

　　　　　　　　　　　　　　　　　　　　　　错误类型转换，数组访问越界，访问空指针

　　　　　　　　　　　　　　　　　　　　　　　　     二.其他异常。eg:数组越界,无效URL

　　　　　　　　　　　　　　　　　　　　　　通常是由环境引起的，可以被处理。

         未检查异常：派生于Error类，Runtime Exception类的所有异常，编译器不进行异常处理。

                    Runtime Exception异常一定是程序员的问题。

　　 已检查异常：除运行异常，其他继承自Exception类的异常类：文件尾部后面读取数据......

　　　　　　详见：

　　　　（6）声明抛出（已检查）异常:一个方法可能会生成一些异常，但是该方法并不确切知道如何对这些异常进行处理，此时，这个方法就声明抛出异常。

　　　　声明抛出异常在方法声明中用throws子句中来声明，可以同时指多个异常。

　　　　throws子句声明抛出异常：

　　　　　　方法调用了一个抛出已检查异常的方法；

　　　　　　程序运行过程中可能发生错误，并且利用throw语句抛出一个已检查异常对象

　　　　　　程序出现错误

　　　　　　Java虚拟机和运行时库出现的内部异常。

　　　　 方法必须声明该方法所有可能抛出的已检查异常

　　     (7)抛出异常要生成异常对象，异常对象可由某些类的实例生成，也可以由JVM生成。

　　　（8）抛出异常：throw new EOFException()

　　　   (9)创建异常类:自定义异常类：一个派生于Exception的直接或者间接子类.

　　　　　　　　　　　　　　　　　　包括两个构造器：默认;带有详细描述信息的构造器。

　　7-2捕获异常

　　（1)捕获定义：异常发生时，Java运行系统从异常生成的代码块开始，寻找相应的异常处理代码，并将异常交给该方法处理。

　　（2)某个异常发生时，若程序没有在任何地方进行该异常的捕获，则程序就会终止执行，并在控制台上输出异常信息。

　　（3)捕获一个异常， try/catch/ finally块：

        　　　　 try：可能抛出异常的代码段。

        　　　　 catch：要捕获的异常及相应的处理代码。

        　　　　 finally：必须执行的程序块。

              eg:try:{...}

　　　　　　catch(Exception e){...}

　　　　　　finally{...}

　　注：catch子句:

       　　1.catch语句只需要一个形式参数指明它所能捕获的异常类对象，这个异常类必须是Throwable的子类，运行时系统通过参数值把被抛出的异常传递给catch块；

       　　2.通过异常对象调用类Throwable所提供的方法：

           　　　　getMessage()用来得到有关异常事件的信息；

           　　　　printStackTrace()用来跟踪异常事件发生时执行堆栈的内容。

      一个try块中可捕获多个异常类型，每个异常类型需要一个单独的catch子句。

　　　　3.顺序：

　　　　　　当捕获一个异常时，剩下的catch语句不在匹配

　　　　　　先捕获最特殊的异常，在一般化。即先子类再父类

　　　　　　catch也可抛出异常类

　　　　       finally 子句：捕获异常的最后一步是通过finally语句为异常处理提供一个统一出口，使得控制流程在转到程序其他部分以前，能够对程序的状态做统一的管理；

　　　　　　　　不管异常是否被捕获，finally子句中的代码都会被执行。

　　（4)异常处理中分析堆栈跟踪元素：

　　　　　　堆栈跟踪：程序执行中一个方法调用过程的列表，包含了程序执行过程中的特定位置。可用Throwable类的printStack Trace方法访问堆栈跟踪的文本描述信息。

　　（5）异常处理方式：积极处理方法：确切知道如何处理的异常应该捕获

　　　　　　　　　　　　消极处理方法：不知道如何去处理的异常声明抛出。

　   （6）异常处理的原则

　　　　a.不能代替简单的条件检测，只在异常情况下使用异常机制

　　　　b.异常类型尽可能明确。

　7-3断言

　　1.断言定义:程序的开发和测试阶段用于插入一些代码错误检测语句的工具。

　　2. 语法如下:assert 条件
　　　　　　　　assert 条件:表达式
　　3.使用：默认情况下，断言是关闭的，需要打开：方法：打开eclipse，点击windows->preference->点击java->installed->选jre1.0（自己电脑安装的eclipse的版本）->edit（编辑）->最后，在Default VM arguments中输入-ea

　　　　　　可以对某个类或包打开

　　4.使用时间：仅在测试阶段用来定位错误

　　　　　　　　可在反复的前置条件或后置条件来添加，也可在任何方法内

　7-4调试技术

　　　1.java程序中的调试

　　　　　　应用局部Boolean变量

　　　　　　应用全局Boolean变量

　　　　　　使用断言

　　　2.eclipse中的调试

　　　　条件断点

 　　变量断点

　　方法断点

 　　异常断点

 　　重新调试：

 　　单步部执行，检查变量，改变变量值

 第二部分：实验内容和步骤

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

　　　　异常1：

　　　　　　代码：

//异常示例1
public class ExceptionDemo1 {
	public static void main(String args[]) {
		int a = 0;
		System.out.println(5 / a);//分母不能为0，发生异常，程序中断
	}
}

 

　　　　　　IDE下编辑调试运行:

　　　　 命令行下运行:

 　　    异常2：

　　　　　　代码：

//异常示例2
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();
      }
}

 　　　　程序存在问题：Unhandled exception type FileNotFoundException，需要修改

            修改1：add throws declaration

//异常示例2
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();
      }
}

               IDE运行：

　　       命令行运行：

 　　   修改2:Surround with try/catch

//异常示例2
import java.io.*;

public class ExceptionDemo2 {
    public static void main(String args[]) 
     {
          FileInputStream fis = null;
        try {                                //try-catch语句
            fis = new FileInputStream("text.txt");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }//JVM自动生成异常对象
          int b;
          try {                               //try-catch语句
            while((b=fis.read())!=-1)
              {
                  System.out.print(b);
              }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
          try {                                 //try-catch语句
            fis.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
      }
}

　　        IDE运行：

　　       命令行运行：

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

　　　　测试程序1：

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

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

 　　   掌握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)
   {
      System.out.println("factorial(" + n + "):");
      Throwable t =new Throwable();
      StackTraceElement[] frames=t.getStackTrace();//使用etStackTrace方法，得到一个StackTraceElement的对象，名为frames
      for(StackTraceElement f:frames)  
          System.out.println(f);//foreach循环遍历打印frames的元素
      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.println("Enter n:");
         int n = in.nextInt();
         factorial(n);
      }
   }

 　　   结果：

 　　  测试程序2：

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

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

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

 

//积极处理方式　　

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

     }

}

 

 　　代码：ExceptionTest.java积极：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class ExceptionTest {
    public static void main(String[] args) throws IOException {
        try {
            FileInputStream fis = new FileInputStream("E://身份证号.txt");
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String m, n = new String();
            while ((m = in.readLine()) != null) {
                n += m + "\n ";
            }
            in.close();
            System.out.println(n);

        } catch (FileNotFoundException e) {
            System.out.println("文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("文件错误");
            e.printStackTrace();
        }
    }
}

　　结果：

 　　代码：ExceptionTest.java消极：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class ExceptionTest2 {
    public static void main(String[] args) throws IOException {
            FileInputStream fis = new FileInputStream("E://身份证号.txt");
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String m, n = new String();
            while ((m = in.readLine()) != null) 
            {
                n += m + "\n ";
            }
            in.close();
            System.out.println(n);
    }
}

　　结果：

     　实验3: 编程练习　　

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

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

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

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

　　 思路：两个类：class Arithmetic

　　　　　　　　　class Num：a,b两个私有域（即计算数值）

　　　　　　　　　　　　　　加，减，乘，除构造方法

　　 代码：Arithmetic.java

 

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

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

        Scanner in = new Scanner(System.in);
        Num counter = new Num();
        PrintWriter out = null;
        try {
            out = new PrintWriter("text.txt");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            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 == counter.divide(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.multiply(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.subract(a, b)) {
                    sum += 10;
                    System.out.println("答案正确");
                } else {
                    System.out.println("答案错误");
                }
                break;

            }

        }
        System.out.println("分数为" + sum);
        out.println("分数为:" + sum);
        out.close();

    }
}

 

　　　　Num.java

package Arithmetic1;
public class Num {
    private int a;
    private int b;

    public int add(int a, int b) {//加
        return a + b;
    }

    public int subract(int a, int b) {//减
        return a - b;
    }

    public int multiply(int a, int b) {//乘
        return a * b;
    }

    public int divide(int a, int b) {//除
        if (b != 0)
            return a / b;//分母不能为0
        else
            return 0;//若分母为0，直接返回0
    }

}

　　　　结果：

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

　　　　实验程序1：

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

 

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

 

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

 

//断言程序示例
public class AssertDemo {
    public static void main(String[] args) {        
        test1(-5);
        test2(-3);
    }
    
    private static void test1(int a){
        assert a > 0;//assert作用:若它的条件错误，则终止程序执行
        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);
    }
}

 　　　　结果：

 　　注：断言需要打开：

　　　　打开方法：打开eclipse，点击windows->preference->点击java->installed->选jre1.0（自己电脑安装的eclipse的版本）->edit（编辑）->最后，在Default VM arguments中输入-ea

　　　　按照上述步骤即可打开断言

　　未打开断言：

 　　注释语句test1(-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);
    }
}

　　结果：

 　　   实验程序2：

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

并掌握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            //try-catch语句
         {
            Logger.getLogger("com.horstmann.corejava").setLevel(Level.ALL);//得到日志记录器
            final int LOG_ROTATION_COUNT = 10;//常量LOG_ROTATION_COUNT为10
            var 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(() ->    //事件派发线程上的可运行对象排队
            {
               var windowHandler = new WindowHandler();
               windowHandler.setLevel(Level.ALL);
               Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);

               var 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菜单栏
      var menuBar = new JMenuBar();
      setJMenuBar(menuBar);

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

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

      var 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设置文件选择器
         var chooser = new JFileChooser();
         chooser.setCurrentDirectory(new File("."));

         // accept all files ending with .gif 接受以.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();
      var 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：

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

　 按课件66-77内容练习并掌握Elipse的常用调试技术。

　　代码：

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            //try-catch语句
         {
            Logger.getLogger("com.horstmann.corejava").setLevel(Level.ALL);//得到日志记录器
            final int LOG_ROTATION_COUNT = 10;//常量LOG_ROTATION_COUNT为10
            var 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(() ->    //事件派发线程上的可运行对象排队
            {
               var windowHandler = new WindowHandler();
               windowHandler.setLevel(Level.ALL);
               Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);

               var 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菜单栏
      var menuBar = new JMenuBar();
      setJMenuBar(menuBar);

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

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

      var 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设置文件选择器
         var chooser = new JFileChooser();
         chooser.setCurrentDirectory(new File("."));

         // accept all files ending with .gif 接受以.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();
      var 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.java异常的概念及处理方法：try-catch-finally;throws             

　　　　　　　　　　　　　　　　　　       2.断言定义及用法　　          

　　　　　　　　　　　　　　　　　　　　3.如何在eclipse中打开断言                     

　　　　　　　　　　　　　　　　　　　　4.了解日志的基本知识　　　　         

　　　　　　　　　　　　　　　　　　　　5.了解程序基础调试技巧，尝试进行调试

　　    在本次实验中，加深了我对异常处理，断言的理解，学会了如何处理异常及如何打开断言。主要问题是对知识的理解上还是不够。要多下一些功夫，听MOOC，结合书进一步理解。还有问题的是四则运算编写，基本上有一个大致的思路，但在编写Arithmetic.java时，不断有问题出现，耗费了很多时间，主要问题还是不熟练，编写的太少。在后来的学习中要弥补前半学期学习的漏洞，多练习。