Java（七）异常处理

package yichangchuli;

// try catch finally的使用

/*
try{
}catch(异常类型 e){
}

1.finally是可选的
2.使用try将可能出现异常的代码包装起来
3.catch中的异常类型如果没有子父类关系，则声明在上，声明在上无所谓
    如果满足子父类关系，则子类一定定义在父类前面，否则报错
4.常用的异常对象处理方式 1.String getMessage（）  2.printStackTrace()
5.在try结构中声明的变量，出了try结构后，不能调用
6.try catch finally操作可以嵌套

体会一：使用try-catch-finally处理编译异常，使得程序在编译时就不在报错，但是运行时仍可能报错

 */

import org.junit.Test;

public class tryTest1 {
    @Test
    public void Test1(){
        String str = "123";
        str = "abc";
        try {
            int num = Integer.parseInt(str);
        } catch (Exception e) {
            System.out.println("出现数值转换异常......");
            // getMessage()
            System.out.println(e.getMessage());
            // printStackTrace
            e.printStackTrace();
        }
    }
}

package yichangchuli;

import org.junit.Test;

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

// finally的用法
/*
1.finally是可选的
2.finally中声明的一定会被执行的代码，即使catch中又出现异常，try中有return语句，catch中有return语句
3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动回收的。我们需要自己手动进行资源释放，声明咋子finally中

 */
public class finally1 {

    @Test
    public void test2(){
        FileInputStream fis = null;
        try {
            File file = new File("hello.txt");
            fis = new FileInputStream(file);

            int data = fis.read();
            while (data != -1){
                System.out.println((char)data);
                data = fis.read();
            }

        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if(fis != null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void test1(){
        try{
            int a = 10;
            int b = 0;
            System.out.println(a/b);
        }catch (ArithmeticException e){
            e.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println("finally.......");
        }
    }
}

package yichangchuli;

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

/*
异常处理的方式二：throws + 异常处理

1."throws + 异常处理"写在方法的声明处可能会抛出异常类型，
    一旦方法体执行时，出现异常仍会在异常代码处生成一个异常类型的对象，此对象满足throws后异常类型时，就会抛出
    异常代码后续代码不再执行。
2.体会：try-catch-finally真正将异常处理掉了
        throws还是将异常抛给了方法的调用者
3.
    3.1 如果父类中被重写的方法没有throws方法处理异常，则子类重写的方法也不能使用throws
        意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理
    3.2 执行的方法a中先后又调用了另外的几个方法，这几个方法是递进关系执行的，我们建议这几个方法使用throws的方法进行处理
        而执行的方法a可以考虑使用try-catch-finally方式进行处理。

 */
public class ExceptionTest2 {

    public static void main(String[] args) {
        try {
            method2();
        }catch (IOException e){
            e.printStackTrace();
        }

    }

    public static void method2() throws IOException{
        method1();
    }

    public static void method1() throws FileNotFoundException, IOException {
        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();
    }
}