Java基础--异常处理

1.异常的概念

Java的异常指的是运行期出现的错误，观察错误的名字和行号最重要

Java异常是Java提供的用于处理程序中错误的一种机制。

所谓错误是指在程序运行的过程中发生的一些异常事件（如：除以0溢出，数组下标越界，所要读取的文件不存在）。

设计良好的程序应该在异常发生时提供处理这些错误的方法，使得程序不会因为异常的发生而阻断或产生不可预见的结果。

Java程序的执行过程中如出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息并将被提交给Java运行时系统，这个过程叫做抛出异常。

当Java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获异常。

public void someMethod() {
throws SomeException {//声明该方法可能抛出的异常
if(someCondition()) {
throw new SomeException("错误原因"); //构造并抛出异常对象
}
}
}
try{                                                  //调用该方法是试图捕捉异常
someMethod();
}catch(SomeExceptione){                //定义处理异常的代码
//异常处理代码；
}

捕获异常：

public static void main(String[] array) {
try {
System.out.println(2 / 0);
} catch (ArithmeticException a) {
System.out.println("系统正在维护，请稍候……");
a.printStackTrace();
}
}

结果是：

系统正在维护，请稍候……

java.lang.ArithmeticException: / by zero

 at Test1.Test.main(Test.java:7)

2.异常的分类



throwable：可被抛出的

error：系统的错误，处理不了的

exception：能够处理的错误

runtimeException：经常出的错误，可以捕获也可以不捕获

其他类Exception：必须要捕获



RuntimeException异常：

void m(int i) throws ArithmeticException {
if(i==0)
throw newArithmeticException("被除数为0");
}                                       //声明m方法
Test te = new Test();
te.m(0);}

第一种没有捕获错误，程序也可以执行

结果是：

Exception in thread "main"java.lang.ArithmeticException:被除数为0

 at Test1.Test.m(Test.java:67)

 at Test1.Test.main(Test.java:25)

第二种捕获错误：

try {
newTest().m(0);
} catch (ArithmeticExceptionae) {
ae.printStackTrace();
System.out.println("出错了");
}
}

结果是：

出错了

java.lang.ArithmeticException: 被除数为0

 at Test1.Test.m(Test.java:67)

 at Test1.Test.main(Test.java:29)
Exception的其他错误：

FileInputStream in = null;
try{
in=new FileInputStream("myfile.txt");
int b;
b=in.read();
while(b!=-1){
System.out.print((char)b);
b=in.read();
}
}catch(FileNotFoundException e){
e.printStackTrace();
}
catch(IOException e){
System.out.println(e.getMessage());
}

结果是：

java.io.FileNotFoundException: myfile.txt (系统找不到指定的文件。)

 at java.io.FileInputStream.open(NativeMethod)

 at java.io.FileInputStream.(Unknown Source)

 at java.io.FileInputStream.(Unknown Source)

 at Test1.Test.main(Test.java:41)

Exception in thread "main" java.lang.NullPointerException

 at Test1.Test.main(Test.java:58)
3.finally语句

try代码段包含可能产生异常的代码，后跟有一个或多个catch代码段。每个catch代码段声明其能处理的一种特定类型的异常并提供处理方法，当异常发生时程序会终止当前的流程，根据获取的异常的类型去执行相应的catch代码段。

finally段的代码无论try中的代码是否发生异常都有执行，有异常时运行catch后在执行finally中的语句

try{                                    //可能抛出异常的语句

}catch(SomeException1 e){

……

}catch(SomeException2 e){

……

}finally{

……

}



在catch语句块中可以使用e这个对象的一些方法获取异常事件发生的信息。

如：getMessage()方法，用来得到有关异常事件的信息

printStackTrace()方法，用来跟踪异常事件发生时执行堆栈的内容

finally语句：

finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序的其他部分以前，能够对程序的状态作统一的管理。

无论try所指定的程序块中是否会抛出例外，finally所指定的代码都要被执行

通常在finally语句中可以进行资源的清除工作，如：关闭打开文件，删除临时文件

finally {

    try {

      in.close();

     } catch (IOException e) {

      e.printStackTrace();

     }

    }

4.声明方法抛出的异常

一些方法处理不了一些Exception，可以抛出，给其他方法处理

public class Test {
public static void main(String[] args) {
try {
new Test().f2();
} catch (IOException e) {
e.printStackTrace();
}
}

void f() throws FileNotFoundException, IOException {
FileInputStream in = new FileInputStream("myfile.txt");
int b;
b = in.read();
while (b != -1) {
System.out.print((char) b);
b = in.read();
}
}

void f2() throws IOException {                               //处理f中的异常
f();
4000
//运行这种情况，调用f2时，给f来处理
}
}

结果为：java.io.FileNotFoundException: myfile.txt(系统找不到指定的文件。)

 atjava.io.FileInputStream.open(NativeMethod)

 at java.io.FileInputStream.(Unknown Source)

 at java.io.FileInputStream.(Unknown Source)

 at Test1.Test.f(Test.java:12)

 at Test1.Test.f2(Test.java:30)

 at Test1.Test.main(Test.java:6)

运行是结果是：myfile.txt (系统找不到指定的文件。)

另一个例子：

public class Test {
public static void main(String[] args) {
Test test = new Test();
try {
test.method1();
} catch (Exception e) {
e.printStackTrace();
}
}

public void method1() throws Exception {
method2();
}

public void method2() throws Exception {
method3();
}

public void method3() throws Exception {
throw new Exception("SomeException occur inmethod3");
}
}

结果是：

java.lang.Exception: SomeException occur inmethod3

 at Test1.Test.method3(Test.java:21)

 at Test1.Test.method2(Test.java:18)

 at Test1.Test.method1(Test.java:15)

 at Test1.Test.main(Test.java:8)
5.一些其他问题

在try后面catch不能先大后小，不能先IoException，后FileNotFoundException，因FileNotFoundException包括在IoException中。

使用自定义的异常：

class 异常类名 extendsException

{

    public异常类名(String msg)

    {

       super(msg);

    }

}

1.通过继承java.lang.Exception类声明自己的异常类

2.在方法适当的位置生成自定义异常的实例，并用throw语句抛出

3.在方法的声明部分用throws语句声明该方法可能抛出的异常

public class MyException extends Exception {
private int id;

public MyException(String message, int id) {
super(message);
this.id = id;
}

public int getId() {
return id;
}
}

public class Test {
public void regist(int num) throws MyException {
if (num < 0) {
throw new MyException("人数为负值，不合理", 3);
}
System.out.println("登记人数" + num);
}

public void manager() {
try {
regist(-1);
} catch (MyException e) {
System.out.println("登记失败，出错类型码=" + e.getId());
e.printStackTrace();                                  //输出的第一行包含该对象的tostring()方法的结果。
}
System.out.println("操作结束");
}

public static void main(String[] args) {
Test t = new Test();
t.manager();
}
}

结果为：登记失败，出错类型码=3

Test1.MyException: 人数为负值，不合理

 at Test1.Test.regist(Test.java:16)

 at Test1.Test.manager(Test.java:22)

 at Test1.Test.main(Test.java:31)

操作结束

 

声明并抛出异常

重写方法需要抛出与原方法所抛出异常类型一致异常或不抛出异常

class A{
public void method() throws IOException{……}
//B1的继承就不对，必须要和原方法一致，既不能大，也不能小
class B1 exrends A{public void method() throwsFileNotFoundException{……}}
}

class B2 extends A{public void method(){……}}这是可以的