201871010118唐敬博《面向对象程序设计（java）》第十周学习总结

博文正文开头格式：（2分）

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11435127.html
作业学习目标	(1) 掌握接口定义方法； (2) 掌握实现接口类的定义要求； (3) 掌握实现了接口类的使用要求； (4) 掌握程序回调设计模式； (5) 掌握Comparator接口用法； (6) 掌握对象浅层拷贝与深层拷贝方法； (7) 掌握Lambda表达式语法； (8) 了解内部类的用途及语法要求。

随笔博文正文内容包括：

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

 

7.1 处理错误

如果由于出现错误而是的某些操作没有完成，程序应该；
返回到一张安全状态，并能够让用户执行一些其他的命令
允许用户保存所有操作的结果，并以妥善的方式终止程序
异常处理的任务就是将控制权从错误产生的地方转移给能够处理的错误处理器
在java中，如果某个方法不能够采用正常的途径完整它的任务，就可以通过另外一个途径退出方法。在这种情况下，方法并不能够返回任何值，而是抛出一个封装了错误信息的对象
在Java程序设计语言中，异常对象都是派生于Trowable类得到一个示例，如果java中内置的异常类不能够满足需求，用户可以创建自己的异常类
所有异常都是由trowable类继承而来，但在下一层立即分解为两个分支：Error和Exception
Error类层次结构描述了java运行时系统的内部错误和资源耗尽错误。应用程序不应该抛出这种类型的对象。如果出现类这样的内部错误，除了报告给用户，并尽力使程序安全的终止外，再也无能无力类，这种情况很少遇见。
在设计Java程序时，需要关注Exception层次结构，这个层次结构又分解为两个分支：一个分支派生于RuntimeException；另一个包含其他异常。划分两个分支的规则是：由程序错误导致的异常属于RuntionException；而程序本身没有问题，但像I/O错误这类问题导致的异常属于其他异常
派生于RuntimeException的异常包含下面几种情况：
错误的类型转换
数组访问越界
访问null指针
不是派生与RuntimeException的异常包括：
试图在文件尾部苟免读取数据
试图打开一个不存在的文件
试图根据给定的字符串查找Class对象，而这个字符串表示的类并不存在
“如果出现RuntimeEeception异常，就一定是你的问题”
Java语言规范将派生于Error类或RuntimeException类的所有异常成为非受查异常，所有其他的异常成为受查异常。这是两个很有用的术语。
方法应该在首部声明所有可能抛出的异常。这样可以从首部反映出这个方法可能抛出哪类受查异常。（thows）
如果一个方法可能抛出多个受查异常类型，那么就必须在方法的首部李处所有的异常类。每个异常类之间用逗号隔开。但是，不需要声明Java的内部错误，即从Error继承的异常。任何程序都具有抛出哪些异常的潜能，而我们对其没有任何控制能力。
我们必须catch的是受查异常（IOException），像数组越界等非受查异常，不需要捕获。总之，一个方法必须声明所有可能抛出的受查异常。如果方法没有申明所有kennel发生的受查异常，编译器就回发出一个错误信息。
子类方法中可以抛出更特定的异常，或则根本不抛出任何异常。如果超类没有抛出任何异常，子类也不能抛出任何受查异常。
关键词：
throws：列出这个方法可能抛出的异常
throw：已经产生类异常，需要抛出。一般用于自定义异常
try——catch：如果有，捕获异常
在Java中，只能抛出Trowable子类的对象
7.2 捕获异常

如果某个异常发生的时候没有在任何地方捕获，程序就回终止，并在控制台打印出异常信息。要想捕获一个异常，必须设置try/catch语句块
如果调用了一个抛出受查异常的方法，就必须对它进行处理或者继续传递
不允许在子类的throws说明符中出现超过超类方法说列出的异常范围
7.3 只用异常机制的技巧

异常处理不能代替简单的测试
不要过分的细化异常
利用异常层次结构
不要压制异常
在检测错误时，“苟刻”要比放任更好
不要羞于传递异常
7.4 断言

断言是一种测试和调试阶段所使用的工具，断言机制允许在测试期间向代码中插入一些检查语句，当代码发布的时候这些插入的检测语句将会被自动移走

断言的语法规则如下，这两种方式都会对条件进行检测，如果为false就抛出一个AssertionError异常，在第二种形式中，表达式就作为一条字符串传入AssertionError构造器，转换成消息字符串 

assert 条件；

assert 条件：表达式； —— 这里表达式就可以理解成字符串

运行程序时可以使用-enableassertions或-ea参数启用断言

7.5日志

全局日志记录（global logger） 

Logger.getGlobal().info("test"); 

Logger.getGlobal().serLevel(Level.OFF);

可以使用getLogger方法创建或获取记录器，未被任何变量引用的日志记录器可能会被垃圾回收，所以可以使用静态变量存储日志记录器的一个引用 

private static final Logger myLogger = Logger.getLogger("com.mycompany.myapp");

日志记录器有7个级别 

SERVER

WARNING

INFO

CONFIG

FINE

FINER

FINEST

可以使用Level.ALL开启所有级别的记录，使用Level.OFF关闭所有级别的记录

第二部分：实验部分

实验1：（5分）

用命令行与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();

      }

}

运行结果如下：

 总结：java中异常分为两类:checked exception(检查异常)和unchecked exception(未检查异常),对于未检查异常也叫RuntimeException(运行时异常).
对未检查的异常(unchecked exception )的几种处理方式：
1、捕获
2、继续抛出
3、不处理
对检查的异常(checked exception，除了RuntimeException，其他的异常都是checked exception )的几种处理方式：
1、继续抛出，消极的方法，一直可以抛到java虚拟机来处理
2、用try...catch捕获

实验2：测试程序1（5分）

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

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

l  掌握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)     //求n的阶乘

   {

      System.out.println("factorial(" + n + "):");

      StackWalker walker = StackWalker.getInstance();    //创建一个表示指定执行点的堆栈跟踪元素walker，调用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 (Scanner in = new Scanner(System.in))   //try子句

      {

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

         int n = in.nextInt();

         factorial(n);

      }

   }

}

运行结果如下：

实验2：测试程序2（10分）

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

//积极处理方式　　

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

     }

}

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

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

实验代码如下：

//积极处理方式<br>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：编程练习（25分）

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

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

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

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

实验代码如下：

import java.util.Scanner;

import java.io.FileNotFoundException;

import java.io.PrintWriter;

import java.util.Random;

 

public class Demo {

    public static void main(String[] args) {

 

        Scanner in = new Scanner(System.in);

        Number counter = new Number();

        PrintWriter out = null;

        try {

            out = new PrintWriter("text.txt");

        } catch (FileNotFoundException e) {

            // TODO Auto-generated catch block

            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 m = (int) Math.round(Math.random() * 3);

            Random n = new Random();

 

            switch (m) {

            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 == counter.division(a, b)) {

                    sum += 10;

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

                } else {

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

                }

 

                break;

 

            case 1:

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

                int c1 = in.nextInt();

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

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

                    sum += 10;

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

                } else {

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

                }

                break;

            case 2:

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

                int c2 = in.nextInt();

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

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

                    sum += 10;

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

                } else {

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

                }

 

                break;

            case 3:

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

                int c3 = in.nextInt();

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

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

                    sum += 10;

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

                } else {

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

                }

                break;

 

            }

 

        }

        System.out.println("成绩" + sum);

        out.println("成绩:" + sum);

        out.close();

 

    }

}

 

public class Number {

    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（5分）

测试程序1

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

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

l  掌握断言的使用特点及用法。（5分）

实验代码如下：

 //断言程序示例

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

    }

}

运行结果如下：

 

实验4：测试程序2（5分）

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

l  并掌握Java日志系统的用途及用法。（5分）

实验代码如下：

//断言程序示例

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

    }

}

运行结果如下：

实验4：测试程序3（5分）

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

l  并掌握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;

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

            {

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

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

   }

}

实验总结：（15分）

这周主要学习了程序产生的异常以及如何解决程序中产生的异常。异常时在程序的执行过程中所发生的非正常事件，它中断指令的正常执行。因此在编写代码时需要及时处理这些错误。对于异常处理，在理论课上听的不是很明白，但在实验课上通过学长演示程序，用抛出异常和将可能出错的语句放入try子句中两种方法，基本理解了异常的产生的原因和解决方法。但对于断言以及日志等内容，还是不明白，以后的日子里需要更努力学习。