201871010123-吴丽丽 《面向对象程序设计（Java）》第十周学习总结

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

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

一、异常

(1)   异常：在程序的执行过程中所发生的异常事件，它中断指令的正常执行。

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

（3）程序中可能出现的错误和问题：a.用户输入错误。b.设备错误。c.物理限制。d.代码错误。

（4）Java中把程序运行时可能出现的错误分为两类：

A:非致命异常：通过某种修正后程序还能继续执行。如：文件不存在，网络断开，无效的数组下标，磁盘满等。Java中提供了一种独特的异常处理机制处理这类             错误。

B:致命异常：程序用到了非常严重的不正常的状态，不能简单执行恢复，是致命性错误。如：内存耗尽，系统内部错误。这种错误程序本身无法解决。

（5）Java中所有异常类都直接或间接地继承于Throwable类。除內置异常类外，程序员可自定义异常类。

(6)  Java的异常类可分为两大类：

A：Error类：描述了java运行时系统的内部错误和资源耗尽错误。应用程序不应该捕获这类异常，也不会抛出这种异常。（很难恢复的严重错误，一般不由程序处理）

B：Exception类：分为两分支，一个分支派生于Runtime Exception；另一个分支包含其他异常。（程序设计或者实现上的问题，如数组越界等）。其他异常：通常是由环境引起的，并且可以被处理。

（7）Java异常层次结构简化示意图如下：

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

A:声明抛出异常在方法声明中用throws子句中来声明，throws子句可以同时指多个异常，说明该方法将不对这些异常进行处理，而是声明抛出它们。

B:以下四种情况用throws子句声明抛出异常：

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

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

—程序出现错误

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

C:一个方法必须声明该方法所有可能抛出的已检查异常，而未检查异常要么不可控制(Error),要么应该避免发生(RuntimeException).

D:如果方法没有声明所有可能发生的已检查异常，编译器会给出一个错误消息。

(9) 当Java应用程序出现错误时，会根据错误类型产生一个异常对象，这个对象包含了异常的类型和错误出现时程序所处的状态信息。把异常对象递交给Java编译器的过程称为抛出。

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

(11)抛出异常对象通过throw语句来实现。

(12)创建异常类

A:自定义异常类：定义一个派生于Exception的直接或者间接子类。自定义的异常类应该包括两个构造器：a:默认构造器b:带有详细描述信息的构造器。

二：捕获异常

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

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

（3)若要捕获一个异常，需要在程序中设置一个 try/catch/ finally块：

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

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

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

（4)try子句：捕获异常的第一步是用try{….}子句选定捕获异常的代码范围，由try所限定的代码块中的语句，在执行过程中可能会自动生成异常对象并抛出。

（5)catch子句:

a)catch块是对异常对象进行处理的代码；

b)每个try代码块可以伴随一个或多个catch语句，用于处理try代码块中所生成的格类异常事件；

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

d)catch块可以通过异常对象调用类Throwable所提供的方法。

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

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

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

（6)finally 子句：

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

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

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

A:堆栈跟踪(staack trace)是程序执行中一个方法调用过程的列表，它包含了程序执行过程中的特定位置；

B:可用Throwable类的printStack Trace方法访问堆栈跟踪的文本描述信息。

三：使用异常机制的建议：

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

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

四：异常处理的原则

(1)异常处理不能代替简单的条件检测，只在异常情况下使用异常机制。例如:上百万次地对一个空栈进行退栈操作。

(2)程序代码不要过分细化异常，尽量将有可能产生异常的语句放在--个try语句块中。

(3)抛出的异常类型尽可能明确。

(4)不要压制异常，对于很少发生的异常，应该将其关闭。

(5) 早抛出，晚捕获，尽量让高层次的方法通告用户发生了错误。

五：断言

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

2.断言(assert) 语法如下:
1）assert 条件

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

第二部分：实验部分

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

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

在命令行环境下运行结果如下：

在ID环境下程序运行结果如下：

//异常示例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())!=-)
          {
              System.out.print(b);
          }
          fis.close();
      }
}

该程序存在文件找不到的错误，对该程序修改后，修改后代码如下：

//异常示例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())!=-)
          {
              System.out.print(b);
          }
          fis.close();
      }
}

该程序在命令行环境下运行结果如下：

在ID环境下运行结果如下：

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

测试程序1：

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

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

3）掌握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 + "):");
       var walker = StackWalker.getInstance(); //创建对象时调用堆栈的跟踪
       walker.forEach(System.out::println);    //调用对象walker的foreach循环
       int r;
       if (n <= ) r = ;
       else r = n * factorial(n - );     //计算n的阶乘需要去调用n-1的阶乘
       System.out.println("return " + r);
       return r;
    }
 
    public static void main(String[] args)
    {
       try (var in = new Scanner(System.in)) //try语句块
       {
          System.out.print("Enter n: ");
          int n = in.nextInt();
          factorial(n);
       }
    }
 }

程序运行结果如下：

测试程序2：

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

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

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

//积极处理方式　　

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 ExceptionTest {
     public static void main (String args[])
    {
 
        try{
            FileInputStream fis=new FileInputStream("D://身份证号.txt");
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String s = new String();
            while ((s = in.readLine()) != null) {
                System.out.println(s);
            }
            in.close();
            fis.close();
        }
        catch (FileNotFoundException e) {
            System.out.println("文件未找到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("文件读取错误");
            e.printStackTrace();
        }
 }
 }

消极处理方式的代码如下：

 import java.io.*;
 
 public class ExceptionTest {
     public static void main (String args[]) throws IOException
    {
 
        try{
            FileInputStream fis=new FileInputStream("D://身份证号.txt");
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String s = new String();
            while ((s = in.readLine()) != null) {
                System.out.println(s);
            }
            in.close();
            fis.close();
 
        }
        finally {
         return ;
        }
 
    }
 }

程序运行结果如下：

实验3: 编程练习

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

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

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

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

分析：

程序代码如下：

package CounterTest;
 
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
 
public class counter {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        sf sf=new sf();
                PrintWriter output = null;
                try {
                    output = new PrintWriter("test.txt");
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
                int sum = ;
 
                for (int i = ; i < ; i++) {
                    int a = (int) Math.round(Math.random() * );
                    int b = (int) Math.round(Math.random() * );
                    int num = (int) Math.round(Math.random() * );
 
                   switch(num)
                   {
                   case :
                       System.out.println(i+": "+a+"/"+b+"=");
                       while(b==){
                           b = (int) Math.round(Math.random() * );
                           }
                       double c = in.nextDouble();
                       output.println(a+"/"+b+"="+c);
                       if (c == sf.chu_fa(a, b)) {
                           sum += ;
                           System.out.println("恭喜答案正确");
                       }
                       else {
                           System.out.println("抱歉，答案错误");
                       }
                       break;
 
                   case :
                       System.out.println(i+": "+a+"*"+b+"=");
                       int c1 = in.nextInt();
                       output.println(a+"*"+b+"="+c1);
                       if (c1 == sf.chen_fa(a, b)) {
                           sum += ;
                           System.out.println("恭喜答案正确");
                       }
                       else {
                           System.out.println("抱歉，答案错误");
                       }break;
                   case :
                       System.out.println(i+": "+a+"+"+b+"=");
                       int c2 = in.nextInt();
                       output.println(a+"+"+b+"="+c2);
                       if (c2 == sf.jia_fa(a, b)) {
                           sum += ;
                           System.out.println("恭喜答案正确");
                       }
                       else {
                           System.out.println("抱歉，答案错误");
                       }break ;
                   case :
                       System.out.println(i+": "+a+"-"+b+"=");
                       int c3 = in.nextInt();
                       output.println(a+"-"+b+"="+c3);
                       if (c3 == sf.jian_fa(a, b)) {
                           sum += ;
                           System.out.println("恭喜答案正确");
                       }
                       else {
                           System.out.println("抱歉，答案错误");
                       }break ;
 
                     } 
 
                  }
                System.out.println("成绩"+sum);
                output.println("成绩:"+sum);
                output.close();
 
            }
    }

package CounterTest;
 
public class sf {
 
           private int a;
           private int b;
            public int  jia_fa(int a,int b)
            {
                return a+b;
            }
            public int   jian_fa(int a,int b)
            {
 
                return a-b;
            }
            public int   chen_fa(int a,int b)
            {
                return a*b;
            }
            public int   chu_fa(int a,int b)
            {
                if(b!=)
                return a/b;
                else
            return ;
            }
 
    }

程序运行结果如下：

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

    }

}

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

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

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

程序运行结果如下：

注释语句test1(-5);后代码如下：

package project;
 
//断言程序示例
public class AssertDemo {
  public static void main(String[] args) {
      //test1(-5);
      test2(-);
  }
 
  private static void test1(int a){
      assert a > ;
      System.out.println(a);
  }
  private static void test2(int a){
     assert a >  : "something goes wrong here, a cannot be less than 0";
      System.out.println(a);
  }
}

运行结果如下：

实验程序2：

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 = ;
             var handler = new FileHandler("%h/LoggingImageViewer.log", , 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 = ;
    private static final int DEFAULT_HEIGHT = ;   
 
    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();
             }
          });
 
       // 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(, );
       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：

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

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

①条件断点 –在Eclipse Java 编辑区的行头双击就会得到一个断点， 代码会运行到此处时停止。

–条件断点，顾名思义就是一个有一定条件的断点，只有满足了用户设置的条件，代码才会在运行到断点处时停止。

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

添加断点

点击“Breakpoint Properties”之后：

②变量断点–断点不仅能打在语句上，变量也可以接受断点：

上图就是一个变量的打的断点，在变量的值初 始化，或是变量值改变时可以停止，当然变量 断点上也是可以加条件的，和上面的介绍的条 件断点的设置是一样的。

③方法断点 –方法断点就是将断点打在方法的入口处：

–方法断点的特别之处在于它可以打在JDK的源码里，由于JDK在编译时去掉了调试信息，所以普通断点是不能打到里面的，但是方法断点却可以，可以通过这种方法查看方法的调用栈。

④异常断点

–经常遇见一些异常，然后程序就退出来了，要找到异常发生的地方就比较难了，还好可以打一个异常断点。

–上图中我们增加了一个NullPointException的异常断点，当异常发生时，代码会停在异常发生处，定 位问题时应该比较有帮助。

⑤重新调试
–这种调试的回退不是万能的，只能在当前线程的栈帧中回退，也就说最多只能退回到当前线程的调用的开始处。

–回退时，请在需要回退的线程方法上点右键，选择 “Drop to Frame”。

实验总结：本周学习了第七章的知识，异常有致命性异常和非致命性异常，后者，可以通过程序员的相关操作进行处理，通过学习知道利用try子句捕获异常代码的范围，它的执行过程中生成异常对象并抛出异常，不论代码块中是否有异常，finally块中的语句都执行；验证了积极处理方式和消极处理方式，分别用throws子句和try子句；总而言之理论知识可以通过课件以及基本理解了相关概念，但是自己实验的动手能力不断地提高。在本次自主编程实验中，虽然那程序可以运行，但是那test.txt文本没有出现，觉得自己在这方面还是不太熟悉，有欠缺，但课后自己会找时间将这部分内容再重新学习。

获奖感言：

很荣幸能获得这一次的微软小黄衫奖励，这既是对我学习肯定也是我更加努力学习的动力。我知道我能获得这次奖励和老师上课时的敦敦教诲，助教的悉心指导，同学们的热心帮助分不开的，非常感谢大家，今后的学习生活中我一定会更加努力，不辜负大家对我的支持。