|
项目 |
内容 |
|
这个作业属于哪个课程 |
<任课教师博客主页链接> https://www.cnblogs.com/nwnu-daizh/ |
|
这个作业的要求在哪里 |
<作业链接地址> https://www.cnblogs.com/nwnu-daizh/p/11778090.html |
|
作业学习目标 |
1.掌握java异常处理技术； 2.了解断言的用法； 3.了解日志的用途； 4.掌握程序基础调试技巧。 |
第一部分：总结第七章关于异常处理相关理论知识（20分）
1、异常：在程序的执行过程中所发生的异常事件，它中断指令的正常执行。
常见的几种错误：
用户输入错误；
设备错误
物理限制。
2、所有的异常都是由Throwable类继承而来，在下一层分解为两个分支：Error和Exception。
（1）Error类层次结构描述了Java运行时系统的内部错误和资源耗尽错误。应用程序不应该抛出这种类型的对象。
（2）在设计Java程序时，需要关注Exception层次结构。这个层次结构又分解为两个分支：一个分支派生于RuntimeException；另一个分支包含其他异常。
3、派生于于RuntimeException的异常包含下面几种情况：
（1）错误的类型转换。
（2）数组访问越界。
（3）访问null指针。
4、不是派生于于RuntimeException的异常包含下面几种情况：
（1）试图在文件尾部后面读取数据。
（2）试图打开一个不存在的文件。
（3）试图根据给定的字符串查找Class对象，而这个字符串表示的类不存在。
5、Java将派生于Error或RuntimeException类的所有异常称为未检查异
6、异常的分类：
非致命异常：通过某种修正后程序还能继续执行。如：文件不存在，网络断开，无效的数组下标，磁盘满等。
致命性异常。程序用到了非常严重的不正常的状态，不能简单执行恢复。如：内存耗尽，系统内部错误。程序本身无法解决。
7、Java中所有异常类都直接或间接地继承于Throwable类。除內置异常类外，程序员可自定义异常类。
Error类：描述了运行时系统的内部错误和资源耗尽；
Exception类：分为两分支一个分支派生于Runtime Exception；另一个分支包含其他异常。
其他异常：通常是由环境引起的，并且可以被处理。
8、声明抛出异常:如果一个方法可能会生成一些异常，但是该方法并不确切知道如何对这些异常进行处理，此时，这个方法就声明抛出异常。
9、捕获异常：
捕获：程序运行期间，异常发生时，Java运行系统从异常生成的代码块开始，寻找相应的异常代码处理，并将异常交给该方法处理。
某个异常发生时，若程序没有在任何地方进行该异常的捕获，则程序就会终止执行，并在控制台上输出异常信息。
若要捕获一个异常，需要在程序中设置一个 try/catch/ finally块：
try语句括住可能抛出异常的代码段。
catch语句指明要捕获的异常及相应的处理代码。
finally语句指明必须执行的程序块。
Try子句：捕获异常的第一步是用try{….}子句选定捕获异常的代码范围，由try所限定的代码块中的语句在执行过程中可能会自动生成异常对象并抛出。
Catch子句:catch块是对异常对象进行处理的代码；每个try代码块可以伴随一个或多个catch语句，用于处理try代码块中所生成的格类异常事件；
Finally 子句：A:捕获异常的最后一步是通过finally语句为异常处理提供一个统一出口，使得控制流程在转到程序其他部分以前，能够对程序的状态做统一的管理
10、断言：假设确信某个属性符合要求，并且代码的执行依赖于这个属性。
断言机制允许在测试期间向代码插入一些检查语句，当代码发布时，这些插入的检查语句将会被自动地移走。
在默认情况下，断言被禁用；注意，在启用或禁用断言时不必重新编译程序；有些类不是由类加载器加载，而是直接由虚拟机加载（可以使用这些开关有选择的启用或禁用那些类中的断言）。
在Java语言中给出了3种处理系统错误的机制：抛出一个异常、日志、使用断言。
什么时候使用断言呢：断言失败是致命的、不可恢复的错误；断言检查只用于开发和测阶段。
有时候会抛出一个断言错误，有时候会产生一个null 指针异常，这完全取决于类加载器的配置。
11、API的优点：可以很容易的取消全部日志记录，或者仅仅取消某个级别的日志，而且打开和关闭这个操作也很容易；可以很简单的禁止日志记录的输出，因此，将这些日志代码留在程序中的开销很小；日志记录可以被定向到不同的处理器，用于在控制台中显示，用于存储在文件中等；日志记录器和处理器都可以对记录进行过滤，过滤器可以根据过滤实现器制定的标准丢弃那些无用的记录项；日志记录可以采用不同的方法格式化；应用程序可以使用多个日志记录器，它们使用类似包名的这种具有层次结构的名字；在默认情况下，日志系统的配置由配置文件控制。
与包名类似，日志记录器名也具有层次结构；通常，有以下7个日志记录器级别：SEVERE、WARNING、INFO、CONFIG、FINE、FINER、FINEST。
默认的日志记录将显示包含日志调用的类名和方法名，如同堆栈所显示的那样；记录日志的常见用途是记录那些不可预料的异常；可以通过编辑配置文件来修改日志系统的各种属性。
在运行的程序中，使用jconsole程序也可以改变日志记录的级别。
第二部分：实验部分
实验1：（5分）
用命令行与IDE两种环境下编辑调试运行源程序ExceptionDemo1、ExceptionDemo2，结合程序运行结果理解程序，掌握未检查异常和已检查异常的区别。
ExceptionDemo1.java
//异常示例1
public class ExceptionDemo1 {
public static void main(String args[]) {
int a = 0;
System.out.println(5 / a);
}
}
ExceptionDemo2.java
//异常示例2
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())!=-1)
{
System.out.print(b);
}
fis.close();
}
}
小结：未检查异常和已检查异常的区别
未检查异常：（RuntimeException与其子类，以及错误（Error））不要求强制处置的异常。
对未检查的异常的几种处理方式：
1、捕获
2、继续抛出
3、不处理
已检查异常：编译器要求必须处置的异常。编译器要求必须要对这段代码try...catch，或者throws exception。
对已检查异常的几种处理方式：
1、继续抛出（消极的方法），一直可以抛到java虚拟机来处理，就是通过throws exception抛出。
2、用try...catch捕获
注意，对于已检查异常必须处理，或者必须捕获或者必须抛出
实验2：测试程序1（5分）
在elipse IDE中编辑、编译、调试运行教材281页7-1，结合程序运行结果理解程序；
在程序中相关代码处添加新知识的注释；
掌握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)
{
System.out.println("factorial(" + n + "):");
var walker = StackWalker.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 (var in = new Scanner(System.in))//可能抛出异常的代码段
{
System.out.print("Enter n: ");
int n = in.nextInt();
factorial(n);
}
}
}
小结：
Throwable 类是 Java 语言中所有错误或异常的父类。只有当对象是此类或其子类之一的实例时，才能通过 throw 语句抛出。才可以是 catch 子句中的参数类型。
两个子类的实例，Error 和 Exception，通常用于指示发生了异常情况。通常，这些实例是在异常情况的上下文中新近创建的，因此包含了相关的信息（比如堆栈跟踪数据）。
getStackTrace 方法可以产生所有线程的堆栈轨迹和 printStackTrace 方法访问堆栈轨迹的文本描述信息。
实验2：测试程序2（10分）
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"); } } |
积极处理方式：
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 {
return ;
}
}
}
实验3：编程练习（25分）
编写一个计算器类，可以完成加、减、乘、除的操作；
利用计算机类，设计一个小学生100以内数的四则运算练习程序，由计算机随机产生10道加减乘除练习题，学生输入答案，由程序检查答案是否正确，每道题正确计10分，错误不计分，10道题测试结束后给出测试总分；
将程序中测试练习题及学生答题结果输出到文件，文件名为test.txt；
在以上程序适当位置加入异常捕获代码。
Demo.java
package Text1;
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) {
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();
}
}
Number.java
package Text1;
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分）
在elipse下调试程序AssertDemo，结合程序运行结果理解程序；
注释语句test1(-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);
}
}
注释语句test1(-5);后重新运行程序，结果如下：
小结：
Java语言引入了关键字assert。有两种形式：
1.assert 条件；
2.assert 条件：表达式；
两种形式都会对条件进行检测，如果结果为false，则抛出一个AssertionError异常。在第二种形式中，表达式将被传入AssertionError的构造器，并转换成一个消息字符串。
实验4：测试程序2（5分）
用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 = 10;
var 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(() ->
{
var windowHandler = new WindowHandler();
windowHandler.setLevel(Level.ALL);
Logger.getLogger("com.horstmann.corejava").addHandler(windowHandler);
var 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);
//设置菜单栏
var menuBar = new JMenuBar();
setJMenuBar(menuBar);
var menu = new JMenu("File");
menuBar.add(menu);
var openItem = new JMenuItem("Open");
menu.add(openItem);
openItem.addActionListener(new FileOpenListener());
var exitItem = new JMenuItem("Exit");
menu.add(exitItem);
exitItem.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent event)
{
logger.fine("Exiting.");
System.exit(0);
}
});
//使用标签显示图像
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);
//设置文件夹
var 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();
var 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();
}
}
实验4：测试程序3（5分）
用JDK命令调试运行教材298页-300页程序7-2，结合程序运行结果理解程序；
按课件66-77内容练习并掌握Elipse的常用调试技术。
1）条件断点：在Eclipse Java 编辑区的行头双击就会得到一个断点，代码会运行到此处时停止。在断点处点击鼠标右键，选择最后一个“Breakpoint Properties”。
2）变量断点：在变量的值初始化，或是变量值改变时可以停止。
3）方法断点：方法断点就是将断点打在方法的入口处。
4）异常断点：当异常发生时，代码会停在异常发生处。
5）重新调试：回退时，请在需要回退的线程方法上点右键，选择“Drop to Frame”。
6）单步执行程序
7）检查变量
8）改变变量值
实验总结：（15分）经过一周的理论知识学习及实验相结合，理解并运用致命错误和非致命错误相关的知识。抛出异常，捕获异常等异常处理的知识的相关运用。捕获异常通过利用try字句、catch字句以及finally字句。断言知识的理解及应用。Java日志系统的用途及用法和Elipse的常用调试技术。在编译程序方面还是有问题，以后会不断锻炼自主编写代码的能力。
获奖感言：
作为这次小黄衫的获得者，在得奖的同时，也深感压力。首先感谢老师和同学的认可，以后我会更加努力的。在前面这半个学期，自己在很多方面做的还不是很好，很多知识还没有掌握。希望在本学期后面的时间里可以提升自己的能力，可以独立编写代码。不求做的最好，但求做的更好。