201871010126 王亚涛《面向对象程序设计（Java）》第十周实验总结

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

随笔博文正文内容包括：

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

第七章：异常、断言和日志

7.1 处理错误

7.1.1 异常分类

1.非致命异常:通过某种修正后程序还能继续执行。这类错误叫作异常。如：文件不存在、无效的数组下标、空引用、网络断开、打印机脱机、磁盘满等。 Java中提供了一种独特的处理异常的机制，通过异常来处理程序设计中出现的错误。

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

异常都是以Exception结尾的。

在我们写程序的时候难免会出现错误，java中的异常机制为了提高我们程序的健壮性和容错性而存在。

异常体系

Throwable: Throwable类是java语言中所有错误或异常的超类

所有已实现的接口：Serializable

直接已知子类：Error, Exception

Error是throwable的子类，它是程序出现严重的问题，这种问题程序解决不了。

1. 编译期异常

编译期的异常我们必须处理，如果我们不处理就会编译失败。我们必须通过程序来处理编译期的异常

我们两种解决方案：抛出异常，把异常抛给调用当前方法的层内部处理，catch来处理。

除了RuntimeException都是编译期的异常

2. 运行期异常

编译的时候可以通过，但是在运行的时候产生的异常叫做运行期异常。

所有RuntimeException的子类都是运行期的异常

7.1.2 声明受查异常

如果遇到无法处理的情况，Java方法可以抛出一个异常，不仅要告诉编辑器将要返回什么值，还要告诉编辑器有可能发生什么错误。方法应该在其首部声明可能发生的所有异常，遇到以下四种情况时应该抛出异常：1调用一个抛出受查异常的方法；2程序运行过程中发现错误，并且利用throw语句抛出一个受查异常；3程序出现错误；4Java虚拟机和运行时库出现的内部错误。

7.1.3 如何抛出异常

1、定义：一个方法不处理这个异常，而是调用层次向上传递，谁调用这个方法，这个异常就由谁来处理。

2、throw : 将产生的异常抛出(强调的是动作)，抛出的既可以是异常的引用，也可以是异常对象。（位置: 方法体内）

3、throws : 如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。用它修饰的方法向调用者表明该方法可能会抛出异常（可以是一种类型，也可以是多种类型，用逗号隔开）（位置: 写在方法名或方法名列表之后，在方法体之前。）

4、throw 和throws 关键字的区别

1）、写法上 : throw 在方法体内使用，throws 函数名后或者参数列表后方法体前
2）、意义： throw 强调动作，而throws 表示一种倾向、可能但不一定实际发生
3）、throws 后面跟的是异常类，可以一个，可以多个，多个用逗号隔开。throw 后跟的是异常对象，或者异常对象的引用。
4）、throws 用户抛出异常，当在当前方法中抛出异常后，当前方法执行结束（throws 后，如果有finally语句的话，会执行到finally语句后再结束。）。可以理解成return一样。

7.1.4 创建异常类

创建自定义的异常类需要继承自Exception类，并提供含有一个String类型形参的构造方法，该形参就是一场的描述信息，可以通过getMessage()方法获得。例如：

public class NewException extends Exception{
public NewException(String s){//这个s就是自定义的精髓所在，想传啥传啥
super(s);
try catch在main里头用哈，具体的方法里头还是if 判断之后throw new 一个异常。

7.2 捕获异常

捕获异常的方法：

try:

检测范围

except Exception[as reason]

　出现异常(Exception)后的处理代码

finally

最后处理 #检测范围内无错误-> 跳过except->finally

#检测范围内有错误-> 执行except->finally

try:

    f=open("我不是一个文件.txt","w") #文件不存在错误

    print(f.write("hello"))

    sum =1 +"1"  #类型错误

    f.close

except OSError as reason:

    print("文件不存在，错误原因是："+str(reason))

except TypeError as reason:

    print("类型出错啦，错误原因是："+str(reason))

finally:

    f.close

如果你在写python程序时遇到异常后想进行如下处理的话,一般用try来处理异常，假设有下面的一段程序：

try:

    语句1

    语句2

    .

    .

    语句N

except .........:

    do something .......

方法一：捕获所有异常

try:

    a=b

    b=c

except Exception,e:

    print Exception,":",e

方法二：采用traceback模块查看异常

#引入python中的traceback模块，跟踪错误

import traceback

try:

    a=b

    b=c

except:

    traceback.print_exc()

方法三：采用sys模块回溯最后的异常

#引入sys模块

import sys

try:

    a=b

    b=c

except:

    info=sys.exc_info()

    print info[0],":",info[1]

但是，如果你还想把这些异常保存到一个日志文件中，来分析这些异常，那么请看下面的方法：

把　traceback.print_exc()　打印在屏幕上的信息保存到一个文本文件中

import traceback

try:

    a=b

    b=c

except:

    f=open("c:log.txt",'a')

    traceback.print_exc(file=f)

    f.flush()

    f.close()

7.4 使用断言

1.断言概述
断言机制允许在测试期间向代码中插入一些检查语句，当代码发布时，这些插入的检测语句就会被自动地移走。assertion（断言）是Java1.4引入的一个新特性，该特性的引入的目的是为了辅助开发人员调试和测试，是一种比较常用的调试、测试方案。由于其会对程序的整体设计产生很大影响，目前很少投入到使用中，一般情况下使用的目的是为了调试和测试。
断言表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式为真。

2.常见的断言特性
前置条件断言：代码执行之前必须具备的特性
后置条件断言：代码执行之后必须具备的特性
前后不变断言：代码执行前后不能变化的特性

3.断言使用格式
断言可以有两种形式：
1.assert 布尔表达式
2.assert 布尔表达式：消息
使用第一种格式，当布尔类型表达式为false时，抛出AssertionError异常；如果是第二种格式，则输出错误消息。
7.5 Java日志

1、实验目的与要求

(2) 了解断言的用法；

(3) 了解日志的用途；

(4) 掌握程序基础调试技巧；

2、实验内容和步骤

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

      }

}

异常示例1截图运行截图如下：

显示错误为：main”java.lang.arithmeticexception中的异常：0

异常示例2运行截图如下：

显示错误为：“main”java.io.filenotfoundexception:text.txt中的异常

检测异常后：

public class ExceptionDemo1 {

    public static void main(String[] args) {

        int a = 0;

        if(a==0) {

            System.out.println("除数为零");

        }

        else

        {

            System.out.println(5 / a);

        }

    }

}

import java.io.*;

public class ExceptionDemo2{

    public static void main(String args[])

     {

          FileInputStream fis;

        try {

          fis = new FileInputStream("text.txt");

          int b;

          while((b=fis.read())!=-1)

          {

              System.out.print(b);

          }

          fis.close();

        }catch (Exception e) {

              // TODO Auto-generated catch block

              e.printStackTrace();//打印堆栈信息

//            System.out.println("Hello.");

        }//JVM自动生成异常对象

     }

}

运行截图如下：

未检测异常与已检测异常的区别：

已检查异常：指的是一个函数的代码逻辑没有错误，但程序运行时会因为IOException等错误导致异常，你在编写程序阶段是预料不到的。如果不处理这些异常，程序将来肯定会出错。所以编译器会提示你要去捕获并处理这种可能发生的异常，不处理就不能通过编译。
未检查异常：指的是你的程序逻辑本身有问题，比如数组越界、访问null对象，这种错误你自己是可以避免的。编译器不会强制你检查这种异常。也检查不过来，太多了。

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

测试程序1：

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

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

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

例题7.1程序代码如下：

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();//创建一个新的StackWalker

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

      //新创建一个输入的Scanner 对象，然后赋值给in

      {

         System.out.print("Enter n: ");

         int n = in.nextInt();

         factorial(n);

      }

   }

}

程序运行截图如下：

Throwable 类总结：

Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。

两个子类的实例，Error 和 Exception，通常用于指示发生了异常情况。

测试程序2：

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

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

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

//积极处理方式　　

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.*;

import java.io.BufferedReader;

import java.io.FileReader;

class ExceptionTest {

    public static void main (String args[])

   {

           File fis=new File("身份证号.txt");

           try {

               FileReader fr = new FileReader(fis);

                        BufferedReader br = new BufferedReader(fr);

                        try {

                             String s, s2 = new String();

                             while ((s = br.readLine()) != null) {

                                 s2 += s + "\n ";

                             }

                             br.close();

                             System.out.println(s2);

           }catch (IOException e) {

               e.printStackTrace();

           }

       }catch（FileNotFoundExcption e）

       {

           e.printStackTrace();

       }

    }

}

//消极处理方式

import java.io.*;

class ExceptionTest1 {

    public static void main (String args[]) throws  IOException

     {

         File fis=new File("身份证号.txt");

        FileReader fr = new FileReader(fis);

       BufferedReader br = new BufferedReader(fr);

            String s, s2 = new String();

            while ((s = br.readLine()) != null)

            {

                s2 += s + "\n ";

            }

            br.close();

            System.out.println(s2);

     }

}

运行截图如下：

实验3: 编程练习

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

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

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

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

程序代码如下：

import java.util.Random;

import java.util.Scanner;

import java.io.FileNotFoundException;

import java.io.PrintWriter;

public class math{

    public static void main(String[] args)

    {

        yunsuan counter=new yunsuan();//与其它类建立联系

    PrintWriter out=null;

    try {

        out=new PrintWriter("D:/text.txt");

    }catch(FileNotFoundException e) {

        e.printStackTrace();

    }

    int sum=0;

    for(int i=0;i<10;i++)

    {

    int a=new Random().nextInt(100);

    int b=new Random().nextInt(100);

    Scanner in=new Scanner(System.in);

    //in.close();

    switch((int)(Math.random()*4))

    {

    case 0:

        System.out.println( ""+a+"+"+b+"=");

        int c1 = in.nextInt();

        out.println(a+"+"+b+"="+c1);

        if (c1 == counter.add(a, b)) {

            sum += 10;

            System.out.println("答案正确");

        }

        else {

            System.out.println("答案错误");

        }

        break ;

    case 1:

        if(a<b)

                        {

                                 int temp=a;

                                 a=b;

                                 b=temp;

                             }//为避免减数比被减数大的情况

         System.out.println(""+a+"-"+b+"=");

         /*while((a-b)<0)

         {

             b = (int) Math.round(Math.random() * 100);

         }*/

        int c2 = in.nextInt();

        out.println(a+"-"+b+"="+c2);

        if (c2 == counter.reduce(a, b)) {

            sum += 10;

            System.out.println("答案正确");

        }

        else {

            System.out.println("答案错误");

        }

        break ;

    case 2:

         System.out.println(""+a+"*"+b+"=");

        int c = in.nextInt();

        out.println(a+"*"+b+"="+c);

        if (c == counter.multiply(a, b)) {

            sum += 10;

            System.out.println("答案正确");

        }

        else {

            System.out.println("答案错误");

        }

        break;

    case 3:

        System.out.println(""+a+"/"+b+"=");

        while(b==0)

        {  b = (int) Math.round(Math.random() * 100);

        }

     int c0= in.nextInt();

     out.println(a+"/"+b+"="+c0);

     if (c0 == counter.devision(a, b)) {

         sum += 10;

         System.out.println("答案正确");

     }

     else {

         System.out.println("答案错误");

     }

     break;

    }

    }

    System.out.println("totlescore:"+sum);

    out.println(sum);

    out.close();

    }

    }

//import java.util.Random;

public class yunsuan{

    //int a=new Random().nextInt(100);

    //int b=new Random().nextInt(100);

    public int add(int a,int b)

    {

        return a+b;

    }

    public int reduce(int a,int b)

    {

        if((a-b)>0)

        return a-b;

        else return 0;

    }

    public int multiply(int a,int b)

    {

        return a*b;

    }

    public int devision(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);

    }

}

实验截图如下：

注释语句test1(-5);后截图如下：

实验程序2：

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

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

实验截图如下：

实验程序3：

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

l 按课件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;

            Handler 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(() ->

            {

               Handler windowHandler = new WindowHandler();

               windowHandler.setLevel(Level.ALL);

               Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);

               JFrame 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

      JMenuBar menuBar = new JMenuBar();

      setJMenuBar(menuBar);

      JMenu menu = new JMenu("File");

      menuBar.add(menu);

      JMenuItem openItem = new JMenuItem("Open");

      menu.add(openItem);

      openItem.addActionListener(new FileOpenListener());

      JMenuItem 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

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

      final JTextArea 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）：学习了第七章的知识，异了解了常有致命性异常和非致命性异常及断言的定义及日志等。

2）：对于异常处理，老师用两节理论课给我们讲，在课下总结有关异常以及异常处理的知识点。在学习的过程中了解了Java许多相关知识，对Java的知识更加熟悉及掌握，虽然有许多的不懂，但在课下还是一一解决了。

巴特西

201871010126 王亚涛《面向对象程序设计（Java）》第十周实验总结

最新文章

热门文章

巴特西

201871010126 王亚涛 《面向对象程序设计（Java）》第十周实验总结

最新文章

热门文章

201871010126 王亚涛《面向对象程序设计（Java）》第十周实验总结