201871010135-张玉晶《面向对象程序设计（java）》第十周学习总结

201871010135-张玉晶《面向对象程序设计（java）》第十周学习总结

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

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

1： 处理错误：

1）用户输入错误；2）设备错误；3）物理限制；4）代码错误

2：  异常分类：所有的异常都是由Throwable继承而来。 分为Error 类和  Exception类

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

Exception类 :    是需重点掌握的异常类。Exception层次结构又分解为两个分支：1）一个分支派生于RuntimeException：2)另一个分支包含其他异常。

RuntimeException为运行时异常类，一般是程序错误产生；

派生于RuntimeException的异常包含下面几种情况：

1）错误的类型转换；

　　　　2）数组访问越界；

　　　　3）访问空指针；

不是派生于RuntimeException的异常包括：

1）试图在文件尾部后面读取数据；

2）试图打开一个不存在的文件；

3）试图根据给定的字符串查找class对象，而这个字符串表示的类并不存在。

Java将派生于Error类或RuntimeException类的所有异常称为未检查异常，编译器允许不对它们异常处理。

3. 声明受查异常

throws : 声明异常

throw :  抛出一个已检查异常

4. 捕获异常

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

try语句 ： 括住可能抛出异常的代码块；

catch语句： 指明要捕获的异常类及相应的处理代码；

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

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

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

finally语句： 指明必须执行的代码块。

try 语句可以只有finally子句，而没有catch子句；也可以有多个catch子句。

可以在一个try块中不或多个异常类型，每个异常类型需要一个单独的catch子句；

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

a :  assert 条件;

b : assert 条件 ：表达式；

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

c : -enableassertions 或 -ea      启用断言

d :  -disableassertions  或 -da   禁用断言

2：实验内容和步骤

实验1：

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

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

IDE环境下：

命令行环境下：

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

IDE环境下：

命令行环境下：

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

测试程序1：StackTraceTest.java:

 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();  //调用堆栈的跟踪
       for(StackTraceElement f : frames)
         System.out.println(f);
       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)
    {
       Scanner 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.*;

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

将程序中的text文件更换为身份证号.txt：

 1 //积极的处理方式

 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 {

        }

    }
 }

实验3: 编程练习

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

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

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

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

 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);
         number sf=new number();
                 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();

             }
     }

 public class number {

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

     }

实验主要用到了两个类，主类和计算机类，在主类中创建计算机类对象，随机产生a,b及num，然后进行运算，并判断。最后在主类中将整个操作读入到文件中。

实验4：断言、日志、程序调试技巧验证实验。

实验程序1：

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

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

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

 //断言程序示例
 public class AssertDemo {
     public static void main(String[] args) {
         test1(-);
         test2(-);
     }

     private static void test1(int a){
         assert a > ;  //引用assert关键字对条件进行检测
         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);
     }
 }

禁用断言时：

启用断言时：

启用断言并注释语句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 = ;
             FileHandler 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(() ->
             {
                WindowHandler windowHandler = new WindowHandler();
                windowHandler.setLevel(Level.ALL);
                Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);

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

       // 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();
       JTextArea 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：

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

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

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

             

实验总结 ： 在本次实验中我学到了 异常，断言及日志。所有的异常都是由Throwable继承而来。 分为Error 类和  Exception类。  Error类：  描述了Java运行时系统的内部错误和资源耗尽错误。应用程序不应该捕获这类异常，也不会抛出这种异常，Exception层次结构又分解为两个分支：1）一个分支派生于RuntimeException：2)另一个分支包含其他异常。  RuntimeException为运行时异常类，一般是程序错误产生； Java将派生于Error类或RuntimeException类的所有异常称为未检查异常，编译器允许不对它们异常处理。    throws : 声明异常， throw :  抛出一个已检查异常。 在捕获异常中， try 语句可以只有finally子句，而没有catch子句；也可以有多个catch子句。 断言  :  assert 条件;    assert 条件 ：表达式；  -enableassertions 或 -ea      启用断言    -disableassertions 或 -da      启用断言 。 本次实验相对来说还可以，比前面的简单一点点。