Java异常使用心得

异常处理是 Java 设计最引以为傲的一个地方。Java 的设计者们提供了处理编译及运行时异常的机制，这极大的增强了程序的健壮性。这里不得不提 Java 的设计哲学：没有完善异常处理的代码根本没有机会被执行。

Java 异常的体系结构

java.lang.Throwable

—|——Error：错误，程序中不进行处理

——|——Exception：异常，要求在编写程序时，就要考虑到对这些异常的处理

———|——编译时异常：在编译期间会出现的异常（执行 javac.exe 命令时，出现异常）

———|——运行时异常：在运行期间出现的异常（执行 java.exe 命令时，出现异常）

Error

/**
* @author kyyee
*
*/
public class TestError {
public static void main(String[] args) {
// java.lang.StackOverflowError
main(args);
// java.lang.OutOfMemoryError: Java heap space
// byte[] b = new byte[1024 * 1024 * 1024];
System.out.println(b);
}
}

代码 main(args)； 会出现 StackOverflowError （栈空间溢出错误）。

代码 byte[] b = new byte[1024*1024*1024]; 会出现 OutOfMemoryError （堆空间溢出错误）。

Exception

异常通常被分为两种：检查型异常（CheckedException）、运行时异常（RuntimeException）。

注意：检查型异常与编译时异常同义。

1.常见的运行时异常：

数组下标越界异常：java.lang.ArrayIndexOutOfBoundsException: -10

算数除 0 异常：java.lang.ArithmeticException: / by zero

类型转换异常：java.lang.ClassCastException: java.util.Date cannot be cast to java.lang.String

空指针异常：java.lang.NullPointerException

传递非法参数异常：java.lang.IllegalArgumentException

数字格式错误异常：java.lang.NumberFormatException

2.检查型异常：

所有的非运行时异常都是检查型异常

如何处理异常

Java 提供了基于抓抛模型的异常处理办法

1.”抛“：当我们执行代码时，一旦出现异常，就会在异常的代码处生成一个对应的异常类型的对象，并将此对象抛出

一旦抛出此异常类的对象，那么异常之后的代码立即停止执行

此异常类的对象抛给方法的调用者

Java 有两种抛出异常的方式（自动抛出/手动抛出）

2.”抓“：抓住抛出来的异常类的对象。如何抓？即为异常处理的方式

Java 提供了两种方式来处理异常类的对象

Java 处理异常类的两种方式

方式一

将可能出现异常的代码块用 try-catch-finally 结构包起来，在 catch 中提供相应的处理办法，而 finally 中是一定会被执行的代码。

try{
// 可能出现异常的代码
...
} catch(Exception1 e1){
// 处理的方式1
...
} catch(Exception2 e2){
// 处理的方式2
...
} finally {
// 一定会执行的代码
...
}

捕获IO异常

// 编译时异常
@Test
public void test6() {
FileInputStream fis = null;
try {
fis = new FileInputStream(new File("hello.txt"));
int len;
byte[] b = new byte[10];
while ((len = fis.read(b)) != -1) {
System.out.println(b);
System.out.println(len);
}
} catch (FileNotFoundException e) { // 子类异常在父类异常上被捕获
} catch (IOException e) {
} finally {
try {
if (fis != null) {
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

注意：

try{} 代码块内声明的变量类似于局部变量，出了 try{} 语句，就不能被使用

finally 是可选的

catch 语句内部是对异常对象的处理=>e.getMessage(); =>e.printStackTrace();

可以有多个 catch 语句，try 中抛出的异常类对象从上往下去匹配 catch 中的异常类的类型，一旦满足就执行 catch 中的代码。执行完跳出其后的多余 catch 语句

如果异常处理了，那么其后的代码继续执行

若 catch{} 多个异常类型是“并列”关系，孰上孰下都可以。若 catch{} 多个异常类型是“包含”关系，须将子类放在父类的上面进行处理，否则编译错误

finally 中存放的是一定会被执行的代码，不管 try 中、catch 中是否仍有异常未被处理，以及是否有 return 语句

try-catch 是可以嵌套的

对于运行时异常来说，可以不显示的进行处理。对于编译时异常来说，必须要显式的进行处理。

方式二

在方法的声明处，显式的抛出该异常对象的类型，关键字：throws。

当在此方法内部出现异常的时候，会抛出一个异常类的对象，抛给方法的调用者，异常类的对象可以逐层向上抛，直至 main 方法。

当然在向上抛的过程中，可以在方法调用者中通过 try-catch-finally 来处理抛出的异常。

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

/**
* Created by kyyee on 2017/6/8.
*/
public cla
4000
ss TestException {
public static void main(String[] args) {
TestException t = new TestException();
try {
t.TestInput();
} catch (IOException e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}

private void TestInput() throws IOException {
FileInputStream fis = new FileInputStream(new File("hello.txt"));
int b;
while ((b = fis.read()) != -1) {
System.out.println((char) b);
}
fis.close();
}
}

如何自定义一个异常类

自定义的异常类继承现有的异常类，提供一个序列号，提供几个重载的构造器。

public class MyException extends RuntimeException {
private static final long serialVersionUID = 2989193327207396613L;

public MyException() {
super();
}

public MyException(String message, Throwable cause) {
super(message, cause);
}

public MyException(String message) {
super(message);
}

public MyException(Throwable cause) {
super(cause);
}
}

如何手动抛出一个异常类

抛出的异常类型，若是RuntimeException，可以不用显式的处理，若是一个Exception，必须要显式的处理。换句话说，RuntimeException不用向外抛（throws）或不用抓（try-catch-finally）；而Exception要么向外抛（throws），要么在某一级抓（try-catch-finally）。

public class TestCricle {
/**
* @param args
*/
public static void main(String[] args) {
Cricle cricle = new Cricle(3.14);
Cricle cricle2 = new Cricle(4.24);
System.out.println(cricle.compareTo(cricle2));
System.out.println(cricle.compareTo(2));
}
}

final class Cricle {
private double radius = 0D;

public Cricle() {
super();
}

public Cricle(double radius) {
super();
this.radius = radius;
}

public double getRadius() {
return radius;
}

public void setRadius(double radius) {
this.radius = radius;
}

@Override
public String toString() {
return "Cricle [radius=" + radius + "]";
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
long temp;
temp = Double.doubleToLongBits(radius);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Cricle other = (Cricle) obj;
if (Double.doubleToLongBits(radius) != Double
.doubleToLongBits(other.radius))
return false;
return true;
}

public int compareTo(Object obj) {
if (this == obj) {
return 0;
} else if (obj instanceof Cricle) {
Cricle c = (Cricle) obj;
if (c.radius < this.radius) {
return -1;
} else if (c.radius == this.radius) {
return 0;
} else {
return 1;
}
} else {
throw new MyException("传入类型与Circle类型不匹配");
}
}
}

重写方法含有 throw Exception

重写方法不能抛出父类中没有的检查型异常

重写方法不能抛出父类抛出异常的父异常，如父类中的方法抛出FileNotFoundException，则该重写方法不能抛出IOException

public class TestOverride {
public static void main(String[] args) {
A a = new B();
try {
a.method1();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

B b = new B();
try {
b.method1();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

class A {
public void method1() throws IOException {
System.out.println("我是父类");
}
}

class B extends A {
/*
* (non-Javadoc)
*
* @see com.nantian.exception.A#method1()
*/
@Override
public void method1() throws FileNotFoundException {
System.out.println("我是子类");
}
}

结语

java的异常处理：抓抛模型

抓：异常的处理，有两种方式（1.try-catch-finally，2.throws）

抛：一旦执行过程中出现异常，会抛出一个异常类的对象（自动抛出 vs 手动抛出 throw new 异常类对象），既可以是系统现有的异常类，也可以是自己创建的异常类

总结： Java 异常处理有 5 个关键字：try , catch , finally , throws , throw。自定义异常继承自 Exception，如果不处理异常，则编译不通过，也就是说继承自 Exception 的异常是检查型异常；自定义异常继承自RuntimeException，可以不处理异常，可编译通过，也就是说继承自 RuntimeException 的异常是运行时异常。