ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

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

2019-11-04 20:53:15  阅读：177  来源： 互联网

标签：丁宣元 java 201871010106 int import new 异常 public


                                                            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时，不断有问题出现，耗费了很多时间，主要问题还是不熟练，编写的太少。在后来的学习中要弥补前半学期学习的漏洞，多练习。

 

 

标签：丁宣元,java,201871010106,int,import,new,异常,public
来源： https://www.cnblogs.com/budinge/p/11776218.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有