1. 异常概述与异常体系结构
Error: 栈溢出与堆溢出
public static void main(String[] args) {
//栈溢出 java.lang.StackOverflowError
main(args);
//堆溢出 java.lang.OutOfMemoryError
Integer[] arr = new Integer[1024*1024*1024];
}
Exception:
2. 常见异常
package org.example;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Date;
import java.util.Scanner;
/**
* 一、异常的体系结构
* java.lang.Throwable
* ---> java.lang.Error:一般不编写针对性的代码处理
* ---> java.lang.Exception: 可以进行异常处理
* -------> 编译时异常（checked) 如：IOException FileNotFoundException ClassNotFoundException
* -------> 运行时异常（uncheked)如：NullPointerException ArrayIndexOutOfBoundsException ClassCastException
* NumberFormatException InputMismatchException ArithmeticException
*/
public class ExceptionTest {
@Test //NullPointerException
public void test1() {
int[] arr = null;
System.out.println(arr[3]);
}
@Test //ArrayIndexOutOfBoundsException
public void test2() {
int[] arr = new int[10];
System.out.println(arr[10]);
}
@Test //ClassCastException
public void test3() {
Object obj = new Date();
String s = (String) obj;
}
@Test //NumberFormatException
public void test4() {
String str = "abc";
int num = Integer.parseInt(str);
}
@Test //InputMismatchException
public void test5() {
Scanner scanner = new Scanner(System.in);
System.out.println("input a integer:");
int score = scanner.nextInt();
System.out.println(score);
scanner.close();
}
@Test //ArithmeticException
public void test6() {
int a = 5;
int b = 0;
System.out.println(a / b);
}
//******以下是编译时异常******
@Test //FileNotFoundException
public void test7() {
File file = new File("hello.txt");
FileInputStream fis = new FileInputStream(file);
int data = fis.read();
while (data != -1){
System.out.print((char) data);
data = fis.read();
}
fis.close();
}
}
3. 异常处理机制一：try-catch-finally
package org.example;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 一、异常处理：抓抛模型
* 过程一： “抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码出生成一个对应的异常类的对象，并将此对象抛出。
* 一旦抛出对象，其后的代码就不再执行。
* <p>
* 过程二： “抓”：可以理解成异常处理的方式：1.try-catch-finally, 2.throws
* <p>
* 二、try-catch-finally的使用
* try{
* //可能出现异常的代码
* }catch(异常类型1 变量名1){
* //处理异常的方式1
* }catch(异常类型2 变量名2){
* //处理异常的方式2
* }catch(异常类型3 变量名3){
* //处理异常的方式3
* }
* ……
* finally{
* //一定会执行的代码
* }
* <p>
* 说明：
* 1.finally是可选的
* 2.使用try将可能出现异常的代码包装起来，在执行过程中，就会生成一个对应异常类的对象，
* 根据此对象的类性，去catch中进行匹配
* 3. 一旦try中的异常对象匹配到某一个catch时，就会进入catch中进行异常处理。一旦处理完成，
* 就会跳出当前的try-catch结构（在没有写finally的情况下）。继续执行其后的代码
* 4. catch中的异常类型如果没有子父类关系，那些位置无所谓，如果满足子父类关系，那么子类要在父类前，否则报错。
* 5. 常用的异常处理方式：1) getMessage() 2) printStactTrace()
* 6.在try结构中声明的变量，出路try结构以后，就不能再被调用了。
* 7.使用try-catch-finally处理编译时异常，使得程序再编译时就不在报错，但是运行时仍可能报错。
* 相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
* 8.try-catch-finally 结构可以相互嵌套
* 9. 开发中，由于运行时异常比较常见， 我们就不对运行时异常进行try-catch-finally处理了
* 针对编译时异常是一定要处理的。
*/
public class ExceptionTest1 {
@Test
public void test1() {
String str = "abc";
int num = 0;
try {
num = Integer.parseInt(str);
System.out.println("1");//不会执行
} catch (NumberFormatException e) {
System.out.println("出现数值转换异常");
//捕获到该异常就会直接跳出try-catch结构
System.out.println(e.getMessage());
e.printStackTrace();
} catch (Exception e) {
System.out.println("出现异常了");
}
System.out.println("2");//会执行
}
@Test
public void test2() {
File file = new File("hello.txt");
try {
FileInputStream fis = new FileInputStream(file);
int data = fis.read();
while (data != -1) {
System.out.print((char) data);
data = fis.read();
}
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
finally的使用
package org.example;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/**
* try-catch-finally
* 1. finally是可选的
* 2. finally中声明的是一定会被执行的代码。即使catch中又出现了异常,或者try中有return语句，catch中有return语句等情况。
* 3. 像数据库连接，输入输出流，网络编程中的socket等资源，JVM是不能自动回收的，我们需要自己手动的进行资源释放，
* 此时的资源释放语句，就要再finally中声明。
*/
public class FinallyTest {
@Test
public void test1() {
try {
int a = 10;
int b = 0;
System.out.println(a / b);
} catch (ArithmeticException e) {
e.printStackTrace();
} finally {
System.out.println("运行结束");
}
}
public int method1() {
try {
int[] arr = new int[10];
System.out.println(arr[10]);
return 1;
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
return 2;
} finally {
System.out.println("我一定会被执行");
return 3;//先执行
}
}
@Test
public void test2() {
File file = new File("hello.txt");
FileInputStream fis = null;
try {
fis = new FileInputStream(file);
int data = fis.read();
while (data != -1) {
System.out.print((char) data);
data = fis.read();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fis != null){
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4. 异常处理机制二：throws
package org.example;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 异常处理的方式二：throws+异常类型
* 1. "throws + 异常类型“ 写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。
* 一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，
* 此对象满足throws后异常类型时，就会被抛出，异常代码后面的代码就不会执行了
* <p>
* 2. 体会：try-catch-finally是真正的将异常处理掉了。
* throws的方式只是将异常抛给了方法的调用者，并没有真正的将异常处理掉。
* 3. 开发中如何选择try-catch-finally,还是throws?
* 3.1 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法不能使用throws,子类如果有，只能使用try-catch-finally
* 3.2 执行的方法中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws处理，而执行的方法中使用try-catch-finally的方式进行处理。
*/
public class ExceptionTest2 {
@Test
public void test7() throws FileNotFoundException, IOException {
File file = new File("hello.txt");
FileInputStream fis = new FileInputStream(file);
int data = fis.read();
while (data != -1) {
System.out.print((char) data);
data = fis.read();
}
fis.close();
}
public void method2() throws IOException {
test7();
}
}
重写中的异常问题
package org.example;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 方法重写的规则之一：子类重写的方法异常类型不大于父类被重写方法的异常类型
*/
public class OverrideTest {
public static void main(String[] args) {
OverrideTest o = new OverrideTest();
o.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 {
@Override
public void method() throws FileNotFoundException {
}
}
5. 手动抛出异常：throw
package org.example;
/**
* 异常方式的产生：
* 1. 系统自动生成的异常对象（如上）
* 2. 手动的生成一个异常对象，并抛出（throw）
*/
public class ExceptionTest3 {
public static void main(String[] args) {
Student s = new Student();
try {
s.regist(-1001);
} 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("输入数据非法");
}
}
}
6. 用户自定义异常类
package org.example;
/**
* 如何自定义异常类？
* 1. 继承现有的异常类，如：RuntimeException,Exception
* 2. 提供全局常量 serialVersionUID
* 3. 提供重载的构造器
*
*/
public class MyException extends RuntimeException {
static final long serialVersionUID = -7034897190745766939L;
public MyException() {
}
public MyException(String message) {
super(message);
}
}
总结
104
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
