201871010112-梁丽珍《面向对象程序设计（java）》第十周学习总结
| 项目php |
内容html |
| 这个做业属于哪一个课程java |
|
| 这个做业的要求在哪里typescript |
https://www.cnblogs.com/nwnu-daizh/p/11778090.html数据库 |
| 做业学习目标编程 |
1.掌握java异常处理技术；数组 2.了解断言的用法；缓存 3.了解日志的用途；安全 4.掌握程序基础调试技巧。 |
第一部分：总结第七章关于异常处理相关理论知识
- 概述：异常就是java程序在运行过程当中出现的错误。
- 异常发生时如何处理，java提供了解决办法：异常处理机制。
- java中的异常能够是函数中的语句执行时引起的，也能够是程序员经过throw语句手动抛出。
- 只要在java程序中产生了异常，就会用一个对应类型的异常对象来封装异常，JRE会试图寻找异常处理程序来处理异常。
- JDK中内建类一些常见的异常类，咱们也能够自定义异常。
- Throwable类是java异常类型的顶层父类，一个对象只有是Throwable类的直接或间接实例，他才是一个异常对象，才能被异常处理机制识别。
异常分类
一、检查性异常：
（1）最具表明性的检查性异常是用户错误或问题引发的异常，这是程序员没法预测的。 （2）例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单的忽略。
二、运行时异常：
（1）运行时异常是可能被程序员避免的异常。 （2）与检查性异常相反，运行时异常能够在编译时被忽略。
三、错误：
（1）错误不是异常，而是脱离程序员控制的问题。 （2）错误在代码中一般被忽略。 （3）例如，当栈溢出时，一个错误就发生了，它们在编译时也是检查不到的。
四、异常分类图解：
Error和Exception类
- java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。
- Throwable又派生出Error类和Exception类。
-
Error类：
（1）Error类以及他的子类的实例，表明了JVM自己的错误。 （2）错误不能被程序员经过代码处理，Error不多出现。 （3）所以，程序员应该关注Exception为父类的分支下的各类异常类 -
Exception类：
（1）Exception及他的子类，表明程序运行时发送的各类不指望发生的事件。 （2）能够被java异常处理机制使用，是异常处理的核心。 - Error错误是没法恢复，不能获取的，如系统崩溃，虚拟机错误，动态连接失败等。这会致使程序直接中断。
- Exception是咱们常说的异常，他又大体分为两类，一类是运行时异常：
RuntimeException，另外一类就是其余异常。由于RuntimeException是由Java虚拟机自动抛出并自动捕获，因此又叫非检查异常。而另外一类异常就不同了，须要咱们手动的捕获和处理异常，因此叫作检查异常。
异常处理
- 异常处理机制能让程序在发生异常时，按照代码预先设定的异常处理逻辑，针对性的处理异常，让程序尽最大可能的恢复正常并继续执行，且保持代码的清晰。
- java中，异常处理的任务就是将执行控制流从异常发生的地方转移到可以处理这种异常的地方去。
- java异常处理涉及到五个关键字，分别是：try、catch、finally、throw、throws。
- try -- 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块以内，当try语句块内发生异常时，异常就被抛出。
- catch -- 用于捕获异常。catch用来捕获try语句块中发生的异常。在编写多个catch的时候，捕获范围大的异常必定要放在捕获范围小的异常后面。
- finally -- finally语句块老是会被执行。它主要用于回收在try块里打开的物力资源(如数据库链接、网络链接和磁盘文件)。只有finally块执行完成以后，才会回来执行try或者catch块中的return或者throw语句，若是finally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接中止。
- throw -- 用于抛出一个实例化的异常对象。
- throws -- 用在方法签名中，用于声明该方法可能抛出的异常，若是方法真的出现异样，将交由调用者来处理。调用了具备throws申明的方法以后，无论异常是否出现，调用者必须使用try...catch处理。调用声明了运行时异常的函数，能够不强制处理，将交给jvm默认处理。
-
在编写代码处理异常时，对于检查异常，有两种处理方式：
（1）使用try...catch...finally语句块处理 （2）在函数签名中使用throws声明交给函数调用者caller去解决
五、try...catch...finally语句块：
（1）try块中放可能发生异常的代码；
（2）若是执行完try而且不发生异常，则接着去执行finally块代码以及finally以后的代码；
（3）若是执行try中代码发生异常，就会尝试匹配catch块；
（4）每个catch块用于处理一个异常；
（5）异常匹配是按照catch块的顺序从上往下寻找的，只有第一个会匹配到的catch块会被执行。
（6）try块中的局部变量和catch块中的局部变量，以及finally中的局部变量，它们之间不能够共享使用；
（7）finally块无论异常是否发生，只要对应的try块执行了，它必定会执行。
（8）finally块一般用来作资源释放操做，关闭文件或者关闭数据库等操做。
六、throws/throw：
（1）若是一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。
（2）throws 关键字放在方法签名的尾部。
（3）throws仅仅是将函数中可能出现的异常向调用者声明，而本身并不处理异常。
（4）采用这种异常处理的缘由多是：方法自己不知道如何处理这种异常，或者说让调用者处理更好，调用者须要为可能发生的异常负责。
（5）也可使用 throw 关键字手动抛出一个异常，不管它是新实例化的仍是刚捕获到的。
（6）throw语句的后面必须是一个异常对象。
异常的捕获
try...catch...
若是没有咱们使用最原始的解决异常是个什么办法：
而后 有了能表示全部的异常状况而后处理掉 try...catch
若是try块里的业务逻辑代码出现了异常，系统就会生成一个异常对象，而后将该对象提交给Java运行时环境（throw），接着查找catch块，若是找到了合适的catch块，就将该异常对象交由该catch块处理。这个过程又叫作捕获（catch）异常；若是找不到合适的catch块，程序将退出。
finally回收资源
finally，最终的，也就是咱们处理完异常最后要作的事情。因为有时候咱们会在try块里面使用一些资源，这些资源最后也就在finally块里被回收掉了。
异常链
对于一个完整的应用而言，都是有比较严格的分层关系的，上层依赖下层的API。而对于用户而言，咱们不想看到底层的SQL异常，同时也会使得系统不安全。因此这时咱们就要将底层的异常捕获，而后再抛出一个新的业务异常，就能够在新的异常中给出用户比较友好的提示信息。
或者咱们也能够这样处理异常：
这是因为Throwable基类有了一个能够接受Exception参数的方法。
自定义异常
虽然java已经提供了不少系统性异常，但在开发中仍是没法知足实际的须要。因此java容许用户自定义异常。语法以下:
总结
- 处理运行时异常时，采用逻辑去合理规避，同时辅助使用try-catch处理。
- 在多重catch块后面，加一个catch(Exception)来处理可能遗漏的异常。
- 对于不肯定的代码，也能够加上try-catch，处理潜在的异常。
- 尽可能去处理异常，切记只是简单的调用printStackTrace()去打印输出。
- 尽可能添加finally块去释放所占用的资源。
- 具体若是处理异常，要根据不一样的业务需求和异常类型去决定。
2、实验内容和步骤
实验1：用命令行与IDE两种环境下编辑调试运行源程序ExceptionDemo1、ExceptionDemo2，结合程序运行结果理解程序，掌握未检查异常和已检查异常的区别。
示例1代码：
package project7;
//异常示例1
public class ExceptionDemo1 {
public static void main(String args[]) {
int a = 0;
System.out.println(5 / a);
}
}
// 线程中的异常为 ArithmeticException 算术异常
//代码错误 5/0 (ExceptionDemo1.java:6)
//此异常为Throwable类中的子类Exception（RuntimeException/unchecked Exception）
//未检查异常
//编译器不要求强制处理的异常，虽然有可能出现错误，但不会再编译的时候检查
//此算术异常是由程序员失误形成的，编译器没编译以前根本不知道会出现这种错误。
//这种不能被直接检查出的错误被称为非检查型异常，便是不能被try catch捕获的异常
运行：
示例2代码：
package project7;
//异常示例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();
}
}
//线程中出现的异常： 未解决的编译问题
//异常类型：FileNotFoundException/ IOException
//出现异常处：(ExceptionDemo2.java:8)
//已检查异常
//编译器要求你必须处理的异常（代码还没运行，编译器就会检查你的代码，会不会出现异常，要求你对可能出现的异常必须作出相应的处理）
//编译器要求你对这段代码 try...catch,或者throws exception
/* 对已检查异常的处理：
* 一、继续抛出，消极的方法，一直能够抛到java虚拟机来处理，就是经过throws exception抛出。
* 二、用try...catch捕获
* 注意：对于检查的异常必须处理，或者必须捕获或者必须抛出
* */
运行：
实验2： 导入如下示例程序，测试程序并进行代码注释。
测试程序1：
在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 + "):");
Throwable t = new Throwable(); //调用Throwable类的getStackTrace方法访问堆栈轨迹的文本描述信息
StackTraceElement[] frames = t.getStackTrace(); //获得StackTraceElement对象的一个数组，并在程序中分析这个对象数组
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);
in.close();
}
}
运行：
测试程序2：
Java语言的异常处理有积极处理方法和消极处理两种方式；
下列两个简单程序范例给出了两种异常处理的代码格式。在elipse IDE中编辑、调试运行源程序ExceptionTest.java，将程序中的text文件更换为身份证号.txt，要求将文件内容读入内容，并在控制台显示；
掌握两种异常处理技术的特色。
代码1：
package project7;
//积极处理方式
import java.io.*;
class ExceptionTest1 {
public static void main (String args[])
{
try{
FileInputStream fis=new FileInputStream("F:/身份证号.txt");
BufferedReader in = new BufferedReader(new InputStreamReader(fis));
try {
String s, s2 = new String();
while ((s = in.readLine()) != null) {
s2 += s + "\n ";
}
in.close();
System.out.println(s2);
}
catch (IOException e)
{
System.out.println("学生信息文件读取错误");
e.printStackTrace();
}
}catch (FileNotFoundException e) {
System.out.println("学生信息文件找不到");
e.printStackTrace();
}
}
}
运行：
代码2：
package project7;
//消极处理方式
import java.io.*;
class ExceptionTest2 {
public static void main (String args[]) throws IOException
{
FileInputStream fis=new FileInputStream("F:/身份证号.txt");
BufferedReader in = new BufferedReader(new InputStreamReader(fis));
String s, s2 = new String();
while ((s = in.readLine()) != null) {
s2 += s + "\n ";
}
in.close();
System.out.println(s2);
}
}
运行：
实验3: 编程练习
编写一个计算器类，能够完成加、减、乘、除的操做；
利用计算机类，设计一个小学生100之内数的四则运算练习程序，由计算机随机产生10道加减乘除练习题，学生输入答案，由程序检查答案是否正确，每道题正确计10分，错误不计分，10道题测试结束后给出测试总分；
将程序中测试练习题及学生答题结果输出到文件，文件名为test.txt；
在以上程序适当位置加入异常捕获代码。
代码：
package project7;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
public class jisuan {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
jieguo student=new jieguo();
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 c= (int) Math.round(Math.random() * 3);
switch(c)
{
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 == student.division(a, b)) {
sum += 10;
System.out.println("right");
}
else {
System.out.println("false");
}
break;
case 1:
System.out.println(i+": "+a+"*"+b+"=");
int D = in.nextInt();
out.println(a+"*"+b+"="+D);
if (D == student.multiplication(a, b)) {
sum += 10;
System.out.println("right");
}
else {
System.out.println("false");
}
break;
case 2:
System.out.println(i+": "+a+"+"+b+"=");
int E = in.nextInt();
out.println(a+"+"+b+"="+E);
if (E == student.add(a, b)) {
sum += 10;
System.out.println("right");
}
else {
System.out.println("false");
}
break ;
case 3:
System.out.println(i+": "+a+"-"+b+"=");
int F = in.nextInt();
out.println(a+"-"+b+"="+F);
if (F == student.reduce(a, b)) {
sum += 10;
System.out.println("right");
}
else {
System.out.println("false");
}
break ;
}
}
System.out.println("成绩"+sum);
out.println("成绩:"+sum);
out.close();
}
}
package project7;
public class jieguo {
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，结合程序运行结果理解程序；
注释语句test1(-5);后从新运行程序，结合程序运行结果理解程序；
掌握断言的使用特色及用法。
运行：
注释语句test1(-5);后从新运行程序，控制台只输出-3，不输出-5
实验程序2：
用JDK命令调试运行教材298页-300页程序7-2，结合程序运行结果理解程序；
并掌握Java日志系统的用途及用法。
使用命令行调试。。。调试不出
实验程序3：
用JDK命令调试运行教材298页-300页程序7-2，结合程序运行结果理解程序；
按课件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;
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();//经过Hander类自定义一个处理器
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");
//调用Logger类的getLogger方法获得一个日志记录器
public ImageViewerFrame()
{
logger.entering("ImageViewerFrame", "<init>");
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
// set up menu bar
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);
}
});
// 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
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
{
//WindowHandler这个处理器扩展于StreamHander类，而且安装了一个流。
//使用这种方法时，处理器会缓存记录，而且只有在缓存满的时候，才将它们写入流中。
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)//write方法将流显示输出到文本框中。
{
} // not called
public void write(byte[] b, int off, int len)
{
output.append(new String(b, off, len));
//append 新构造的文件处理器对象应该追加在一个已存在的日志文件尾部，则为TRUE
}
});
}
public void publish(LogRecord record)
//将日志发送到目的地
{
if (!frame.isVisible()) return;
super.publish(record);
flush();//覆盖publish方法，以便在处理器得到每一个记录以后刷新缓冲区。
}
}
结果没能调试运行出来。。。
实验总结：
本周主要讲了异常方面的知识，学习了异常的处理方法，感受本身学的没有特别清楚，尤为是日志方面的知识，最后一个程序阅读特别困难，都没调试出来。。。还须要继续学习。
相关文章
- 1. 201871010112-梁丽珍《面向对象程序设计（java）》第四周学习总结
- 2. 201871010112-梁丽珍《面向对象程序设计（java）》第七周学习总结
- 3. 201871010112-梁丽珍《面向对象程序设计（java）》第二周学习总结
- 4. 201871010112-梁丽珍《面向对象程序设计（java）》第一周学习总结
- 5. 201871010112-梁丽珍《面向对象程序设计（java）》第八周学习总结
- 6. 201871010112-梁丽珍《面向对象程序设计（java）》第十一周学习总结
- 7. 201871010112-梁丽珍《面向对象程序设计（java）》第6、七周学习总结
- 8. 201871010123-吴丽丽 《面向对象程序设计（Java）》第十周学习总结
- 9. 201871010123-吴丽丽《面向对象程序设计（Java）》第一周学习总结
- 10. 201871010123-吴丽丽《面向对象程序设计（java）》第二周学习总结
- 更多相关文章...
- • PHP 面向对象 - PHP教程
- • Lua 面向对象 - Lua 教程
- • 算法总结-归并排序
- • 使用Rxjava计算圆周率
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 201871010112-梁丽珍《面向对象程序设计（java）》第四周学习总结
- 2. 201871010112-梁丽珍《面向对象程序设计（java）》第七周学习总结
- 3. 201871010112-梁丽珍《面向对象程序设计（java）》第二周学习总结
- 4. 201871010112-梁丽珍《面向对象程序设计（java）》第一周学习总结
- 5. 201871010112-梁丽珍《面向对象程序设计（java）》第八周学习总结
- 6. 201871010112-梁丽珍《面向对象程序设计（java）》第十一周学习总结
- 7. 201871010112-梁丽珍《面向对象程序设计（java）》第6、七周学习总结
- 8. 201871010123-吴丽丽 《面向对象程序设计（Java）》第十周学习总结
- 9. 201871010123-吴丽丽《面向对象程序设计（Java）》第一周学习总结
- 10. 201871010123-吴丽丽《面向对象程序设计（java）》第二周学习总结