|
异常主要分为Error和Exception，其中Error是Java虚拟机也解决不了的问题，一般不写针对性代码处理。
Error笔记：
package exception;
/*
* Error：
* Java虚拟机JVM也解决不了的问题
* 如栈溢出
* 一般不编写针对性的代码处理
*/
public class ErrorTest {
public static void main(String[] args) {
//1.栈溢出 java.lang.StackOverflowError
// main(args);
//2.堆溢出 java.lang.OutOfMemoryError
// Integer[] arr=new Integer[1024*1024*1024];
}
}
异常的体系结构：
package exception;
import java.sql.Date;
import java.util.Scanner;
import org.junit.Test;
/*
* 一、异常的体系结构
*java.lang.Throwable
* ①java.lang.Error:一般不编写针对性代码处理
* ②java.lang.Exception:可以进行异常处理
* 编译时异常：（checked）
* IOException
* FileNotFoundException
* ClassNotFoundException
* 运行时异常：（unchecked）
* NullPointerException
* ArrayIndexOutOfBoundsException
* ClassCastException
* NumberFormatException
* InputMismatchException
* ArithmeticException
*/
public class ExceptionTest {
/*******************以下是编译时异常***********************/
@Test
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();
}
/*******************以下是运行时异常***********************/
@Test
//ArithmeticException
public void test6() {
int a=6;
int b=0;
System.out.println(a/b);
}
@Test
//InputMismatchException
public void test5() {
Scanner scan=new Scanner(System.in);
int score = scan.nextInt();
System.out.println(score);
}
//NumberFormatException
public void test4() {
// String str="abc";
// int num=Integer.parseInt(str);
}
//ClassCastException
@Test
public void test3() {
Object obj=new Date(0);
String str=(String)obj;
}
//ArrayIndexOutOfBoundsException
@Test
public void test2() {
// int[] arr=new int[10];
// System.out.println(arr[10]);
//StringIndexOutOfBoundsException
// String str="abc";
// System.out.println(str.charAt(3));
}
//NullPointerException
@Test
public void test1() {
// int[] arr=null;
// System.out.println(arr[3]);
// String str="abc";
// str=null;
// System.out.println(str.charAt(0));
}
}
异常的处理 ：主要有两种形式，一种是try-catch-finally型，另一类是throws型。
笔记：
package exception;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import org.junit.Test;
/*
* 异常的处理：抓抛模型
* 过程一："抛"：程序在正常执行过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。
* 并将此对象抛出，一旦抛出对象以后，其后的代码就不再执行。
*
* 关于异常对象的产生：①系统自动生成的异常对象
* ②手动生成一个异常，并抛出（throw）
*
* 过程二："抓"：异常的处理方式：①try-catch-finally
* ②throws
* 二、try-catch-finally的使用
* try{
* //可能出现异常的代码
* }catch(异常类型1 变量名1){
* //处理异常的方式1
* }catch(异常类型2 变量名2){
* //处理异常的方式2
* }catch(异常类型3 变量名3){
* //处理异常的方式3
* }
* ...
* finally{
* 一定会执行的代码
* }
* 说明
* 1.finally是可选的
* 2.使用try将可能出现异常的代码包装起来，执行过程中一旦出现异常，就生成一个对应异常类的对象，根据此对象的类型
* 去catch中去匹配。
* 3.一旦try中的异常类型匹配到某一个catch时就进入到catch中进行异常处理。一旦处理完成，跳出try-catch结构（没有写finally）
* 继续执行后面的代码
* 4.catch中的异常类型如果没有子父类关系，谁先声明都没关系，如果有子父类关系，要求子类声明在前，父类声名在后否则报错
* 5.常用异常对象处理的方式：①String e.getMessage ②void e.printStackTrace()
* 6.在try结构中定义的变量，出了try结构就不可以再使用。
* 7.try-catch-finally结构可以嵌套。
*
*
* note1:使用try-catch-finally处理编译时异常时，使得程序编译时不再报错，但运行时仍可能报错
* 相当于使用try-catch-finally结构将编译时的异常延迟到运行时出现。
* note2:开发中由于运行时异常比较常见，通常不针对运行时异常编写try-catch-finally结构
* 针对编译时异常，一定要考虑异常处理。
*/
public class ExceptionTest1 {
@Test
public void test2() {
try {
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();}catch(FileNotFoundException e) {
e.getStackTrace();
}catch(IOException e) {
e.getStackTrace();
}
}
@Test
public void test1() {
String str="abc";
try {
int num=Integer.parseInt(str);
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 exception;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import org.junit.Test;
/*
* 异常处理的方式二：throws+异常类型
* 1."throws+异常类型"写在方法的声明处，指明此方法执行时可能会抛出的异常类型
* 一旦方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后面的异常时
* 就会被抛出，异常代码后面的代码不再被执行。
* 2.note：try-catch-finally真正将异常处理掉了 。
* throws的方式只是将异常抛给了方法的调用者。并没有将异常处理掉 。
* 3.开发中如何选择使用try-catch-finally还是throws：
* ①如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果
* 子类中有异常必须使用try-catch-finally方式处理异常。
* ②执行的方法a中先后又调用了另外的几个方法，这几个方法还是递进的关系的，建议这几个方法用throws处理
* 执行的方法a利用try-catch-finally处理
*/
public class ExceptionTest2 {
public static void main(String[] args) {
}
public static void method3() {
}
public static void method2() throws IOException{
method1();
}
public static void method1() 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();
}
}
package exception;
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 fis=null;
try {
File file = new File("hello.txt");
fis = new FileInputStream(file);
int data = fis.read();
while (data != -1) {
System.out.print((char) data);
data = fis.read();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(fis!=null)
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void methodTest() {
int num = method();
System.out.println(num);
}
public int method() {
try {
int[] arr = new int[10];
System.out.println(arr[10]);
return 1;
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
return 2;
} finally {
System.out.println("我一定会被执行");
}
}
@Test
public void test1() {
try {
int a = 10;
int b = 0;
System.out.println(a / b);
} catch (ArithmeticException e) {
// e.printStackTrace();
int[] arr = new int[10];
System.out.println(arr[10]);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("这是finally内的代码");
}
}
}
自定义异常类：三步走
package exception;
/*
*
* 自定义异常类：
* 1.继承于现有的异常结构：RuntimeException、Exception
* 2.提供全局常量：serialVersionUID
* 3.提供重载的构造器
*/
public class MyException extends RuntimeException {
static final long serialVersionUID = -7034897190745764539L;
// 构造器
public MyException() {
}
public MyException(String msg) {
super(msg);
}
}
package exception;
public class StudentTest {
public static void main(String[] args) {
Student s = new Student();
s.regist(-1001);
System.out.println(s.toString());
}
}
class Student{
private int id;
public void regist(int id)
{
if(id>0)
{
this.id=id;
}else {
// System.out.println("您输入的数据非法！");
//手动抛出异常对象
// throw new RuntimeException("您输入的数据非法！");
throw new MyException("不能输入负数");
//错误的
// throw new String("不能输入负数");
}
}
@Override
public String toString() {
return "Student [id=" + id + "]";
}
}
方法的重写：子类抛出的异常类型不大于父类被重写的方法抛出的异常
package exception;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
* 方法重写的规则之一：
* 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
*/
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{
}
}
|