首页 > > 程序设计 > Java技术 >

王之泰201771010131《面向对象程序设计（java）…

2018-10-29 15:32:04来源：博客园阅读 ()

第一部分：理论知识学习部分

第7章异常、日志、断言和调试

概念：异常、异常类型、异常声明、异常抛出、异常捕获
1.异常处理技术
2.断言的概念及使用
3.基本的调试技巧

1）异常的概念

a.Java的异常处理机制可以控制程序从错误产生的位置转移到能够进行错误处理的位置。

b.程序中出现的常见的错误和问题有:用户输入错误；设备错误；物理限制；代码错误。

2）异常分类：

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

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

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

Java中的异常类可分为两大类：

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

b.Exception Exception类：重点掌握的异常类。Exception层次结构又分解为两个分支：一个分支派生于 RuntimeException；另一个分支包含其他异常

第二部分：实验部分 ——异常、断言与日志

1、实验目的与要求

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

(2) 了解断言的用法；

(3) 了解日志的用途；

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

2、实验内容和步骤

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

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

 1 //异常示例2
 2 import java.io.*;
 3 
 4 public class ExceptionDemo2 {
 5     public static void main(String args[]) 
 6      {
 7           FileInputStream fis=new FileInputStream("text.txt");//JVM自动生成异常对象
 8           int b;
 9           while((b=fis.read())!=-1)
10           {
11               System.out.print(b);
12           }
13           fis.close();
14       }
15 }

检查异常后：

 1 package 异常;
 2 
 3 //异常示例1
 4 public class ExceptionDemo1 {
 5     public static void main(String args[]) {
 6         int a=0;
 7         if(a==0) {
 8             System.out.println("除数为零！");
 9         }
10         else {
11             System.out.println(5 / a);
12 
13         }
14     }
15 }

 1 package 异常;
 2 
 3 //异常示例2
 4 import java.io.*;
 5 
 6 public class ExceptionDemo2 {
 7     public static void main(String args[]) throws Exception 
 8    {
 9         FileInputStream fis=new FileInputStream("text.txt");//JVM自动生成异常对象
10         int b;
11         while((b=fis.read())!=-1)
12         {
13             System.out.print(b);
14         }
15         fis.close();
16     }
17 }

在项目文件夹中添加相应的TXT文件

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

测试程序1：

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

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

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

7-1代码如下：

 1 package stackTrace;
 2 
 3 import java.util.*;
 4 
 5 /**
 6  * A program that displays a trace feature of a recursive method call.
 7  * @version 1.01 2004-05-10
 8  * @author Cay Horstmann
 9  */
10 public class StackTraceTest
11 {
12    /**
13     * Computes the factorial of a number
14     * @param n a non-negative integer
15     * @return n! = 1 * 2 * . . . * n
16     */
17    public static int factorial(int n)
18    {
19       System.out.println("factorial(" + n + "):");
20       Throwable t = new Throwable();//调用Throwable类的getStackTrace方法，得到StackTraceElement对象的一个数组
21       StackTraceElement[] frames = t.getStackTrace();
22       for (StackTraceElement f : frames)
23          System.out.println(f);
24       int r;
25       if (n <= 1) r = 1;
26       else r = n * factorial(n - 1);
27       System.out.println("return " + r);
28       return r;
29    }
30 
31    public static void main(String[] args)
32    {
33       Scanner in = new Scanner(System.in);
34       System.out.print("Enter n: ");
35       int n = in.nextInt();
36       factorial(n);
37    }
38 }

程序运行结果如下：

测试程序2：

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

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

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

 1 //积极处理方式　　
 2 import java.io.*;
 3 
 4 class ExceptionTest {
 5     public static void main (string args[])
 6    {
 7        try{
 8            FileInputStream fis=new FileInputStream("text.txt");
 9        }
10        catch（FileNotFoundExcption e）
11         {   ……  }
12     ……
13     }
14 }

1 //消极处理方式
2 
3 import java.io.*;
4 class ExceptionTest {
5     public static void main (string args[]) throws  FileNotFoundExcption
6      {
7          FileInputStream fis=new FileInputStream("text.txt");
8      }
9 }

读入内容后：

 1 package 异常;
 2 
 3 //积极处理方式　　
 4 import java.io.*;
 5 import java.io.BufferedReader;
 6 import java.io.FileReader;
 7 
 8 class ExceptionTest {
 9     public static void main (String args[])
10  {
11         File fis=new File("身份证号.txt");
12      try{
13          
14 
15          FileReader fr = new FileReader(fis);
16          BufferedReader br = new BufferedReader(fr);
17          try {
18              String s, s2 = new String();
19              while ((s = br.readLine()) != null) {
20                  s2 += s + "\n ";
21              }
22              br.close();
23              System.out.println(s2);
24          } catch (IOException e) {
25              // TODO Auto-generated catch block
26              e.printStackTrace();
27          }
28      } catch (FileNotFoundException e) {
29          // TODO Auto-generated catch block
30          e.printStackTrace();
31      }
32 
33   }
34 }

 1 package 异常;
 2 
 3 //消极处理方式
 4 
 5 import java.io.*;
 6 class ExceptionTest {
 7     public static void main (String args[]) throws  IOException
 8        {
 9         File fis=new File("身份证号.txt");
10         FileReader fr = new FileReader(fis);
11         BufferedReader br = new BufferedReader(fr);
12         String s, s2 = new String();
13 
14             while ((s = br.readLine()) != null) {
15                 s2 += s + "\n ";
16             }
17             br.close();
18             System.out.println(s2);
19        }
20 }

实验3: 编程练习

练习1：

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

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

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

4.查询最小年龄人员信息；

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

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

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

  1 package IDcard;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.File;
  5 import java.io.FileInputStream;
  6 import java.io.FileNotFoundException;
  7 import java.io.IOException;
  8 import java.io.InputStreamReader;
  9 import java.util.ArrayList;
 10 import java.util.Scanner;
 11 import java.util.Collections;
 12 
 13 public class ID {
 14 
 15     public static People findPeopleByname(String name) {
 16         People flag = null;
 17         for (People people : peoplelist) {
 18             if(people.getName().equals(name)) {
 19                 flag = people;
 20             }
 21         }
 22         return flag;
 23 
 24     }
 25 
 26     public static People findPeopleByid(String id) {
 27         People flag = null;
 28         for (People people : peoplelist) {
 29             if(people.getnumber().equals(id)) {
 30                 flag = people;
 31             }
 32         }
 33         return flag;
 34 
 35     }
 36      
 37     private static ArrayList<People> agenear(int yourage) {
 38         // TODO Auto-generated method stub
 39         int j=0,min=53,d_value=0,k = 0;
 40         ArrayList<People> plist = new ArrayList<People>();
 41         for (int i = 0; i < peoplelist.size(); i++) {
 42             d_value = peoplelist.get(i).getage() > yourage ? 
 43                     peoplelist.get(i).getage() - yourage : yourage - peoplelist.get(i).getage() ;
 44             k = d_value < min ? i : k;
 45             min = d_value < min ? d_value : min;
 46         }
 47         for(People people : peoplelist) {
 48             if(people.getage() == peoplelist.get(k).getage()) {
 49                 plist.add(people);
 50             }
 51         }
 52         return plist;
 53     }
 54 
 55     private static ArrayList<People> peoplelist; 
 56     
 57     public static void main(String[] args) //throws  IOException
 58     {
 59         peoplelist = new ArrayList<People>();
 60         Scanner scanner = new Scanner(System.in);
 61         File file = new File("D:\\身份证号.txt");
 62         try {
 63             FileInputStream files = new FileInputStream(file);
 64             BufferedReader in = new BufferedReader(new InputStreamReader(files));
 65             String temp = null;
 66             while ((temp = in.readLine()) != null) {
 67                 
 68                 String[] information = temp.split("[ ]+");
 69                 People people = new People();
 70                 people.setName(information[0]);
 71                 people.setnumber(information[1]);
 72                 int A = Integer.parseInt(information[3]);
 73                 people.setage(A);
 74                 people.setsex(information[2]);
 75                 for(int j = 4; j<information.length;j++) {
 76                     people.setplace(information[j]);
 77                 }
 78                 peoplelist.add(people);
 79 
 80             }
 81         } catch (FileNotFoundException e) {
 82             System.out.println("文件未找到");
 83             e.printStackTrace();
 84         } catch (IOException e) {
 85             System.out.println("文件读取错误");
 86             e.printStackTrace();
 87         }
 88         boolean isTrue = true;
 89         while (isTrue) {
 90 
 91             System.out.println("******************************************");
 92             System.out.println("   1.按姓名典序输出人员信息");
 93             System.out.println("   2.查询最大年龄人员信息");
 94             System.out.println("   3.查询最小年龄人员信息");
 95             System.out.println("   4.输入你的年龄，查询身份证号.txt中年龄与你最近的人");
 96             System.out.println("   5.查询人员中是否有你的同乡");
 97             System.out.println("   6.退出");
 98             System.out.println("******************************************");
 99             int nextInt = scanner.nextInt();
100             switch (nextInt) {
101             case 1:
102                 Collections.sort(peoplelist);
103                 System.out.println(peoplelist.toString());
104                 break;
105             case 2:
106                 int max=0;
107                 int j,k1 = 0;
108                 for(int i=1;i<peoplelist.size();i++)
109                 {
110                     j = peoplelist.get(i).getage();
111                    if(j>max)
112                    {
113                        max = j; 
114                        k1 = i;
115                    }
116                   
117                 }  
118                 System.out.println("年龄最大："+peoplelist.get(k1));
119                 break;
120             case 3:
121                 int min = 100;
122                 int j1,k2 = 0;
123                 for(int i=1;i<peoplelist.size();i++)
124                 {
125                     j1 = peoplelist.get(i).getage();
126                     if(j1<min)
127                     {
128                         min = j1; 
129                         k2 = i;
130                     }
131 
132                  } 
133                 System.out.println("年龄最小："+peoplelist.get(k2));
134                 break;
135             case 4:
136                 System.out.println("年龄：");
137                 int input_age = scanner.nextInt();
138                 ArrayList<People> plist = new ArrayList<People>();
139                 plist = agenear(input_age);
140                 for(People people : plist) {
141                     System.out.println(people.toString());
142                 }
143                 break;
144             case 5:
145                 System.out.println("请输入省份");
146                 String find = scanner.next();        
147                 for (int i = 0; i <peoplelist.size(); i++) 
148                 {
149                     String [] place = peoplelist.get(i).getplace().split("\t");
150                     for(String temp : place) {
151                         if(find.equals(temp)) {
152                             System.out.println("你的同乡是    "+peoplelist.get(i));
153                             break;
154                         }
155                     }
156                     
157                 } 
158                 break;
159             case 6:
160                 isTrue = false;
161                 System.out.println("byebye!");
162                 break;
163             default:
164                 System.out.println("输入有误");
165             }
166         }
167     }
168 
169 }

练习2：

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

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

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

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

程序如下：

 1 package 算术题;
 2 
 3 import java.io.FileNotFoundException;
 4 import java.io.PrintWriter;
 5 import java.util.Scanner;
 6 
 7 
 8 public class ss {
 9     public static void main(String[] args) {
10 
11         Scanner in = new Scanner(System.in);
12         sf sf=new sf();
13         PrintWriter output = null;
14         try {
15             output = new PrintWriter("ss.txt");
16         } catch (Exception e) {
17             //e.printStackTrace();
18         }
19         int sum = 0;
20 
21         for (int i = 1; i < 11; i++) {
22             int a = (int) Math.round(Math.random() * 100);
23             int b = (int) Math.round(Math.random() * 100);
24             int s = (int) Math.round(Math.random() * 4);
25 
26             
27            switch(s)
28            {
29            case 1:
30                System.out.println(i+": "+a+"/"+b+"=");
31                while(b==0){  
32                    b = (int) Math.round(Math.random() * 100); 
33                    }
34                double c = in.nextDouble();
35                output.println(a+"/"+b+"="+c);
36                if (c == sf.chu_fa(a, b)) {
37                    sum += 10;
38                    System.out.println("恭喜答案正确");
39                }
40                else {
41                    System.out.println("抱歉，答案错误");
42                } break;
45             
46            case 2:
47                System.out.println(i+": "+a+"*"+b+"=");
48                int c1 = in.nextInt();
49                output.println(a+"*"+b+"="+c1);
50                if (c1 == sf.chen_fa(a, b)) {
51                    sum += 10;
52                    System.out.println("恭喜答案正确");
53                }
54                else {
55                    System.out.println("抱歉，答案错误");
56                }break;

58            case 3:
59                System.out.println(i+": "+a+"+"+b+"=");
60                int c2 = in.nextInt();
61                output.println(a+"+"+b+"="+c2);
62                if (c2 == sf.jia_fa(a, b)) {
63                    sum += 10;
64                    System.out.println("恭喜答案正确");
65                }
66                else {
67                    System.out.println("抱歉，答案错误");
68                }break ;

71            case 4:
72                System.out.println(i+": "+a+"-"+b+"=");
73                int c3 = in.nextInt();
74                output.println(a+"-"+b+"="+c3);
75                if (c3 == sf.jian_fa(a, b)) {
76                    sum += 10;
77                    System.out.println("恭喜答案正确");
78                }
79                else {
80                    System.out.println("抱歉，答案错误");
81                }break ;
83 
84              } 
85     
86           }
87         System.out.println("成绩"+sum);
88         output.println("成绩:"+sum);
89         output.close();
90          
91     }
92 }

package 算术题;

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)
        {
            if((a-b)<0)
                return 0;
            else
            return a-b;
        }
        public int   chen_fa(int a,int b)
        {
            return a*b;
        }
        public int   chu_fa(int a,int b)
        {
            if(b!=0)
            return a/b;    
            else
        return 0;
        }

        
}

结果如下：

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

实验程序1：

 1 //断言程序示例
 2 public class AssertDemo {
 3     public static void main(String[] args) {        
 4         test1(-5);
 5         test2(-3);
 6     }
 7     
 8     private static void test1(int a){
 9         assert a > 0;
10         System.out.println(a);
11     }
12     private static void test2(int a){
13        assert a > 0 : "something goes wrong here, a cannot be less than 0";
14         System.out.println(a);
15     }
16 }

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

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

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

程序运行结果如下：

注释后程序如下：

 1 package stackTrace;
 2 //断言程序示例
 3 public class AssertDemo {
 4   public static void main(String[] args) {        
 5 //      test1(-5);
 6       test2(-3);
 7   }
 8   
 9   private static void test1(int a){
10       assert a > 0;
11       System.out.println(a);
12   }
13   private static void test2(int a){
14      assert a > 0 : "something goes wrong here, a cannot be less than 0";
15       System.out.println(a);
16   }
17 }
18

结果如下：

实验程序2：

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

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

程序如下：

  1 package logging;
  2 
  3 import java.awt.*;
  4 import java.awt.event.*;
  5 import java.io.*;
  6 import java.util.logging.*;
  7 import javax.swing.*;
  8 
  9 /**
 10  * A modification of the image viewer program that logs various events.
 11  * @version 1.03 2015-08-20
 12  * @author Cay Horstmann
 13  */
 14 public class LoggingImageViewer
 15 {
 16    public static void main(String[] args)
 17    {
 18       if (System.getProperty("java.util.logging.config.class") == null
 19             && System.getProperty("java.util.logging.config.file") == null)
 20       {
 21          try
 22          {
 23             Logger.getLogger("com.horstmann.corejava").setLevel(Level.ALL);
 24             final int LOG_ROTATION_COUNT = 10;
 25             Handler handler = new FileHandler("%h/LoggingImageViewer.log", 0, LOG_ROTATION_COUNT);
 26             Logger.getLogger("com.horstmann.corejava").addHandler(handler);
 27          }
 28          catch (IOException e)
 29          {
 30             Logger.getLogger("com.horstmann.corejava").log(Level.SEVERE,
 31                   "Can't create log file handler", e);
 32          }
 33       }
 34 
 35       EventQueue.invokeLater(() ->
 36             {
 37                Handler windowHandler = new WindowHandler();
 38                windowHandler.setLevel(Level.ALL);
 39                Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);
 40 
 41                JFrame frame = new ImageViewerFrame();
 42                frame.setTitle("LoggingImageViewer");
 43                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 44 
 45                Logger.getLogger("com.horstmann.corejava").fine("Showing frame");
 46                frame.setVisible(true);
 47             });
 48    }
 49 }
 50 
 51 /**
 52  * The frame that shows the image.
 53  */
 54 class ImageViewerFrame extends JFrame
 55 {
 56    private static final int DEFAULT_WIDTH = 300;
 57    private static final int DEFAULT_HEIGHT = 400;   
 58 
 59    private JLabel label;
 60    private static Logger logger = Logger.getLogger("com.horstmann.corejava");
 61 
 62    public ImageViewerFrame()
 63    {
 64       logger.entering("ImageViewerFrame", "<init>");      
 65       setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
 66 
 67       // set up menu bar
 68       JMenuBar menuBar = new JMenuBar();
 69       setJMenuBar(menuBar);
 70 
 71       JMenu menu = new JMenu("File");
 72       menuBar.add(menu);
 73 
 74       JMenuItem openItem = new JMenuItem("Open");
 75       menu.add(openItem);
 76       openItem.addActionListener(new FileOpenListener());
 77 
 78       JMenuItem exitItem = new JMenuItem("Exit");
 79       menu.add(exitItem);
 80       exitItem.addActionListener(new ActionListener()
 81          {
 82             public void actionPerformed(ActionEvent event)
 83             {
 84                logger.fine("Exiting.");
 85                System.exit(0);
 86             }
 87          });
 88 
 89       // use a label to display the images
 90       label = new JLabel();
 91       add(label);
 92       logger.exiting("ImageViewerFrame", "<init>");
 93    }
 94 
 95    private class FileOpenListener implements ActionListener
 96    {
 97       public void actionPerformed(ActionEvent event)
 98       {
 99          logger.entering("ImageViewerFrame.FileOpenListener", "actionPerformed", event);
100 
101          // set up file chooser
102          JFileChooser chooser = new JFileChooser();
103          chooser.setCurrentDirectory(new File("."));
104 
105          // accept all files ending with .gif
106          chooser.setFileFilter(new javax.swing.filechooser.FileFilter()
107             {
108                public boolean accept(File f)
109                {
110                   return f.getName().toLowerCase().endsWith(".gif") || f.isDirectory();
111                }
112 
113                public String getDescription()
114                {
115                   return "GIF Images";
116                }
117             });
118 
119          // show file chooser dialog
120          int r = chooser.showOpenDialog(ImageViewerFrame.this);
121 
122          // if image file accepted, set it as icon of the label
123          if (r == JFileChooser.APPROVE_OPTION)
124          {
125             String name = chooser.getSelectedFile().getPath();
126             logger.log(Level.FINE, "Reading file {0}", name);
127             label.setIcon(new ImageIcon(name));
128          }
129          else logger.fine("File open dialog canceled.");
130          logger.exiting("ImageViewerFrame.FileOpenListener", "actionPerformed");
131       }
132    }
133 }
134 
135 /**
136  * A handler for displaying log records in a window.
137  */
138 class WindowHandler extends StreamHandler
139 {
140    private JFrame frame;
141 
142    public WindowHandler()
143    {
144       frame = new JFrame();
145       final JTextArea output = new JTextArea();
146       output.setEditable(false);
147       frame.setSize(200, 200);
148       frame.add(new JScrollPane(output));
149       frame.setFocusableWindowState(false);
150       frame.setVisible(true);
151       setOutputStream(new OutputStream()
152          {
153             public void write(int b)
154             {
155             } // not called
156 
157             public void write(byte[] b, int off, int len)
158             {
159                output.append(new String(b, off, len));
160             }
161          });
162    }
163 
164    public void publish(LogRecord record)
165    {
166       if (!frame.isVisible()) return;
167       super.publish(record);
168       flush();
169    }
170 }

程序运行结果如下：

实验程序3：

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

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

1）条件断点

添加断点：

点击Breakpoint Properties后：

2）变量断点

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

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

3）方法断点

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

4）异常断点

经常遇见一些异常，然后程序就退出来了，要找到异常发生的地方就比较难了，还好可以打一个异常断点。
上图中我们增加了一个NullPointException的异常断点，当异常发生时，代码会停在异常发生处，定位问题时应该比较有帮助。

5）重新调试

6）单步执行程序

7）检查变量

8）改变变量值

第三部分：总结

　　通过本周的学习，我掌握了java异常处理的一些基础技术；通过调试理解书上的示例程序，再加上老师助、教学长的演示讲解，更好的使我理解这一章的知识。课后的自主编程也是在学长提供思路的基础上理解之后，补充完整的，本周除了惯例的编程练习外，重点是学习Java异常处理技术，更好的运用eclipse这个工具为我们编程提供服务。

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有