异常
一、异常概述与异常体系结构
- Java程序在执行过程中所发生的异常事件可分为两类:
- Error:Java虚拟机无法解决的严重问题。
- Exception:其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如:
- 空指针访问
- 试图读取不存在的文件
- 网络连接中断
- 数组角标越界
一、异常体系结构
java.lang.Throwable
|--java.lang.Error:一般不编写针对性的代码进行处理
|--java.lang.Exception:可以进行异常的处理
|--编译时异常（checked）
|--IOExecption
|--FileNotFoundException
|--ClassNotFoundException
|--运行时异常（unchecked）
|--NullPointerException
|--ArrayIndexOutOfBoundsException
|--ClassCastException
二、异常的处理
异常的处理：抓抛模型
过程一：“抛”，程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。
并将此对象抛出
一旦抛出对象以后，其后的代码就不会执行
关于异常对象的产生：1. 系统自动生成的异常对象
2. 手动的生成一个异常对象，并抛出（throw）
过程二：“抓”，可以理解为异常的处理：
1.try-catch-finally
2.throws
2.1、try catch finally
异常处理的方式一：
try{
//可能出现异常的代码
}catch(异常类型1 变量名1){
//处理异常的方式1
}catch(异常类型2 变量名2){
//处理异常的方式2
}finally{
//一定会执行的代码，finally可选的
}
@Test
public void test3(){
String str = "abc";
try {
int num = Integer.parseInt(str);
System.out.println("hello---------1");
} catch (NumberFormatException e) {
System.out.println("数值出现异常，已经处理完成");
} finally {
System.out.println("finally一定会执行，finally是可选的");
}
System.out.println("hello------------2");
}
说明：
try-catch
1.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配
2.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理，一旦处理完成，就跳出当前的try-catch结构。继续执行其后的代码
3.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
4.catch中的异常类型如果满足子父类关系，【则要求子类一定声明在父类的上面。否则，报错】
5.常用的异常对象处理的方式：
1) String getMessage() //打印错误信息
System.out.println(e.getMessage());
2) PrintStackTrace() //会在控制台报红色 当前错误
e.PrintStackTrace();
6.在try结构中声明的变量，出了try结构以后，就不能再被调用
7.try-catch-finally 可以进行嵌套
/********************************************************/
finally
1.finally 是可选的。
2.finally 中声明的是一定会被执行的代码。即时catch中又出现异常了，try中有return 语句，catch中有return语句等情况
3.像数据库连接，输入输出流、网络编程Socket等资源。JVM是不能自动的回收的，我们需要自己手动的进行资源的释放，此时的资源释放，就需要声明在finally中。
@Test
public void test2(){
File file = new File("hello.text");
FileInputStream fis = null;
try {
fis = new FileInputStream(file);
int read = fis.read();
while(read != -1){
System.out.println((char)read);
read = fis.read();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fis != null){
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/*********************************************************/
体会一：使用try-catch-finally处理编译时异常，使得程序在编译时就不在报错，但是运行时扔可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现
体会二：开发中，由于运行时异常出现之后我们会进行代码的修改，通常就不针对运行时异常编写try-catch-finally了，只针对于编译时异常。
2.2、throws
异常处理的方式二：throws + 异常类型
public static void main(String[] args){
try{
method2();
}catch(FileNotFoundException e){
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}
}
public static void method2() throws FileNotFoundException,IOException{
method1();
}
public static void method1() throws FileNotFoundException,IOException{
File file = new File("hello.text");
FileInputStream fis = new FileInputStream(file);
int read = fis.read();
while(read != -1){
System.out.println((char)read);
read = fis.read();
}
fis.close();
}
1."throws + 异常类型" 写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws异常类型时，就会抛出。异常代码后续的代码，就不会再执行
2.体会：try-catch-finally：真正的将异常给处理掉了，
throws 的方式只能是将异常抛给方法的调用者。并没有真正将异常处理掉
3.方法的重写规则之一：
子类重写的方法抛出的异常类型不大于父类重写的方法抛出的异常类型
public class ExceptionOverride {
public static void main(String[] args) {
ExceptionOverride over = new ExceptionOverride();
over.display(new SuberClass());
/*
这里出现了多态，SuperClass s = new SubClass();
你想本来父类中已经解决了异常，这是父类的对象引用了子类（多态），
子类的异常大于父类的异常，是不是出现了矛盾
*/
}
public void display(SuperClass s){
try {
s.method();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class SuperClass{
public void method() throws IOException {}
}
class SuberClass extends SuperClass{
public void method() throws IOException {}
}
开发中如何选择使用 try-catch-finally 或 throws
-
如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须使用try-catch-finally 方式进行处理
-
执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用 try-catch-finally 方式进行处理。
2.3、手动抛出异常 throw
代码体现一：
public class ExceptionTest {
public static void main(String[] args) {
Student s1 = new Student();
s1.regist(-1002);
}
}
class Student{
private int id;
public void regist(int id){
if(id > 0){
this.id = id;
}else{
throw new RuntimeException("你输入的数据非法"); //运行时异常
}
}
}
代码体现二：
public class ExceptionTest {
public static void main(String[] args) {
Student s1 = new Student();
try {
s1.regist(-1002);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
class Student{
private int id;
public void regist(int id)throws Exception{
if(id > 0){
this.id = id;
}else{
throw new Exception("你输入的数据非法");
}
}
}
2.4、用户自定义异常
如何自定义异常类？
1.继承于现有的异常结构：RuntimeException 、 Exception
2.提供全局常量：serialVersionUID
3.提供重载的构造器
//MyException.java
public class MyException extends RuntimeException {
static final long serialVersionUID = -7034897190746939L; //类的表示
public MyException(){}
public MyException(String msg){
super(msg); //指向父类的构造器 RuntimeException(String msg)
}
}
//ExceptionTest.java
public class ExceptionTest {
public static void main(String[] args) {
Student s1 = new Student();
s1.regist(-2001);
}
}
class Student{
private int id;
public void regist(int id){
if(id > 0){
this.id = id;
}else{
throw new MyException("不能为负数");
}
}
}
浙公网安备 33010602011771号