java中的异常

Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。

Throwable的两个子类Error和Exception 

异常：

1.编译时不被检测异常：Error和RuntimeException

这种异常一旦出现，无法继续功能，一般不做处理，产生的原因一般是调用者导致的

（编译可以通过，运行时产生异常）

刚开始没有异常这个类的时候，异常需要自己去解决，自己去做判断

public class Demo {
    public int method(int arr[],int index){
        if (arr == null){
          System.out.println("空指针");
            return -1;
        }
        if (index>=arr.length){
         System.out.println("数组下标越界");
            return -2;
        }
        if (index<0){
          System.out.println("下标越界");
            return -3;
        }
        return arr[index];
    }

出现RuntimeException类型的一些异常(子类)的时候，如果在函数体内throw（返回）出该异常,函数名上可以不声明，编译可通过。即使是在函数名上声明了该异常，调用者可以不进行处理，编译也可以通过。之所以不在函数上声明，是不希望调用者处理，因为处理不了，只有把程序停掉，对代码进行修正。

public class Demo {
    public int method(int arr[],int index){
            if (arr == null){
                throw new NullPointerException("数组为NULL");               
            }
            if (index>=arr.length){
                throw new ArrayIndexOutOfBoundsException("数组下标越界！！");
                 }
        if (index<0){
            throw new FuShuIndex("下标是负数了");
                 }
        return arr[index];
    }
    //自己定义的异常，继承RuntimeException，也可以加入异常体系
    class FuShuIndex extends RuntimeException{
        public FuShuIndex() {
        }
        public FuShuIndex(String s) {
            super(s);
        }
    }

public static void main(String[] args) {
        Demo d = new Demo();
        int a[] = new int[5];

        System.out.println( d.method(a,-1));
        System.out.println(d.method(a, 5));
    }
}

有些异常在RuntimeException的子类中没有，需要自己定义，先继承RuntimeException类，然后再定义空的构造函数，然后再定义一个带有字符串参数的构造函数， 用指定的详细消息构造一个新的运行时异常。

2.编译时被检测异常：Exception下所有的子类，除了特殊的RuntimeException;

这种异常的出现，在编译时就被检测到，这种异常有针对性的处理方式（编译时无法通过）

public class Demo1 {
    public int method(int arr[],int index)throws FuShuIndex{ //声明异常
        if (index<0){
            throw new FuShuIndex("下标是负数了");
        }
        return arr[index];
    }
    //自己定义的异常，继承Exception，也可以加入异常体系
    class FuShuIndex extends Exception{
        public FuShuIndex() {
        }
        public FuShuIndex(String s) {
            super(s);
        }
    }

    public static void main(String[] args) {
        Demo1 d = new Demo1();
        int a[] = new int[5];
        try {
            System.out.println(d.method(a, 4));
        } catch (Demo1.FuShuIndex fuShuIndex) {
            fuShuIndex.printStackTrace();
        }
    }
}

当函数体内throw了一个Exception类型的异常，而函数名上并没有声明该异常告诉上层调用者，那么javac 编译器就认为这个代码是有安全隐患的,不允许编译通过，但如果你声明（throws）了这个异常，上层调用者就可以处理该异常,捕获或者抛出。

IO异常

public class FileReaderDemo {
    public static void main(String[] args) {
        FileReader reader = null;//创建输入流对象，与文件建立绑定
        try {
            reader = new FileReader("D://text.txt");
        } catch (FileNotFoundException e) { //文件找不到异常
            System.out.println("文件找不到");
          /*  e.printStackTrace();*/
        }
        int i = 0;
        try {
            if (reader!=null){
                while ((i=reader.read()) != -1){//调用读的方法，返回读取的字符
                    System.out.print((char)i);
                }
            }
        } catch (IOException e) {
            /*e.printStackTrace();*/
            System.out.println(e.getMessage());//得到异常的详细信息
        }
        try {
            if (reader != null){
                reader.close();//关闭资源
            }
        } catch (IOException e){ //io异常
            e.printStackTrace();
        }
    }
}