至此,java异常就介绍到这里。从放弃到开始,从删库到跑路,今天又遇到一位从入门到放弃的,哎,坚持不易,且行且珍惜,做什么都不是那么的容易,"台上一分钟,真的是台下十年功"!加油,为自己呐喊,为自己加油,为每个人看到此文章的人加油!!!!!!!!!!!!!!
本篇文章是基于异常学习一上讲的,所以不明白的请先看学习一链接:https://blog.csdn.net/qq_30764991/article/details/83244036
上篇文章讲到了异常的两种处理方式:上篇介绍的是异常的介绍与异常的try catch捕捉处理。那么这里就介绍不处理的,抛出的方式。
抛出处理
定义一个功能,进行除法运算例如(div(int x,int y))如果除数为0,进行处理。
功能内部不想处理,或者处理不了。就抛出使用throw new Exception("除数不能为0"); 进行抛出。抛出后需要在函数上进行声明,告知调用函数者,我有异常,你需要处理如果函数上不进行throws 声明,编译会报错。例如:未报告的异常 java.lang.Exception;必须对其进行捕捉或声明以便抛出throw new Exception("除数不能为0");
demo1如下:
package cn.demo;
public class TryTest {
public static void main(String[] args) throws Exception {
div(6, 0);
System.out.println("over");
}
public static void div(int x, int y) throws Exception { // 声明异常,通知方法调用者。
if (y == 0) {
throw new Exception("除数为0"); // throw关键字后面接受的是具体的异常的对象
}
System.out.println(x / y);
System.out.println("除法运算");
}
}
运算结果如下:
Exception in thread "main" java.lang.Exception: 除数为0
at cn.demo.TryTest.div(TryTest.java:10)
at cn.demo.TryTest.main(TryTest.java:5)
demo2代码如下:
package cn.demo;
public class TryTest2 {
public static void main(String[] args) {
try {
chufa(6, 0);//x,y分别是6,0: x,y分别是6与3
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("over");
}
//定义除法函数方法
public static void chufa(int x, int y) throws Exception { // 声明异常,通知方法调用者。
//如果y==0,抛出异常,异常信息,除数为0
if (y == 0) {
throw new Exception("除数为0"); // throw关键字后面接受的是具体的异常的对象
}
System.out.println(x / y);
System.out.println("除法运算");
}
}
运算结果:
x,y分别是6,0的运算结果如下:
java.lang.Exception: 除数为0
at cn.demo.TryTest2.chufa(TryTest2.java:19)
at cn.demo.TryTest2.main(TryTest2.java:8)
over
x,y分别是6,0的运算结果如下:
2
除法运算
over
-
throw和throws的区别,这个很多时候面试的时候都会考到,所以请各位注意下。
- 相同:都是用于做异常的抛出处理的。
- 不同点:
- 使用的位置: throws 使用在函数上,throw使用在函数内
- 后面接受的内容的个数不同:
- 1throws 后跟的是异常类,可以跟多个,用逗号隔开。
- 2throw 后跟异常对象。
- 1throws 后跟的是异常类,可以跟多个,用逗号隔开。
总结
- try语句不能单独存在,可以和catch、finally组成 try...catch...finally、try...catch、try...finally三种结构。
- catch语句可以有一个或多个,finally语句最多一个,try、catch、finally这三个关键字均不能单独使用。
- try、catch、finally三个代码块中变量的作用域分别独立而不能相互访问。如果要在三个块中都可以访问,则需要将变量定义到这些块的外面。
- 多个catch块时候,Java虚拟机会匹配其中一个异常类或其子类,就执行这个catch块,而不会再执行别的catch块。(子类在上,父类在下)。
- throw语句后不允许有紧跟其他语句,因为这些没有机会执行。
- 如果一个方法调用了另外一个声明抛出异常的方法,那么这个方法要么处理异常,要么声明抛出。
自定义异常:
问题:现实中会出现新的病,就需要新的描述。
分析: java的面向对象思想将程序中出现的特有问题进行封装。
案例: 定义功能模拟凌波登录。(例如:lb(String ip))需要接收ip地址
- 当没有ip地址时,需要进行异常处理。
1. 当ip地址为null是需要throw new Exception("无法获取ip");
2. 但Exception是个上层父类,这里应该抛出更具体的子类。
3. 可以自定义异常
- 自定义描述没有IP地址的异常(NoIpException)。
1. 和sun的异常体系产生关系。继承Exception类,自定义异常类名也要规范,结尾加上Exception,便于阅读
package cn.demo;
/*
自定义异常 ,这里自定义了一个没有ip的异常
自定义描述没有IP地址的异常(NoIpException)。
继承总的父异常Exception
*/
class NoIpException extends Exception {
// 序列化,如果不序列 ,会报警告
private static final long serialVersionUID = 1L;
// 无参构造
NoIpException() {
}
// 有参构造
NoIpException(String message) {
super(message);
}
}
class TryTest4 {
public static void main(String[] args) throws NoIpException {
System.out.println();
String ip = "192.168.21.104";// 定义本电脑的Ip 192.168.31.104
// ip为Null
ip = null;// "192.168.31.108";
try {
ipfunction(ip);// 调用ipfunction方法
} catch (NoIpException e) {
// ip为null,程序结束
System.out.println("没插网线吧,小白,程序结束");
}
}
// 定义ipfunction方法
public static void ipfunction(String ip) throws NoIpException {
if (ip == null) {// "192.168.31.108"
// throw new Exception("没插网线吧,小白");
throw new NoIpException("没插网线吧,小白");
}
System.out.println("醒醒了,开始上课了。");
}
}
运行结果:
没插网线吧,小白,程序结束
自定义参数demo2:
案例:模拟吃饭没带钱的问题
- 定义吃饭功能,需要钱。(例如:eat(double money))
- 如果钱不够是不能吃放,有异常。
- 自定义NoMoneyException();继承Exception 提供有参无参构造,调用父类有参构造初始化。at 方法进行判断,小于20块,throw NoMoneyException("钱不够");
- eat 方法进行声明,throws NoMoneyException
- 如果钱不够老板要处理。调用者进行处理。try{}catch(){} 。
package cn.demo;
class NoMoneyException extends Exception {
NoMoneyException() {
}
NoMoneyException(String message) {
super(message);
}
}
class TryTest5 {
public static void main(String[] args) {
System.out.println();
try {
eat(100);// 调用吃饭的函数方法,eat中赋值,如赋值2则报钱不够,说明是小于规定的价格
} catch (NoMoneyException e) {
System.out.println("钱不够,得努力学习,跟我干活吧。");
}
}
// 定义一个吃饭功能方法
public static void eat(double money) throws NoMoneyException {
// 如果钱小于20块,抛出钱不够,得努力学习
if (money < 20) {
throw new NoMoneyException("钱不够,得努力学习");
}
// 大于则可吃到
System.out.println("高兴的吃大餐,大餐是湖南米粉,哈哈");
}
}
运算结果:
高兴的吃大餐,大餐是湖南米粉,哈哈
-
- 运行时异常和非运行时异常
- RuntimeException
- 运行时异常和非运行时异常
RunntimeException的子类:
ClassCastException
多态中,可以使用Instanceof 判断,进行规避
ArithmeticException
进行if判断,如果除数为0,进行return
NullPointerException
进行if判断,是否为null
ArrayIndexOutOfBoundsException
使用数组length属性,避免越界
这些异常时可以通过程序员的良好编程习惯进行避免的
1:遇到运行时异常无需进行处理,直接找到出现问题的代码,进行规避。
2:就像人上火一样牙疼一样,找到原因,自行解决即可
3:该种异常编译器不会检查程序员是否处理该异常
4:如果是运行时异常,那么没有必要在函数上进行声明。
6:案例
1:除法运算功能(div(int x,int y))
2:if判断如果除数为0,throw new ArithmeticException();
3:函数声明throws ArithmeticException
4:main方法调用div,不进行处理
5:编译通过,运行正常
6:如果除数为0,报异常,程序停止。
7:如果是运行时异常,那么没有必要在函数上进行声明。
1:Object类中的wait()方法,内部throw了2个异常 IllegalMonitorStateException InterruptedException
1:只声明了一个(throws) IllegalMonitorStateException是运行是异常没有声明。
package cn.demo;
public class TryTest6 {
public static void main(String[] args) {
div(2, 0);
}
public static void div(int x, int y) {
if (y == 0) {
throw new ArithmeticException("除数为0的算数异常");
}
System.out.println(x / y);
}
}
finally
1: 实现方式一:
try{ // 可能发生异常的代码 } catch( 异常类的类型 e ){ // 当发生指定异常的时候的处理代码 }catch...
比较适合用于专门的处理异常的代码,不适合释放资源的代码。
2:实现方式二:
try{ } catch(){} finally{ // 释放资源的代码 }
finally块是程序在正常情况下或异常情况下都会运行的。
比较适合用于既要处理异常又有资源释放的代码
3:实现方式三
try{ }finally{ // 释放资源 }
比较适合处理的都是运行时异常且有资源释放的代码。
4:finally:关键字主要用于释放系统资源。
1:在处理异常的时候该语句块只能有一个。
2:无论程序正常还是异常,都执行finally。
5:finally是否永远都执行?
1:只有一种情况,但是如果JVM退出了System.exit(0),finally就不执行。
2:return都不能停止finally的执行过程。
6:案例使用流
1:使用FileInputStream加载文件。
导包import java.io.FileInputStream;
2:FileNotFoundException
导入包import java.io.FileNotFoundException;
3:IOException
import java.io.IOException;
package cn.demo;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TryTest8 {
// 本例子使用finally 关闭系统资源。
public static void main(String[] args) {
FileInputStream fin = null;
try {
System.out.println("1创建io流可能出现异常");
fin = new FileInputStream("aabc.txt"); // 加载硬盘的文本文件到内存,通过流
// System.out.println(fin);
} catch (FileNotFoundException e) {
System.out.println("2没有找到abc.txt 文件");
System.out.println("3catch 了");
// System.exit(0);
// return;
}
// finally
finally {
System.out.println("4fianlly执行");
if (fin != null) { // 如果流对象为null 流对象就不存在,没有必要关闭资源
try {
fin.close();
} catch (IOException e) {
e.printStackTrace();
System.out.println("close 异常");
}
}
System.out.println("5finally over");
}
System.out.println("6mainover");
}
}
// 2:无论程序正常还是异常,都执行finally。 但是遇到System.exit(0); jvm退出。
// finally用于必须执行的代码, try{} catch(){}finally{}
// try{}finally{}