异常的处理方法

在java中异常的处理方法有三种分别为：try-catch-finally语句处理、throws抛出异常和throw手动抛出异常

try-catch-finally

                                 

1、try块：try语句指定了一段代码，该段代码就是一次捕获并处理的范围。在执行过程中，当任意一条语句产生异常时，就会跳过该段中后面的代码。代码中可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对这些异常做相应的处理 ，需要注意的而是：一个try语句必须带有至少一个catch语句块或一个finally语句块 （可以没有finally语句，但是没有catch语句的话，后面只有finally有时候会报错）；在try里面定义的都是局部变量，也就是说只能在try语句里面使用而try语句之外的不能使用

2、catch块：每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
常用方法：
          toString ( )方法，显示异常的类名和产生异常的原因
          getMessage( ) 方法，只显示产生异常的原因，但不显示类名。
          printStackTrace( ) 方法，用来跟踪异常事件发生时堆栈的内容。
这些方法均继承自Throwable类Catch捕获异常时的捕获顺序： 如果异常类之间有继承关系，在顺序安排上需注意。越是顶层的类，越放在下面。再不然就直接把多余的catch省略掉。

3、finally块：有些语句，不管是否发生了异常，都必须要执行，那么就可以把这样的语句放到finally语句块中。通常在finally中关闭程序块已打开的资源，比如：文件流、释放数据库连接等。

实例：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;


public class Testryandcatch {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
            reader = new FileReader("d:/安装包/a.txt");
            char c = (char)reader.read();
            char c2 = (char)reader.read();
            System.out.println(" "+c+c2);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch(IOException e){    //注意这个地方的异常不能和上一个catch语句对调，因为FileNotFoundException
                                  //是IOException的子类，一旦换了之后，处理到IOException就同样会认为已经执
                                  //行了异常，所以不会继续往下执行FileNotFoundException。
            e.printStackTrace(); 
        }finally{
            try {
                if(reader!=null){
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

try, catch,finally ,return 执行顺序

执行顺序：
      1、执行try，catch ， 给返回值赋值
      2、执行finally
      3、return
实例：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestException {
    public static void main(String[] args) {
        String str = new TestException().openFile();
        System.out.println(str);
    }

    String openFile() {
        try {
            System.out.println("aaa");
            FileInputStream fis = new FileInputStream("d:/a.txt");
            int a = fis.read();
            System.out.println("bbb");
            return "step1";
        } catch (FileNotFoundException e) {
            System.out.println("catching !!!!!");
            e.printStackTrace();
            return "step2";// 先确定返回值，并不会直接结束运行。只有在finally执行完之后才会把返回值返回
        } catch (IOException e) {
            e.printStackTrace();
            return "step3";
        } finally {
            System.out.println("finally !!!!!");
            // return "fff";不要在finally中使用return. //因为这里返回值会把上面的覆盖掉
        }
    }

异常的处理办法之二，声明异常：throws子句

当Checked Exception产生时，不一定立刻处理它，可以再把异常Throws出去。

• 在方法中使用try-chatch-finally由这个方法处理异常。在一些情况下，当前方法并不需要处理发生的异常，而是向上传递给调用它的方法处理。
• 如果一个方法中可能产生某种异常，但是并不能确定如何处理这种异常，则应根据异常规范在方法的首部声明该方法可能抛出的异常。
• 如果一个方法抛出多个已检查异常，就必须在方法的首部列出所有的异常，之间以逗号隔开。

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileTest {
    public static void main(String[] args) {
        try{
            readFile("d:/a.txt");   //这里也就是谁调它谁就处理异常，也可以继续往上抛给JVM
        }catch (FileNotFoundException e){
            System.out.println("所需要的文件不存在！");
            e.printStackTrace();
        }catch (IOException e) {
            System.out.println("文件读写出错误！");
            e.printStackTrace();
        }
    }

    public static void readFile(String fileName) throws IOException {
        FileReader in = new FileReader(fileName);
        try {
            int tem = 0;
            tem = in.read();
            while (tem != -1) {
                System.out.println((char) tem);
                tem = in.read();
            }
        } finally {
            in.close();
        }
    }
}

方法重写中声明异常原则
子类声明的异常范围不能超过父类声明的范围。包含如下意思：

• 父类没有声明异常，子类也不能；
• 不可抛出原有方法抛出异常类的父类或上层类
• 抛出的异常类型的数目不可以比原有的方法抛出的还多（不是指个数）

import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.ParseException;

public class TestException1 {
    public static void main(String[] args) {
    }
}

class A {
    public void method() throws IOException, ParseException {
    }
}

class B extends A {
    public void method() throws FileNotFoundException {
    }
}

class C extends A {
    public void method() {
    }
}

class D extends A {
    public void method() throws IOException {  //报错：因为子类异常超出父类异常范围
    }
}

class E extends A {

    public void method() throws IOException, FileNotFoundException { 
    }
}

class F extends A {
    //下面这个不会报错，因为FileNotFoundException是RuntimeException的子类，也就是不可查异常，所以不会报错
    public void method() throws IOException, ArithmeticException {
    }
}

class G extends A {
    //会报错，因为ParseException和IOException是同等级的，都是继承Exception
    public void method() throws IOException, ParseException {  
    }
}

异常的处理办法之三，手动抛出异常，throw子句

java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要手工创建并抛出。在捕获一个异常前，必须有一段代码先生成异常对象并把它抛出。这个过程我们可以手工做，也可以由JRE来实现，但是他们调用的都是throw子句。
对于一个已经存在的异常类，抛出该类异常对象过程如下：

• 找到一个合适的异常类。
• 创建一个该类的对象。
• 将对象抛出

File f = new File("c:/tt.txt");
if (!f.exists())  {
    try {
        throw new FileNotFoundException("File can't be found!");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
}