异常处理总结

一：try-catch-finally
/*
* 说明：
* 1.finally类是可选的
* 2.使用try将可能出现异常的代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象
* 的类型，去catch中进行匹配
* 3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常类的处理。一旦处理完成，就跳出当前的
* try-catch结构（在没有写finally的情况）。继续执行其后的代码
* 4.catch中的异常类型如果没有子父类关系，则声明在上，谁声明在下无所谓
* 如果满足子父类的关系，则要求子类一定要声明在父类上面，否则，报错
* 5.常用的异常对象处理的方式，String  getMassage()  printStackTrace()
* 6.在try结构中声明的变量，出了try结构以后，就不能再被调用
*
* 7.finally类声明的是一定会被执行的代码。即使catch中又出现异常了、try中有return语句、catch中有return语句等情况
* 这种情况下如果没有finally，则系统会直接结束运行
*
* 8。像数据库连接，输入输出流网络编程Socket等资源，JVM是不能自动回收的，需要我们自己手动进行资源的释放，
* 此时的资源释放（7中的情况），就需要声明在finally中。
*
* 体会:使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。*/

public class text1 {
    public static void text(){
        FileInputStream fis = null;
        try {
            File file = new File("hello1.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();
            }
        }
    }
    public static void main(String[] args) {
        String str="123";
        str="abc";
        try{
            int num=Integer.parseInt(str);

            System.out.println("hello--1");//如果发现异常，直接进入catch不在进行下面的语句；
        } catch (NumberFormatException e) {
            System.out.println("出现了数值转换异常...");
            //String getMessage()
            System.out.println(e.getMessage());
            //打印出运行时调用的数据（错误信息）
//            e.printStackTrace();
        }catch(NullPointerException e){//在新的catch中e可以再次利用
            System.out.println("出现了空指针...");
        }catch (Exception e){
            System.out.println("出现异常了..");
        }
        System.out.println("hello---2");
        text();
    }
}

二：throws

/*
1."throws + 异常类型"写在方法的声明出处。指明此方法执行时，可能会抛出的异常类型
   一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常
   类型时，就会抛出。异常代码后续的代码，就不再执行。

 2.体会：try-catch-finally：真正将异常给处理掉了。
 throws的方式，只是将异常抛给了方法的调用者。并没有真正将异常给处理掉.

 3.如果子类重写父类的方法时，当父类抛出异常类型时，子类抛出的异常类型不能大于父类的异常类型

 4.如何选择使用try-catch-finally 还是throws？
  4.1如果父类中被重写的方法没有用throws方式处理异常，则子类重写的方法也不能使用throws，意味着
  如果子类重写的方法有异常，必须使用try-catch-finally 方式处理。
  3.2执行的方法a中，先后又调用了另外几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws
  的方式进行处理。而执行的方法a可以考虑使用try-catch-finally 方式进行处理

  如果递进关系中使用try-catch-finally 处理。如果某一段代码出现异常了，后面的代码没有必要在运行了，

  通常从程序代码中抛出的是自己编写的异常（系统不会帮我们自动抛出，除了系统定义的运行异常）
 */

public class text2 {
    public static void main(String[] args) {
        try {
            method2();
            System.out.println("hello--1");
        }catch (IOException e){
            e.getMessage();
        }
    }
    public static void method2() throws IOException{
        method1();
    }
    public static void method1() throws FileNotFoundException,IOException {//file..继承io所以只写io..也行
        File file = new File("hello.txt");
        FileInputStream fis = new FileInputStream(file);

        int data = fis.read();
        while (data!=-1){
            System.out.println((char)data);
            data = fis.read();//继续读取下一个；
        }
        fis.close();
    }
}