异常处理
Java提供了异常处理机制来帮助程序猿检查可能出现的错误，保证了程序的可读性和可维护性。Java中将异常封装到一个类中，出现错误时，就会抛出异常。
异常概述
- java语言是一门面向对象的编程语言，因此，异常在java语言中也是作为类的实例的形式出现的。
- 当某一方法中发生错误时，这个方法会创建一个对象，并且把它传递给正在运行的系统。这个对象就是异常对象
- 通过异常处理机制，可以将非正常情况下的处理代码与程序的主逻辑分离，即在编写代码主流程的同时在其他地方处理异常。
处理程序异常错误
本节将介绍java中捕获异常的方法
错误
捕捉异常
java语言的异常捕获结构由try、catch和finally 3部分。其中：
- try语句块存放的是可能发生异常的java语句
- catch程序块在try语句块之后，用来激发被捕获的异常；
- finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块。
- 语法如下：
try{
//程序代码块
}
catch(Exceptiontype1 e){
//对 Exceptiontype1 的处理
}
catch(Exceptiontype2 e){
//对 Exceptiontype2 的处理
}
...
finally{
//程序块
}
try-catch语句块
public class Take { // 创建类
public static void main(String[] args) {
try { // try语句中包含可能出现异常的程序代码
String str = "lili"; // 定义字符串变量
System.out.println(str + "年龄是："); // 输出的信息
int age = Integer.parseInt("20L"); // 数据类型转换
System.out.println(age);
} catch (Exception e) { // catch语句块用来获取异常信息
e.printStackTrace(); // 输出异常性质
}
System.out.println("program over"); // 输出信息
}
}
在上面例题中将可能出现异常的代码用try-catch语句块进行处理，当try代码块中的语句发生异常时，程序就会调转到catch代码块中执行，执行完catch代码块中的程序代码后，将继续执行catch代码块后的其他代码，而不会执行try代码块中发生一成语句后面的代码。
由此可知，Java的异常处理是结构化的，不会因为一个异常印象整个程序的执行。
Exception是try代码块传递给catch代码块的变量类型，e是变量名。catch代码块中语句“e.getMessage();”用于输出错误性质。通常，异常处理常用一下3个函数来获取异常的有关信息：
- getMessage()函数：输出错误性质。
- toString()函数：给出异常的类型与性质。
- printStackTrace()函数：指出异常的类型、性质、栈层次及出现在程序中的位置。
finally语句块
完整的异常处理语句一定要包含finally语句，无论程序中有无异常发生，并且无论之前的try-catch是否顺利执行完毕，都会执行finally语句。
在以下4种特殊情况下，finally块不会被执行；
- 在finally语句块中发生了异常。
- 在前面的代码块中使用了System.exit()退出程序。
- 程序所在的线程死亡
- 关闭CPU
Java常见异常
| 异常类 | 说明 |
|---|---|
| ClassCastException | 类型转换异常 |
| ClassNotFoundException | 未找到相应类异常 |
| ArithmeticException | 算术异常 |
| ArrayIndexOutOfBoundsException | 数组下标越界异常 |
| ArrayStoreException | 数组中包含不兼容的值抛出的异常 |
| SQLException | 操作数据库异常类 |
| NullPointerException | 空指针异常 |
| NoSuchFieldException | 字段未找到异常 |
| NoSuchMethodExcetion | 方法为找到抛出的异常 |
| NumberFormatException | 字符串转换为数字抛出的异常 |
| NegativeArraySizeException | 数组元素个数为负数抛出的异常 |
| StringIndexOutOfBoundsException | 字符串索引超出范围抛出的异常 |
| IOException | 输入输出异常 |
| IllegalAccessException | 不允许访问某类 异常 |
| InstantiantionException | 当应用程序试图使用Class类中的newInstance()方法创建一个类的实例， |
| （接上） . | 而指定的类对象无法被实例化时，抛出该异常 |
| EOFException | 文件已结束异常 |
| FileNotFoundException | 文件未找到异常 |
自定义异常
用户只需继承Exception类即可自定义异常类
- 自定义异常类步骤：
- 创建自定义异常类
- 在方法中通过throw关键字抛出异常对象。
- 如果在当前抛出异常的方法中处理异常，可以使用try—catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
- 再出现异常方法的调用这种不火并处理异常。
例：
public class MyException extends Exception {//创建自定义异常，继承Exception类
public MyException(String ErrorMessagr) { // 构造方法
super(ErrorMessagr); // 父类构造方法
}
}
public class Tran { // 创建类
// 定义方法，抛出异常
static int avg(int number1, int number2) throws MyException {
if (number1 < 0 || number2 < 0) { // 判断方法中参数是否满足指定条件
throw new MyException("不可以使用负数"); // 错误信息
}
if (number1 > 100 || number2 > 100) { // 判断方法中参数是否满足指定条件
throw new MyException("数值太大了"); // 错误信息
}
return (number1 + number2) / 2; // 将参数的平均值返回
}
public static void main(String[] args) { // 主方法
try { // try代码块处理可能出现异常的代码
int result = avg(102, 150); // 调用avg()方法
System.out.println(result); // 将avg()方法的返回值输出
} catch (MyException e) {
System.out.println(e); // 输出异常信息
}
}
}
在方法中抛出异常
若某个方法可能会发生异常，但不想在当前方法中处理这个异常，则可以使用thorws、throw关键字在方法中抛出异常。
使用throws关键字抛出异常
- throws关键字通常被应用在声明方法时，用来指定方法可能抛出的异常。多个异常可使用逗号分隔。
- 使用throws关键字将异常抛给上一级后，如果不想处理该异常，可以继续向上抛出，但最重要有能够处理该异常的代码。
- 例
public class Tran { // 创建类
// 定义方法，抛出异常
static int avg(int number1, int number2) throws MyException {
if (number1 < 0 || number2 < 0) { // 判断方法中参数是否满足指定条件
throw new MyException("不可以使用负数"); // 错误信息
}
if (number1 > 100 || number2 > 100) { // 判断方法中参数是否满足指定条件
throw new MyException("数值太大了"); // 错误信息
}
return (number1 + number2) / 2; // 将参数的平均值返回
}
public static void main(String[] args) { // 主方法
try { // try代码块处理可能出现异常的代码
int result = avg(102, 150); // 调用avg()方法
System.out.println(result); // 将avg()方法的返回值输出
} catch (MyException e) {
System.out.println(e); // 输出异常信息
}
}
}
如果是Error、RuntimeException或它们的子类，可以不使用throws关键字来声明要抛出的异常，
编译仍能顺利通过，但在运行时会被系统抛出
使用throw关键字抛出异常
throw关键字通常用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，他后面的语句都不执行。
throw通常用来抛出用户自定义异常
public class MyException extends Exception { // 创建自定义异常类
String message; // 定义String类型变量
public MyException(String ErrorMessagr) { // 父类方法
message = ErrorMessagr;
}
public String getMessage() { // 覆盖getMessage()方法
return message;
}
}
public class Captor { // 创建类
static int quotient(int x, int y) throws MyException { // 定义方法抛出异常
if (y < 0) { // 判断参数是否小于0
throw new MyException("除数不能是负数"); // 异常信息
}
return x / y; // 返回值
}
public static void main(String args[]) { // 主方法
try { // try语句包含可能发生异常的语句
int result = quotient(3, -1); // 调用方法quotient()
} catch (MyException e) { // 处理自定义异常
System.out.println(e.getMessage()); // 输出异常信息
} catch (ArithmeticException e) { // 处理ArithmeticException异常
System.out.println("除数不能为0"); // 输出提示信息
} catch (Exception e) { // 处理其他异常
System.out.println("程序发生了其他的异常"); // 输出提示信息
}
}
}
运行时异常
Java中提供了常见的RuntimeException异常，这些异常可通过try-catch可语句捕获
RuntimeException异常的种类
| 种类 | 说明 |
|---|---|
| NullPointerException | 空指针异常 |
| ArrayIndexOutOfBoundsException | 数组下标越界异常 |
| ArithmeticException | 算术异常 |
| ArrayStoreException | 数组中包含不兼容的值抛出的异常 |
| IllegalArgumentException | 非法参数异常 |
| SecurityException | 安全性异常 |
| NegativeArraySizeException | 数组长度为负异常 |
异常的使用原则
- 在当前方法声明中使用try-catch语句捕获异常。
- 一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。
- 如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。
实践与练习
终于终于又是习题了，先去洗个澡，休息回来再做。
1.
编写一个异常类MyException，再编写一个类Student，该类有一个产生异常的方法speak(int m)。要求参数m的值大于1000时，方法抛出一个MyException对象。最后编写主类，在主方法中创建Student对象，让该对象调用speak()方法。
public class Student {
void speak(int m) throws MyException {
if (m > 1000) {
throw new MyException("try");
} else {
System.out.println(m + "ok");
}
}
public static void main(String args[]) {
Student boy = new Student();
try {
boy.speak(999);
boy.speak(2999);
} catch (MyException e) {
System.out.println(e);
}
}
}
class MyException extends Exception {
public MyException(String ErrorMessage) {
super(ErrorMessage);
}
}
2.
创建类Number，通过类中的方法count可得到任意两个数相乘的结果，并在调用该方法的主方法中使用try-catch语句捕捉可能发生的异常
public class Brunt {
public static int count(int m, int n) {
return m * n;
}
public static void main(String args[]) throws Exception {
try {
int result = count(12315, 57876876);
System.out.println(result);
} catch (Exception e) {
e.printStackTrace();
}
}
}
3.
创建类Computer,该类中有一个计算两个数的最大公约数的方法，如果向该方法传递负整数，该方法就会抛出自定义异常。
求最大公约数方法这点挺重要：
一是辗转相除法，两者相除取余，然后小的和余数继续除，直到没有余数的前一个余数即答案。
二是更相减损法，若都是偶数，则除2，除到有一方不是偶数，然后相减，将得数与被减数再相减，直到得数与被减数相等。
这里用辗转相除法
public class Computer {
static int solution(int a, int b) throws MyException {
int x, y, z;
if (a < 0 || b < 0) {
throw new MyException("不能使用负数");
}
if (a > b) {
x = a;
y = b;
} else if (a < b) {
x = b;
y = a;
} else {
return a;
}
do {
z = x % y;
x = y;
y = z;
} while (z == 0);
return y;
}
public static void main(String args[]) throws MyException {
try {
System.out.println(Computer.solution(554, 268));
System.out.println(Computer.solution(-453, -11));
} catch (MyException e) {
System.out.println(e);
}
}
}
class MyException extends Exception {
MyException(String a) {
super(a);
}
}
小结
经过一次笔试之后发现自己许多方面都缺好多，还得赶赶进程，明天开始每天一篇博客吧。然后，手撕代码很重要，所以这次的习题基本都是在网页上先码出来，然后放到eclipse上测试，修改，在ctrl+shift+f整理格式，才粘贴上来的。
扫一扫
673
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
