201871010112-梁丽珍《面向对象程序设计（java）》第十周学习总结

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

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

1. 概述：异常就是java程序在运行过程中出现的错误。
2. 异常发生时如何处理，java提供了解决办法：异常处理机制。
3. java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过throw语句手动抛出。
4. 只要在java程序中产生了异常，就会用一个对应类型的异常对象来封装异常，JRE会试图寻找异常处理程序来处理异常。
5. JDK中内建类一些常见的异常类，我们也可以自定义异常。
6. Throwable类是java异常类型的顶层父类，一个对象只有是Throwable类的直接或间接实例，他才是一个异常对象，才能被异常处理机制识别。

异常分类

1、检查性异常：

（1）最具代表性的检查性异常是用户错误或问题引起的异常，这是程序员无法预测的。
（2）例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单的忽略。

2、运行时异常：

（1）运行时异常是可能被程序员避免的异常。
（2）与检查性异常相反，运行时异常可以在编译时被忽略。

3、错误：

（1）错误不是异常，而是脱离程序员控制的问题。
（2）错误在代码中通常被忽略。
（3）例如，当栈溢出时，一个错误就发生了，它们在编译时也是检查不到的。

4、异常分类图解：

Error和Exception类

1. java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。
2. Throwable又派生出Error类和Exception类。

3. Error类：

   （1）Error类以及他的子类的实例，代表了JVM本身的错误。
   （2）错误不能被程序员通过代码处理，Error很少出现。
   （3）因此，程序员应该关注Exception为父类的分支下的各种异常类

4. Exception类：

    

   （1）Exception及他的子类，代表程序运行时发送的各种不期望发生的事件。
   （2）可以被java异常处理机制使用，是异常处理的核心。

5. Error错误是无法恢复，不能获取的，如系统崩溃，虚拟机错误，动态链接失败等。这会导致程序直接中断。
6. Exception是我们常说的异常，他又大致分为两类，一类是运行时异常：RuntimeException，另一类就是其他异常。因为RuntimeException是由Java虚拟机自动抛出并自动捕获，所以又叫非检查异常。而另一类异常就不一样了，需要我们手动的捕获和处理异常，所以叫做检查异常。

异常处理

1. 异常处理机制能让程序在发生异常时，按照代码预先设定的异常处理逻辑，针对性的处理异常，让程序尽最大可能的恢复正常并继续执行，且保持代码的清晰。
2. java中，异常处理的任务就是将执行控制流从异常发生的地方转移到能够处理这种异常的地方去。
3. java异常处理涉及到五个关键字，分别是：try、catch、finally、throw、throws。
   1. try    -- 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。
   2. catch  -- 用于捕获异常。catch用来捕获try语句块中发生的异常。在编写多个catch的时候，捕获范围大的异常一定要放在捕获范围小的异常后面。
   3. finally -- finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果finally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。
   4. throw  -- 用于抛出一个实例化的异常对象。
   5. throws -- 用在方法签名中，用于声明该方法可能抛出的异常，如果方法真的出现异样，将交由调用者来处理。调用了具有throws申明的方法之后，不管异常是否出现，调用者必须使用try...catch处理。调用声明了运行时异常的函数，可以不强制处理，将交给jvm默认处理。

4. 在编写代码处理异常时，对于检查异常，有两种处理方式：

    

   （1）使用try...catch...finally语句块处理
   （2）在函数签名中使用throws声明交给函数调用者caller去解决

　　5、try...catch...finally语句块：

　　（1）try块中放可能发生异常的代码；
　　（2）如果执行完try并且不发生异常，则接着去执行finally块代码以及finally之后的代码；
　　（3）如果执行try中代码发生异常，就会尝试匹配catch块；
　　（4）每一个catch块用于处理一个异常；
　　（5）异常匹配是按照catch块的顺序从上往下寻找的，只有第一个会匹配到的catch块会被执行。
　　（6）try块中的局部变量和catch块中的局部变量，以及finally中的局部变量，它们之间不可以共享使用；
　　（7）finally块不管异常是否发生，只要对应的try块执行了，它一定会执行。
　　（8）finally块通常用来做资源释放操作，关闭文件或者关闭数据库等操作。

　　6、throws/throw：

　　（1）如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。
　　（2）throws 关键字放在方法签名的尾部。
　　（3）throws仅仅是将函数中可能出现的异常向调用者声明，而自己并不处理异常。
　　（4）采用这种异常处理的原因可能是：方法本身不知道如何处理这种异常，或者说让调用者处理更好，调用者需要为可能发生的异常负责。
　　（5）也可以使用 throw 关键字手动抛出一个异常，无论它是新实例化的还是刚捕获到的。
　　（6）throw语句的后面必须是一个异常对象。

异常的捕获

　　try...catch...

　　如果没有我们使用最原始的解决异常是个什么办法：

　　　　　　　　

　　然后 有了能表示所有的异常情况然后处理掉 try...catch

　　　　　　　　

　　如果try块里的业务逻辑代码出现了异常，系统就会生成一个异常对象，然后将该对象提交给Java运行时环境（throw），接着查找catch块，如果找到了合适的catch块，就将该异常对象交由该catch块处理。这个过程又叫做捕获（catch）异常；如果找不到合适的catch块，程序将退出。

finally回收资源

　　finally，最终的，也就是我们处理完异常最后要做的事情。由于有时候我们会在try块里面使用一些资源，这些资源最后也就在finally块里被回收掉了。

　　　　

异常链

　　对于一个完整的应用而言，都是有比较严格的分层关系的，上层依赖下层的API。而对于用户而言，我们不想看到底层的SQL异常，同时也会使得系统不安全。所以这时我们就要将底层的异常捕获，然后再抛出一个新的业务异常，就可以在新的异常中给出用户比较友好的提示信息。　　　　　　　　　　　　　　　

或者我们也可以这样处理异常：

这是由于Throwable基类有了一个可以接受Exception参数的方法。

自定义异常

虽然java已经提供了很多系统性异常，但在开发中还是无法满足实际的需要。所以java允许用户自定义异常。语法如下:

　　　　

总结

1. 处理运行时异常时，采用逻辑去合理规避，同时辅助使用try-catch处理。
2. 在多重catch块后面，加一个catch(Exception)来处理可能遗漏的异常。
3. 对于不确定的代码，也可以加上try-catch，处理潜在的异常。
4. 尽量去处理异常，切记只是简单的调用printStackTrace()去打印输出。
5. 尽量添加finally块去释放所占用的资源。
6. 具体如果处理异常，要根据不同的业务需求和异常类型去决定。

2、实验内容和步骤

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

示例1代码：

package project7;
//异常示例1
public class ExceptionDemo1 {
	public static void main(String args[]) {
		int a = 0;
		System.out.println(5 / a);
	}
}

// 线程中的异常为 ArithmeticException 算术异常
//代码错误 5/0	(ExceptionDemo1.java:6)
//此异常为Throwable类中的子类Exception（RuntimeException/unchecked Exception）

//未检查异常
//编译器不要求强制处理的异常，虽然有可能出现错误，但不会再编译的时候检查

//此算术异常是由程序员失误造成的，编译器没编译之前根本不知道会出现这种错误。
//这种不能被直接检查出的错误被称为非检查型异常，即是不能被try catch捕获的异常

　运行：

示例2代码：

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

//线程中出现的异常： 未解决的编译问题
//异常类型：FileNotFoundException/ IOException
//出现异常处：(ExceptionDemo2.java:8)

//已检查异常
//编译器要求你必须处理的异常（代码还没运行，编译器就会检查你的代码，会不会出现异常，要求你对可能出现的异常必须做出相应的处理）
//编译器要求你对这段代码 try...catch,或者throws exception

/* 对已检查异常的处理：
* 	1、继续抛出，消极的方法，一直可以抛到java虚拟机来处理，就是通过throws exception抛出。
* 	2、用try...catch捕获
* 	注意：对于检查的异常必须处理，或者必须捕获或者必须抛出
* */

运行：

 

实验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();		//调用Throwable类的getStackTrace方法访问堆栈轨迹的文本描述信息
      StackTraceElement[] frames = t.getStackTrace();	//得到StackTraceElement对象的一个数组，并在程序中分析这个对象数组
      for(StackTraceElement f:frames)
    	  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);
      in.close();
   }
}

运行：

测试程序2：

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

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

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

代码1：

package project7;

//积极处理方式　　
import java.io.*;

class ExceptionTest1 {
	public static void main (String args[])
 {
     try{
	       FileInputStream fis=new FileInputStream("F:/身份证号.txt");
	       BufferedReader in = new BufferedReader(new InputStreamReader(fis));
	       try {
	              String s, s2 = new String();
	              while ((s = in.readLine()) != null) {
	                s2 += s + "\n ";
	            }
	             in.close();
	             System.out.println(s2);
     }
     catch (IOException e)
	       {
    	 System.out.println("学生信息文件读取错误");
         e.printStackTrace();

  		}
     }catch (FileNotFoundException e) {
    	 System.out.println("学生信息文件找不到");
    	 e.printStackTrace();
     	}
 	}
}

　　运行：

代码2：

package project7;

//消极处理方式
import java.io.*;

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

　　运行：

实验3: 编程练习

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

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

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

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

代码：

package project7;

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

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

        Scanner in = new Scanner(System.in);
        jieguo student=new jieguo();
        PrintWriter out = null;
        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 c= (int) Math.round(Math.random() * 3);

           switch(c)
           {
           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 == student.division(a, b)) {
                sum += 10;
                System.out.println("right");
            }
            else {
                System.out.println("false");
            }

            break;

           case 1:
               System.out.println(i+": "+a+"*"+b+"=");
               int D = in.nextInt();
               out.println(a+"*"+b+"="+D);
               if (D == student.multiplication(a, b)) {
                   sum += 10;
                   System.out.println("right");
               }
               else {
                   System.out.println("false");
               }
               break;
           case 2:
               System.out.println(i+": "+a+"+"+b+"=");
               int E = in.nextInt();
               out.println(a+"+"+b+"="+E);
               if (E == student.add(a, b)) {
                   sum += 10;
                   System.out.println("right");
               }
               else {
                   System.out.println("false");
               }

               break ;
           case 3:
               System.out.println(i+": "+a+"-"+b+"=");
               int F = in.nextInt();
               out.println(a+"-"+b+"="+F);
               if (F == student.reduce(a, b)) {
                   sum += 10;
                   System.out.println("right");
               }
               else {
                   System.out.println("false");
               }
               break ;
              }
          }
       System.out.println("成绩"+sum);
        out.println("成绩:"+sum);
         out.close();
   }
}

package project7;

public class jieguo {
	   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)
	        return a/b;
	        else return 0;
	    }

}　

运行：

实验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);
    }
}

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

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

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

运行：

注释语句test1(-5);后重新运行程序，控制台只输出-3，不输出-5

实验程序2：

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

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

使用命令行调试。。。调试不出

实验程序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
         {
            Logger.getLogger("com.horstmann.corejava").setLevel(Level.ALL);
          //开启所有级别的记录
            final int 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();//通过Hander类自定义一个处理器
               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");
   //调用Logger类的getLogger方法得到一个日志记录器
   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
         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
{
	//WindowHandler这个处理器扩展于StreamHander类，并且安装了一个流。
    //使用这种方法时，处理器会缓存记录，并且只有在缓存满的时候，才将它们写入流中。
   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)//write方法将流显示输出到文本框中。
            {
            } // not called

            public void write(byte[] b, int off, int len)
            {
               output.append(new String(b, off, len));
             //append  新构造的文件处理器对象应该追加在一个已存在的日志文件尾部，则为TRUE
            }
         });
   }

   public void publish(LogRecord record)
 //将日志发送到目的地
   {
      if (!frame.isVisible()) return;
      super.publish(record);
      flush();//覆盖publish方法，以便在处理器获得每个记录之后刷新缓冲区。
   }
}

结果没能调试运行出来。。。

实验总结：

　　本周主要讲了异常方面的知识，学习了异常的处理方法，感觉自己学的没有特别清楚，尤其是日志方面的知识，最后一个程序阅读特别困难，都没调试出来。。。还需要继续学习。