实验九 异常、断言与日志
实验时间 2018-10-25
1、实验目的与要求
(1) 掌握java异常处理技术；
(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 public class ExceptionDemo1 {
2
3 public static void main(String[] args) {
4
5 int a = 0;
6 if (a==0) {
7 System.out.println("除数为零");
8 } else {
9 System.out.println(5 / a);
10 }
11 }
12 }
//消极处理方式
import java.io.*;
public class ExceptionDemo2 {
public static void main(String args[]) throws Exception
{
//以字节流打开未正常打开，字符流打开是可以正常打开。
FileInputStream fis=new FileInputStream("text.txt");//JVM自动生成异常对象
int b;
while((b=fis.read())!=-1)
{
System.out.print(b);
}
fis.close();
}
}
//积极的异常处理
import java.io.*;
public class ExceptionDemo {
public static void main(String args[])
{
FileInputStream fis;
try {
fis = new FileInputStream("text.txt");
//JVM自动生成异常对象
int b;
while((b=fis.read())!=-1)
{
System.out.print(b);
}
fis.close();
} catch (Exception e) {//e.printStackTrace();
// System.out.println("Hello.");
}
}
}
实验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 非负整数的PARAM
* @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.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
public class ExceptionTest {
public static void main(String[] args) throws IOException {
try {
FileInputStream fis = new FileInputStream("身份证号.txt");
BufferedReader in = new BufferedReader(new InputStreamReader(fis));
String m, n = new String();
while ((m = in.readLine()) != null) {
n += m + "\n ";
}
in.close();
System.out.println(n);
} 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
{
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 Test {
private static ArrayList<Student> studentlist;
public static void main(String[] args) {
studentlist = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
File file = new File("F:\\java\\身份证号.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();
Student student = new Student();
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("选择你的操作， ");
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("地址?");
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("同乡"+studentlist.get(i));
}
break;
case "4":
System.out.println("年龄：");
int yourage = scanner.nextInt();
int near=agenear(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 agenear(int age) {
int j=0,min=53,value=0,ok=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;
ok=i;
}
}
return ok;
}
}
public class Student implements Comparable<Student> {
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) {
// int a = Integer.parseInt(age);
this.age= age;
}
public String getprovince() {
return province;
}
public void setprovince(String province) {
this.province=province ;
}
public int compareTo(Student 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 在以上程序适当位置加入异常捕获代码。
package 异常;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
public class Demo {
public static void main(String[] args, Object jf) {
@SuppressWarnings("resource")
Scanner in = new Scanner(System.in);
jf counter=new jf();
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);
switch(m)
{
case 0:
System.out.println(i+": "+a+"/"+b+"=");
while(b==0){ b = (int) Math.round(Math.random() * 100); }
int c0 = in.nextInt();
out.println(a+"/"+b+"="+c0);
if (c0 == ((异常.jf) jf).division(a, b)) {
sum += 10;
System.out.println("恭喜答案正确");
}
else {
System.out.println("抱歉，答案错误");
}
break;
case 1:
System.out.println(i+": "+a+"*"+b+"=");
int c = in.nextInt();
out.println(a+"*"+b+"="+c);
if (c == counter.multiplication(a, b)) {
sum += 10;
System.out.println("恭喜答案正确");
}
else {
System.out.println("抱歉，答案错误");
}
break;
case 2:
System.out.println(i+": "+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 3:
System.out.println(i+": "+a+"-"+b+"=");
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 ;
}
}
System.out.println("成绩"+sum);
out.println("成绩:"+sum);
out.close();
}
}
package 异常;
public class jf {
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：
|
//断言程序示例 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); } } |
在elipse下调试程序AssertDemo，结合程序运行结果理解程序；
l 注释语句test1(-5);后重新运行程序，结合程序运行结果理解程序；
l 掌握断言的使用特点及用法。
//断言程序示例
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);
}
}
实验程序2：
l 用JDK命令调试运行教材298页-300页程序7-2，结合程序运行结果理解程序；
l 并掌握Java日志系统的用途及用法。
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
/**
* 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");
}
}
}
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);
});
}
}
import java.util.logging.LogRecord;
import java.util.logging.StreamHandler;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import org.omg.CORBA.Any;
import org.omg.CORBA.Object;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.portable.InputStream;
import org.omg.CORBA_2_3.portable.OutputStream;
/**
* 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));
}
@Override
public InputStream create_input_stream() {
// TODO Auto-generated method stub
return null;
}
@Override
public void write_Object(Object arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_TypeCode(TypeCode arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_any(Any arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_boolean(boolean arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_boolean_array(boolean[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_char(char arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_char_array(char[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_double(double arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_double_array(double[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_float(float arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_float_array(float[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_long(int arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_long_array(int[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_longlong(long arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_longlong_array(long[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_octet(byte arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_octet_array(byte[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_short(short arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_short_array(short[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_string(String arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_ulong(int arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_ulong_array(int[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_ulonglong(long arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_ulonglong_array(long[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_ushort(short arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_ushort_array(short[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_wchar(char arg0) {
// TODO Auto-generated method stub
}
@Override
public void write_wchar_array(char[] arg0, int arg1, int arg2) {
// TODO Auto-generated method stub
}
@Override
public void write_wstring(String arg0) {
// TODO Auto-generated method stub
}
});
}
public void publish(LogRecord record)
{
if (!frame.isVisible()) return;
super.publish(record);
flush();
}
}
实验总结：
第7章 异常、日志、断言和调试：
?概念：异常、异常类型、异常声明、异常抛出、 异常捕获
?异常处理技术
?断言的概念及使用
?基本的调试技巧
一、异常的概念：
Java的异常处理机制可以控制程序从错误产生的 位置转移到能够进行错误处理的位置。 ?
程序中出现的常见的错误和问题有:
用户输入错误
设备错误
物理限制
代码错误
二、异常分类：
?Java把程序运行时可能遇到的错误分为两类：
1、非致命异常:通过某种修正后程序还能继续执行。 这类错误叫作异常。如：文件不存在、无效的数组 下标、空引用、网络断开、打印机脱机、磁盘满等。 Java中提供了一种独特的处理异常的机制，通过异 常来处理程序设计中出现的错误。
2、致命异常：程序遇到了非常严重的不正常状态，不 能简单恢复执行，是致命性错误。如：内存耗尽、 系统内部错误等。这种错误程序本身无法解决。
?Java中所有的异常类都直接或间接地继承于 Throwable类。除内置异常类外，程序员可自定义异 常类。 ?
3、Java中的异常类可分为两大类：
-Error Error类层次结构描述了Java运行时系统的内部错误 和资源耗尽错误。应用程序不应该捕获这类异常，也 不会抛出这种异常。
-Exception Exception类：重点掌握的异常类。Exception层次结 构又分解为两个分支：一个分支派生于 RuntimeException；另一个分支包含其他异常。
4、RuntimeException为运行时异常类，一般是程序错误 产生。 ?
派生于RuntimeException的异常包含下面几种情况：
–错误的类型转换 –数组访问越界
–访问空指针
–Java将派生于Error类或RuntimeException类的所有异 常称为未检查异常，编译器允许不对它们做出异常处 理。
注意：“如果出现RuntimeException异常，就一定是程序员 的问题！！！”
5、非运行时异常，程序本身没有问题，但由于某种情 况的变化，程序不能正常运行，导致异常出现。 ?除了运行时异常之外的其它继承自Exception类的 异常类包括：
–试图在文件尾部后面读取数据 –试图打开一个错误格式的URL
–编译器要求程序必须对这类异常进行处理 (checked)，称为已检查异常。
RuntimeException: 运行时异常类
–ArithmeticException: 算术异常类
–ArrayStoreException: 数组存储异常类
–ClassCastException: 类型强制转换异常类
–IndexOutOfBoundsException: 下标越界异常类
–NullPointerException: 空指针异常类
–SecurityException: 违背安全原则异常类
IOException:输入输出异常类
–IOException：申请I/O操作没有正常完成。
–EOFException：在输入操作正常结束前遇见了 文件结束符。
–FileNotFountException：在文件系统中，没有找到由文件名字符串指定的文件。
小结：异常类型：
1>.Error 很难恢复的严重错误，一般不由程序处理。
?2>.RuntimeException 程序设计或实现上的问题，如数组越界等。
?3>.其它异常 通常是由环境因素引起的，并且可以被处理。 如文件不存在，无效URL等。
原文地址：https://www.cnblogs.com/hongyanohongyan/p/9851808.html
时间： 2024-10-14 04:11:42