概念
1. 什么是异常：异常是指在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序。
2. 什么是异常处理：异常处理是编程语言的一种机制，对可能出现的问题进行预处理，异常处理完毕后，程序可以继续运行，增强系统的健壮性和安全性。
3. 异常处理的必要性：异常处理用于解决一些程序无法掌控，但又必须面对的情况。为了程序能继续运行，就需要把这些情况进行异常处理。异常处理的方法通常有以下几种：
1) 将异常通知给开发人员、运维人员或用户
2) 因为异常中断的程序以适当的方式继续运行，或者退出
3) 保存用户的当前操作，或者进行数据回滚
4) 释放资源
4. Java 编程语言提供了异常处理机制为程序提供了错误处理的能力
异常分类
1) Throwable 类是 Java 异常类型的顶层父类，一个对象只有是 Throwable类的实例，才是一个异常对象，才能被异常处理机制识别,位于java.lang包中。
2) 按照错误严重性，从 Throwale 类中衍生出 Error 和 Exception 两大派系
a) Error（错误）：程序在执行过程中所遇到的硬件或系统的错误。错误对程序而言是致命的，将导致程序无法运行。不允许捕获。当发生 Error 时，只能依靠外界干预。常见错误： StackOverflowError、OutOfMemoryError等。
b) Exception（异常）：是程序运行过程中，可以预料的意外情况。比如空指针，数组下标越界。异常出现可以被捕获处理掉，使程序继续运行。
public class Demo {
public static void main(String[] args) {
//异常：可以处理
// int[] arr = {3,2,4,5};
// System.out.println("arr[4]:"+arr[4]);//java.lang.ArrayIndexOutOfBoundsException: 4
//错误：不能处理
//int[] arr2 = new int[1024*1024*1024];//java.lang.OutOfMemoryError: Java heap space
//异常：检查异常和运行时异常
int div = 10/0;//java.lang.ArithmeticException: / by zero//编译器不检查的异常
//编译器能检查出来：检查异常
//FileInputStream fis = new FileInputStream("d:\\hello.txt");
}
}3) Exception：又分为编译时异常和运行时异常。
RuntimeException：运行时异常，可处理，可不处理。
CheckedException：检查时异常，必须处理
a) 运行时异常都是 RuntimeException 类及其子类, 这些异常是不检查的异常, 是在程序运行的时候可能会发生的, 所以程序可以捕捉, 也可以不捕捉。程序应该从逻辑角度去尽量避免。如：空指针、数组下标越界等
NullPointerException
ArrayIndexOutOfBoundsException//数组越界
ArithemicException
ClassCastException
NumberFormatException
b) 编译时异常也叫检查异常，是运行时异常以外的异常, 也是 Exception 及其子类, 这些异常从程序的角度来说是必须经过捕捉检查处理的, 否则不能通过编译. 如 IOException、SQLException 等。
FileNotFoundExcetpion
IOException
SQLException
import java.io.FileInputStream;
public class ExceptionDemo {
public static void main(String[] args) {
//异常：检查异常和运行时异常
try {
int div = 10 / 0;//java.lang.ArithmeticException: / by zero//编译器不检查的异常
FileInputStream fis = new FileInputStream("d:\\hello.txt");
System.out.println("----------------------");
}
// catch(ArithmeticException e){
// System.out.println("捕获了异常....");
// }
// catch (FileNotFoundException e) {
// e.printStackTrace();
// }
catch (Exception e) {
e.printStackTrace();//追踪信息
} finally {//可选的，可以有，可以没有
//无论是否产生异常，都会执行finally语句块里面的代码
System.out.println("finally语句块一定要执行....");
}
System.out.println("hello,world!!!");
System.out.println("hello,world!!!");
System.out.println("hello,world!!!");
//编译器能检查出来：检查异常
//FileInputStream fis = new FileInputStream("d:\\hello.txt");
}
}4) 异常分类的结构图
异常产生和传递
异常产生
自动抛出异常：当程序在运行时遇到不符合规范的代码或结果时，会产生异常。
手动抛出异常：语法：throw new 异常类型(“实际参数”)。
产生异常结果：相当于遇到 return语句，导致程序因异常而终止。
异常传递
按照方法的调用链反向传递，如始终没有处理异常，最终会由JVM进行默认异常处理（打印堆栈跟踪信息）。
受查异常：throws 声明异常，修饰在方法参数列表后端。
运行时异常：因可处理可不处理，无需声明异常。
异常的处理
捕获异常：try，catch，finally
语法规则：
try{
//可能产生异常的代码
}catch(异常类型1 e){
//捕获异常的处理
}catch(异常类型2 e){
//捕获异常的处理
}finally{
//无论程序是否产生异常，此处的代码一定会被执行。
//比如说：释放资源，删除临时文件等。。。
}
注意点：
1.一个try可以匹配多个catch语句
2.如果try中产生了异常对象，那么会跳出try，进到相应的catch中处理异常，从上向下匹配。
3.如果是多个catch语句，那么小的异常捕获处理写前面，大的异常捕获处理写后面。
4.finally是可选的
声明异常 throws
方法级别上，向外抛出异常。
方法的声明上就要通过throws关键字声明抛出异常：
public static void test1(int i,int j)throws NullPointerException{
}
[修饰符1，修饰符2.。。] 返回值类型/void 方法名(参数列表) 异常的声明{
}按照方法的调用链反向传递，如始终没有处理异常，最终会由JVM进行默认异常处理（打印堆栈跟踪信息）。
public static void test1() throws ArithmeticException{
int i=10;
int j =0;
int div = i/j;
System.out.println("div:"+div);
System.out.println("test1.....end.....");
}
public static void test2() throws ArithmeticException{
// try {
// test1();
// } catch (ArithmeticException e) {
// e.printStackTrace();
// }
test1();
System.out.println("test2......end....");
}
public static void test3() throws FileNotFoundException {
File file = new File("c:\\a.jpg");
FileInputStream fis = new FileInputStream(file);
}
public static void test4() throws Exception{
//FileNotFoundException
test3();//检查异常一定要处理，强制处理
}
public static void test5() throws Exception{
}
public static void test6(){
test5();
}
public static void main(String[] args) {
try {
test2();
} catch (ArithmeticException e) {
e.printStackTrace();
}
System.out.println("main......end......");
}运行时异常的抛出，不一定要处理
检查异常的抛出，必须处理
Exception和RuntimeException的区别？
1.RuntimeException是Exception的子类。
2.Exception包含了受检异常，所以抛出Exception以及受检异常时，代码中一定要给与处理。如果抛出的是RuntimeException(运行时异常，非受检)以及它的子类异常，程序中不一定非要处理。
3.重写的时候，子类不能抛出比父类更大的异常
class Person{
public void eat() throws FileNotFoundException{
}
}
class Student extends Person{
@Override
public void eat() throws Exception{
}
}
public class Demo7 {
public void test(Person p){
p.eat();
}
public static void main(String[] args) {
}
}throw 关键字
throw和throws的区别？
1.throws，用于定义方法的时候，声明该方法向外抛出异常。
2.throw，主动抛出一个异常的对象。打断程序的执行。配合trycatch，或者throws来使用。
Exception exception = new Exception("我自定义的异常。。");
try {
throw exception;//自己主动抛出的异常
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("main......end.....");自定义异常
1) 上面的异常体系结构图都是系统自带的，系统自己处理，但是很多时候项目会出现特有问题，而这些问题并未被 Java 所描述并封装成对象，所以对于这些特有的问题可以按照封装的思想，将特有的问题进行自定义异常封装。要想创建自定义异常，需要继承 Throwable 或者他的子类 Exception。
2) 使用自定义异常类的步骤
异常类型名称望文生义，可在发生特定问题时抛出对应的异常。
常用构造方法：
无参数构造方法。
String message参数的构造方法。
public class AgeException extends RuntimeException{
public AgeException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
public AgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace){
super(message, cause, enableSuppression, writableStackTrace);
}
public AgeException(String message, Throwable cause) {
super(message, cause);
// TODO Auto-generated constructor stub
}
public AgeException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
}
}
扫一扫
301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
