目录
7.1.3:捕获错误最理想的是在编译期间,但有的错误只有在运行时才会发生
七:异常处理
7.1:异常概述与异常体系结构
7.1.1:异常定义
在Java语言中,将程序执行中发生的不正常情况称为“异常”(开发过程中的语法错误和逻辑错误不是异常)
7.1.2:分类
Error:Java虚拟机无法解决的严重问题。例如:JVM系统内部错误、资源耗尽等严重情况,一般不编写针对性的代码进行处理
Exception:其它因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理。例如:
①空指针访问
②试图读取不存在的文件
③网络连接中断
④数组角标越界
7.1.3:捕获错误最理想的是在编译期间,但有的错误只有在运行时才会发生
分类:
①编译时异常
②运行时异常
7.2:常见异常
7.2.1:运行时异常(unchecked)
--NullPointerException:空指针异常
--ArrayIndexOutOfBoundsException:数组角标越界异常
--ClassCastException:类型转换异常
--NumberFormatException:数字格式异常
--InputMismatchException:输入不匹配异常
--ArithmeticException:算数异常
7.2.2:编译时异常(Checked)
--IOException
--FileNotFoundException
--ClassNotFoundException
7.3:异常处理机制一:try-catch-finally
package com.jiayifeng.java;
import org.junit.Test;
/*
* 一:异常处理
* 1.过程一:“抛”
* 程序在正常执行的过程中,一旦出现异常,就会在异常代码处生成一个对应异常类
* 的对象,并将此对象抛出;一旦抛出对象以后,其后的代码就不再进行
* 关于异常对象的产生:
* ①系统自动生成的异常对象
* ②手动的生成一个异常对象,并抛出(throw)
*
* 2.过程二:“抓”
* 异常处理方式:
* ①try - catch - finally
* ②throws
*
* 3.try - catch - finally的使用
* try{
* //可能出现异常的代码
* }catch(异常类型1 变量名1){
* //处理异常的方式一
* }catch(异常类型2 变量名2){
* //处理异常的方式二
* }
* ....
* finally{
* //一定会执行的代码
* }
*
* 说明:
* 1.finally是可选的
* 2.使用try将可能出现异常代码包装起来,在执行过程中,一旦出现异常,就会生成一个
* 对应异常类的对象,根据此对象的类型,去catch中进行匹配
* 3.一旦try中的异常对象匹配到某一个catch时,就进入catch中进行异常的处理。一旦
* 处理完成,就跳出当前的try - catch结构(在没有写finally的情况下),继续执行其
* 后的代码
* 4.catch中的异常类型如果没有子父类关系,则谁声明在上,谁声明在下无所谓
* catch中的异常类型如果满足子父类关系,则要求子类一定声明在父类的上面。否则,
* 报错
* 5.常用的异常对象处理的方式:
* ①String getMessage()
* ②printStackTrace()
* 6.在try结构中声明的变量,出了try结构以后,就不能再被调用
* 7.try - catch - finally结构可以嵌套
*/
public class ExceptionTest1 {
@Test
public void test1() {
String string = "123";
string = "abc";
try {
int num = Integer.parseInt(string);
System.out.println("hello------1");
}catch(NumberFormatException e) {
// System.out.println("出现数值转换异常,不要着急...");
// String getMessage();
// System.out.println(e.getMessage());
// printStackTrace();
e.printStackTrace();
}
System.out.println("hello------2");
}
}
package com.jiayifeng.java;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import org.junit.Test;
/*
* 一:try - catch - finally中finally的使用
* 1.finally是可选的
* 2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了,try中有
* return语句,catch中有return语句等情况
* 3.像数据库连接、输入输出流、网络编程Socket等资源,JVM是不能自动的回收的,我们
* 需要自己手动的进行资源的释放。此时的资源释放,就需要在finally中进行
*/
public class FinallyTest {
@Test
public void test2() {
FileInputStream fileInputStream = null;
try {
File file = new File("hello.txt");
fileInputStream = new FileInputStream(file);
int data = fileInputStream.read();
while(data != -1) {
System.out.println((char)data);
data = fileInputStream.read();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(fileInputStream != null) //避免空指针异常
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void test1() {
try {
int a = 10;
int b = 0;
System.out.println(a / b);
}catch(ArithmeticException e) {
e.printStackTrace();
}catch(Exception e) {
e.printStackTrace();
}finally {
System.out.println("HelloWorld");
}
}
}
7.4:异常处理机制二:throws+异常类型
package com.jiayifeng.java;
/*
* 一:异常处理的方式二:throws + 异常类型
* 1.方式二写在方法的声明处。指明此方法执行时,可能会抛出的异常类型。
* 一旦当方法体执行时出现异常,仍会在异常代码处生成一个异常类的对象,
* 此对象满足throws异常类型时,就会被抛出。异常代码后续的代码就不再
* 执行
*
* 2.体会:
* ①try - catch - finally:真正的将异常给处理掉了
* ②throws的方式只是将异常抛给了方法的调用者,并没有
* 真正将异常处理掉
*
* 3.开发中如何选择使用try - catch - finally还是使用throws?
* 3.1:如果父类中被重写的方法没有使用throws方式处理异常,则
* 子类重写的方法也不能使用throws,意味着如果子类重写的方法中有异常,
* 必须使用try - catch - finally方式处理
* 3.2:执行的方法a中先后又调用了另外的几个方法,这几个方法是递进关系执行的。
* 我们建议使用throws方式进行处理。而执行的方法a可以考虑try - catch - finally
* 方式进行处理
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class ExceptionTest2 {
public static void main(String[] args) {
try {
method2();
}catch(IOException e) {
e.printStackTrace();
}
}
public static void method2() throws IOException{
method1();
}
// 编译异常
public static void method1() throws FileNotFoundException,IOException {
File file = new File("hello.txt");
FileInputStream fileInputStream = new FileInputStream(file);
int data = fileInputStream.read();
while(data != -1) {
System.out.println((char)data);
data = fileInputStream.read();
}
fileInputStream.close();
}
}
7.5:手动抛出异常:throw
package com.jiayifeng.java1;
public class StudentTest {
public static void main(String[] args) {
Student student = new Student();
try {
student.regist(-1001);
} catch (Exception e) {
// e.printStackTrace();
System.out.println(e.getMessage());
}
System.out.println(student);
}
}
class Student{
private int id;
public void regist(int id) throws Exception {
if(id > 0) {
this.id = id;
}else {
// System.out.println("你输入的数据非法!");
// 手动抛出异常对象
throw new MyException("不能输入负数");
}
}
@Override
public String toString() {
return "Student [id=" + id + "]";
}
}
7.6:用户自定义异常类
package com.jiayifeng.java1;
/*
* 一:如何自定义异常类?
* 1.继承于现有的异常结构:RuntimeException、Exception
* 2.提供全局变量:serialVersionUID
* 3.提供重载的构造器
*/
public class MyException extends RuntimeException{
static final long serialVersionUID = -7034897190745766939L;
public MyException(){}
public MyException(String msg) {
super(msg);
}
}
7.7:异常中的方法重写
package com.jiayifeng.java1;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.channels.NonWritableChannelException;
/*
* 方法重写的规则之一:
* 子类重写方法的异常类型要小于父类重写方法的异常类型
*/
public class OverrideTest {
public static void main(String[] args) {
OverrideTest test = new OverrideTest();
test.display(new SubClass());
}
public void display(SuperClass s) {
try {
s.method();
}catch(IOException e) {
e.printStackTrace();
}
}
}
class SuperClass{
public void method() throws IOException{
}
}
class SubClass extends SuperClass{
public void method() throws FileNotFoundException{
}
}