201871010102常龙龙《面向对象程序设计（java）》第十周学习总结

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

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

 一、异常

 概念：程序执行过程中所发生的异常事件，它中断指令的正常执行。

●Java的异常处理机制可以控制程序从错误产生的位置转移到能够进行错误处理的位置。
●程序中出现的常见错误和问题有:
                        1.用户输入错误

                        2.设备错误

                        3. 物理限制

                        4.代码错误       

●Java把程序运行时可能遇到的错误分为两类：非致命异常和致命异常。

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

● Java的异常类可分为两大类:

      1.Error

                 Error类层次结构描述了Java运行时系统的内部错误和资源耗尽错误。应用程序不应该捕获这类异常，也不会抛出这种异常。

      2.Exception

                Exception类是需重点掌握的异常类。Exception层次结构又分解为两个分支:一个分支派生于Runt imeException;另-一个分支包含其他异常。   

●Runt imeExcept ion为运行时异常类，一般是程序 错误产生。

●派生于RuntimeExcept ion的异常包含下面几种情况:
          1.错误的类型转换

          2.数组访问越界

          3.访问空指针

●Java将派生于Error类或Runt imeException类的所有异常称为未检查异常，编译器允许不对它们异常处理。注意:“ 如果出现RuntimeException异常，就一定是程序员的问题! ! !”          
●RuntimeException: 运行时异常类
         1.Ari thmeticException:算术异常类.

         2.ArrayStoreException:数组存储异常类

         3.ClassCastException:类型强制转换异常类-

         4.IndexOutOfBoundsException: 下标越界异常类.

         5.Nul lPointerException: 空指针异常类

         6.SecurityExcept ion:违背安全原则异常类  

●I0Exception: 输入输出异常类
         1.I0Exception: 申请I/0操作没有正常完成。

         2.EOFException:在输入操作正常结束前遇见了文件结束符。
         3. Fi leNotFountException: 在文件系统中，没有找到由文件名字符串指定的文件。

二、抛出异常

●声明抛出异常:如果-一个方法可能会生成-一些异常，但是该方法并不确切知道如何对这些异常事件进行处理，此时，这个方法就需声明抛出这些异常。

●一个方法不仅需要告诉编译器将要返回什么值,还要告诉编译器可能发生什么异常

●声明抛出异常在方法声明中用throws子句中来指明。例如:
                  public FileInputStrean (String name ) throws FileNotFoundExcept ion
●throws子句可以同时指明多个异常，说明该方法将不对这些异常进行处理，而是声明抛出它们。
                  public static void main(String argsO]) throwsI0E xcept ion, IndexOutOfBoundsException   

●首先决定抛出异常类型。例如:当从一个长为1024的文件中读取数据时，但读到733时遇到了文件结束标记，此时应抛出一个异常，E0FException比较合适。
●代码为:
                  throw new E0FExcept ion() ;

或者:
                  EOFException e= new EOFException();

                  throw e;       

●对于已存在的异常类，抛出该类的异常对象非常容易，步骤是:
                1.找到一个合适的异常类；

                2.创建这个类的一一个对象;

                3将该对象抛出。

●一个方法抛出了异常后，它就不能返回调用者了。

创建异常类
●自定义异常类:定义一个派生于Exception的直接或间接子类。如一个派生于IOException的类。

●自定义异常类应该包括两个构造器:
               1.默认构造器;
               2.带有详细描述信息的构造器(超类Throwable的toString方法会打印出这些详细信息，有利于代码调试)   

三、捕获异常

●程序运行期间，异常发生时，Java运行系统从异常生成的代码块开始，寻找相应的异常处理代码，并将异常交给该e方法处理，这一过程叫作捕获。

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

●若要捕获-一个异常，需要在程序中设置一个try/catch/finally块:

      1.try语句括住可能抛出异常的代码段。

      2.catch语句指明要捕获的异常类及相应的处理代码。

      3.finally语句指明必须执行的程序块。  

●代码如下：

    try{

           ...

    }catch(Expection e){

         ...

   }finally{

        ...}

●程序编码时异常处理的两种方式
       1.积极处理方式
                确切知道如何处理的异常应该捕获

       2.消极处理方式
                不知道如何去处理的异常声明抛出。          

四、断言

●断言:是程序的开发和测试阶段用于插入一些代码错误检测语句的工具。
●断言(assert) 语法如下:
          1、assert 条件

   或者
          2、assert 条件:表达式
这两个形式都会对布尔“条件”进行判断，如果判断结果为假.(false)，说明程序已经处于不正确的状态下，系统则抛出AssertionError,给出警告并且退出。在第二种形式中，“表达式” 会传入Assert ionError的构造函数中并转成一个消息字符串。

第二部分：实验部分

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

//异常示例1

public class ExceptionDemo1 {

public static void main(String args[]) {

int a = 0;

System.out.println(5 / a);

}

}

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

      }

}

示例一命令行运行结果如下：

示例二命令行运行结果如下：

示例一IDE运行结果如下 ：

                                         示例一IDE运行结果如下 ：   

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

测试程序1：

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

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

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

代码如下：

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 + "):");
      //创建堆栈对象
      var walker = StackWalker.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 (var in = new Scanner(System.in))
      //避免产生异常
      {
         System.out.print("Enter n: ");
         int n = in.nextInt();
         factorial(n);
      }
   }
}

运行结果如下：

测试程序2：

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

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

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

积极处理方式代码如下：

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

class ExceptionTest {
    public static void main (String args[])
   {
       try{
           FileInputStream fis=new FileInputStream("身份证号.txt");
           BufferedReader in = new BufferedReader(new InputStreamReader(fis));
           String temp = null;
           while ((temp=in.readLine()) != null) {
               System.out.println(temp);
           }
       }
       catch(FileNotFoundException e)
        {  
           System.out.println("error!");
        } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    
    }
}

运行结果如下：

消极处理方式代码如下：

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

class ExceptionTest {
    public static void main (String args[]) throws  IOException
     {
         FileInputStream fis=new FileInputStream("身份证号.txt");
         BufferedReader in=new BufferedReader(new InputStreamReader(fis));
         String temp=null;
         while((temp=in.readLine())!=null)
         {
             System.out.println(temp);
         }
     }
}

运行结果如下：

实验3: 编程练习

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

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

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

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

代码如下：

public class operation {
    
    public int plus(int a,int b)
    {
        return a+b;
    }
    
    public int subtract(int a,int b)
    {
        return a-b;
    }
    
    public int multiple(int a,int b)
    {
        return a*b;
    }
    
    public int divide(int a,int b)
    {
        return a/b;
    }
}

package calculate;

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


public class main {

    public static void main(String[] args){
        // TODO Auto-generated method stub
        PrintWriter write=null;
        try {
            write=new PrintWriter("test.txt");
        }catch(FileNotFoundException e) {
            e.printStackTrace();
        }
        Random rand = new Random(); 
        int sum=0;
        int result=0;
        Scanner in=new Scanner(System.in);
        for(int i=1; i<=10; i++)
        {  
             int a =rand.nextInt(100) +1;
             int b =rand.nextInt(100) +1;
             operation cal=new operation();         
             int c =rand.nextInt(4) +1;
             System.out.print("第"+i+"题"+":  ");
             switch(c)
              {
                 case 1:System.out.println(a+"+"+b+"=");
                        int ret=cal.plus(a,b);
                        result=in.nextInt();
                        write.println(a+"+"+b+"="+result);
                        if(result==ret)
                        {
                            System.out.println("答案正确！");
                            sum+=10;
                        }else {
                            System.out.println("答案错误！");
                        }
                        break;
                 case 2:System.out.println(a+"-"+b+"=");
                        ret=cal.subtract(a,b);
                        result=in.nextInt();
                        write.println(a+"-"+b+"="+result);
                        if(result==ret)
                        {
                            System.out.println("答案正确！");
                            sum+=10;
                        }else {
                            System.out.println("答案错误！");
                        }
                        break;
                 case 3:System.out.println(a+"*"+b+"=");
                        ret=cal.multiple(a,b);
                        result=in.nextInt();
                        write.println(a+"*"+b+"="+result);
                        if(result==ret)
                        {
                            System.out.println("答案正确！");
                            sum+=10;
                        }else {
                            System.out.println("答案错误！");
                        }
                        break;
                 case 4:System.out.println("除法只需写出它的整数部分   "+a+"/"+b+"=");
                        ret=cal.divide(a,b);
                        result=in.nextInt();
                        write.println(a+"/"+b+"="+result);
                        if(result==ret)
                        {
                            System.out.println("答案正确！");
                            sum+=10;
                        }else {
                            System.out.println("答案错误！");                   
                        }
                        break;
                 default:System.out.println("error!!!");
             }         
        }
        in.close();
        write.println("总得分为："+sum);
        write.close();
        System.out.println("你的总得分是："+sum);
    }
}

运行结果如下：

 

 思维导图如下：

实验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)后的运行结果如下：

实验程序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
         {
            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();
               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
         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：

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

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

运行图如下：

 

 实验总结：（15分）

通过本周的学习，我学会了当程序出现异常时的各种处理方法，了解了异常，断言和日志的概念。在大量的代码测试过程中，我加深了对代码异常处理的理解。本章的编程练习题对我有很大的影响。我的文本读取原本就不太好，加上平时缺乏练习，所以对这块的掌握的不好。这次的编程练习让我通过扎扎实实的动手基本掌握了对文本读取的理解。所以在今后的学习中，我要多动手，多做编程，这样才能加深对于每一部分的理解。

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