冯志霞201771010107《面向对象程序设计（java）》第九周学习总结

实验九异常、断言与日志

实验时间 2018-10-25

1、实验目的与要求

(1) 掌握java异常处理技术；

(2) 了解断言的用法；

(3) 了解日志的用途；

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

1.Throwable类中的常用方法
注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:

getCause()：返回抛出异常的原因。如果 cause 不存在或未知，则返回 null。
　 getMeage()：返回异常的消息信息。
　 printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。
有时为了简单会忽略掉catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。

1. runtimeException子类:
1、 java.lang.ArrayIndexOutOfBoundsException 数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。 2、java.lang.ArithmeticException 算术条件异常。譬如：整数除零等。 3、java.lang.NullPointerException 空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等 4、java.lang.ClassNotFoundException 找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。

5、java.lang.NegativeArraySizeException 数组长度为负异常

6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常

7、java.lang.SecurityException 安全性异常

8、java.lang.IllegalArgumentException 非法参数异常

2.IOException

IOException：操作输入流和输出流时可能出现的异常。

EOFException 文件已结束异常

FileNotFoundException 文件未找到异常

3. 其他

ClassCastException 类型转换异常类

ArrayStoreException 数组中包含不兼容的值抛出的异常

SQLException 操作数据库异常类

NoSuchFieldException 字段未找到异常

NoSuchMethodException 方法未找到抛出的异常

NumberFormatException 字符串转换为数字抛出的异常

StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常

IllegalAccessException 不允许访问某类异常

4.自定义异常

用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。

在程序中使用自定义异常类，大体可分为以下几个步骤。
（1）创建自定义异常类。
（2）在方法中通过throw关键字抛出异常对象。
（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
（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();

      }

}

 

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

测试程序1：

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.01 2004-05-10
 * @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 <= 1) r = 1;
      else r = n * factorial(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：

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

l  下列两个简答程序范例给出了两种异常处理的代码格式。在elipse IDE中编辑、调试运行源程序ExceptionalTest.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：

l  编制一个程序，将身份证号.txt 中的信息读入到内存中；

l  按姓名字典序输出人员信息；

l  查询最大年龄的人员信息；

l  查询最小年龄人员信息；

l  输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；

l  查询人员中是否有你的同乡；

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

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;


public class A{
    private static ArrayList<Test> studentlist;
    public static void main(String[] args) {
        studentlist = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        File file = new File("D:\\身份证号.txt");
        try {
            FileInputStream fis = new FileInputStream(file);
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String temp = null;
            while ((temp = in.readLine()) != null) {
                
                Scanner linescanner = new Scanner(temp);
                
                linescanner.useDelimiter(" ");    
                String name = linescanner.next();
                String number = linescanner.next();
                String sex = linescanner.next();
                String age = linescanner.next();
                String province =linescanner.nextLine();
                Test student = new Test();
                student.setName(name);
                student.setnumber(number);
                student.setsex(sex);
                int a = Integer.parseInt(age);
                student.setage(a);
                student.setprovince(province);
                studentlist.add(student);

            }
        } catch (FileNotFoundException e) {
            System.out.println("学生信息文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("学生信息文件读取错误");
            e.printStackTrace();
        }
        boolean isTrue = true;
        while (isTrue) {
           
            System.out.println("1:字典排序");
            System.out.println("2:输出年龄最大和年龄最小的人");
            System.out.println("3:寻找老乡");
            System.out.println("4:寻找年龄相近的人");
            System.out.println("5:退出");
            String m = scanner.next();
            switch (m) {
            case "1":
                Collections.sort(studentlist);              
                System.out.println(studentlist.toString());
                break;
            case "2":
                 int max=0,min=100;
                 int j,k1 = 0,k2=0;
                 for(int i=1;i<studentlist.size();i++)
                 {
                     j=studentlist.get(i).getage();
                 if(j>max)
                 {
                     max=j; 
                     k1=i;
                 }
                 if(j<min)
                 {
                   min=j; 
                   k2=i;
                 }
                 
                 }  
                 System.out.println("年龄最大："+studentlist.get(k1));
                 System.out.println("年龄最小："+studentlist.get(k2));
                break;
            case "3":
                 System.out.println("province?");
                 String find = scanner.next();        
                 String place=find.substring(0,3);
                 for (int i = 0; i <studentlist.size(); i++) 
                 {
                     if(studentlist.get(i).getprovince().substring(1,4).equals(place)) 
                         System.out.println("province"+studentlist.get(i));
                 }             
                 break;
                 
            case "4":
                System.out.println("年龄：");
                int yourage = scanner.nextInt();
                int near=agematched(yourage);
                int value=yourage-studentlist.get(near).getage();
                System.out.println(""+studentlist.get(near));
                break;
            case "5":
                isTrue = false;
                System.out.println("退出程序!");
                break;
                default:
                System.out.println("输入有误");

            }
        }
    }
        public static int agematched(int age) {      
        int j=0,min=53,value=0,k=0;
         for (int i = 0; i < studentlist.size(); i++)
         {
             value=studentlist.get(i).getage()-age;
             if(value<0) value=-value; 
             if (value<min) 
             {
                min=value;
                k=i;
             } 
          }    
         return k;         
      }

}

public  class Test implements Comparable<Test> {

    private String name;
    private String number ;
    private String sex ;
    private int age;
    private String province;
   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getnumber() {
        return number;
    }
    public void setnumber(String number) {
        this.number = number;
    }
    public String getsex() {
        return sex ;
    }
    public void setsex(String sex ) {
        this.sex =sex ;
    }
    public int getage() {

        return age;
        }
        public void setage(int age) {
           
        this.age= age;
        }

    public String getprovince() {
        return province;
    }
    public void setprovince(String province) {
        this.province=province ;
    }

    public int compareTo(Test o) {
       return this.name.compareTo(o.getName());
    }

    public String toString() {
        return  name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
    }
    
}

 

注：以下实验课后完成

练习2：

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

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

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

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

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

    }

}

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

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

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

实验程序2：

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

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