13 Java异常（异常过程解析、throw、throws、try-catch关键字）

  public class ThrowableDemo {
      public static void main(String[] args) throws ParseException {
          //错误Error --》 死递归（访问无限调用自身，不能停止）【栈溢出错误】
          //java.lang.StackOverflowError ---》 栈溢出错误
          //show();
          //异常Exception --》
          // 运行时异常 ---> 数组下标越界异常 ---> ArrayIndexOutOfBoundsException
  //          int[] arr = new int[2];
  //           System.out.println(arr[3]);
          /*
          编译时异常 ---> 时间格式化解析方法 Unhandled exception: XXXXX ---> 提示是一个编译时异常需要处理
          java: 未报告的异常错误java.text.ParseException; 必须对其进行捕获或声明以便抛出
          编译时异常发现时，必须进行处理，否则无法正确执行代码
          */
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
          sdf.parse("1990-01-01");
      }
      public static void show(){
          show();
      }
  }

//抽象父类 ---> Person
public abstract class Person {
    private String name;
    private String sex;
    public Person(){}
    public Person(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}
class Man extends Person{
    public Man() {
    }
    public Man(String name, String sex) {
        super(name, sex);
    }
}
class Woman extends Person{
    public Woman() {
    }
    public Woman(String name, String sex) {
        super(name, sex);
    }
}
class FactoryPerson{
    public static Person createPerson(String sex){
        switch (sex){
            case "男人":
                return new Man();
            case "女人":
                return new Woman();
            default:
//throw 可以当做一个return使用
                throw new RuntimeException("没有这个性别，无法创建....");
        }
    }
}
class Test{
    public static void main(String[] args) {
        Person man = FactoryPerson.createPerson("男人");
        System.out.println(man.getSex());
        Person oldMan = FactoryPerson.createPerson("老人");
        System.out.println(oldMan.getSex());
    }
}

访问权限修饰符 [其他修饰符] 返回值类型 方法名(参数列表)throws 异常类名1,异常类名2...{
        方法体
        return 或 throw 关键字
        }
PS：throws 关键字后面的异常可以有多个，每个异常之间使用[,]分隔

public class ParseExceptionDemo {
    //此时异常声明标识是在main方法上，如果一旦触发异常必然是JVM虚拟停止并打印异常信息
    public static void main(String[] args) throws ParseException, IOException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String time = "1990-01-01";
        Date parse = sdf.parse(time);
        //因为在show方法上声明标识了一个编译时异常IOException，所以只要调用show方法就需要
        处理这个异常
        show();
    }
    public static void show()throws IOException{
        //Unhandled exception: java.io.IOException-->因为IOException是编译异常
        //需要外界调用按方法时，知晓这个内部会出现异常问题
        throw new IOException();
    }
}

try{
编写代码，这里的代码是可能出现异常代码
}catch(异常类型 e){
提供当前处理异常代码
例如"【记录日志、打印异常信息、继续抛出异常等等】"
}
执行步骤：
1. 首先会先执行try代码块中代码，如果try代码块中代码出现了异常，那么就执行catch代码
块中代码，执行完毕之后，程序继续向下执行
2. 如果try代码块中代码没有出现异常，那么就不会执行catch代码块中代码，而是代码继续向
后执行

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TryCatchDemo {
    public static void main(String[] args) {
    //提供出现异常代码
/*
int[] arr = new int[1];
System.out.println(arr[2]);//arr[2]出现了下标越界异常，没回造成当前后续代码无法
执行
System.out.println("我要是出现，证明程序执行到这行代码....");
*/
//提供try...catch代码块进行一个捕获处理 -->快捷键 ctrl+atl+t
/* try {
int[] arr = new int[1];
System.out.println(arr[2]);//arr[2]出现了下标越界异常，没回造成当前后续代码
无法执行
} catch (ArrayIndexOutOfBoundsException e) { //catch后面小括号内提供异常类
型，尽量是要对应捕获的异常类型
//提供除以异常方式
*//*
catch中确实可以做异常信息的提示，保证代码可以继续向后执行，但是只要出现以异常信
息
说明比代码出现了问题，虽然catch提供错误信息让代码继续执行，但并没有修改错误异常
代码
当我们发现出现异常信息时，需要及时的处理当前try中产生产生异常代码，否则虽然保证
代码正常执行，但是效果是错误的
*//*
//System.out.println("下标越界了，无法访问");
*//*
Throwable类中还提供一些方法可以方便不我们在catch代码块中进行错误信息的提示
getMessage() --> 打印异常信息【这个信息是系统提供（可能会很笼统）】
*//*
//System.out.println(e.getMessage());
*//*
开发阶段可以使用这个方法，但是项目上线之后就建议修改掉这个操作
方法printStackTrace() --> 打印异常栈信息包含了：【异常类型、异常原因、异常出
现位置】
*//*
e.printStackTrace();
}
System.out.println("我要是出现，证明程序执行到这行代码....");*/
        try {
            int[] arr = new int[1];
            System.out.println(arr[2]);//try代码块中如果代码出现异常，后续代码都无法执行【try中】
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date parse = sdf.parse("1990-10-10");
            System.out.println(parse);
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (ArrayIndexOutOfBoundsException e){//try多个异常是，添加多个catch代码块进行异常追加捕获操作
            e.printStackTrace();
        }
        //提供多个catch的时候父类异常一定要在最后一个catch中，不要放置到之前否则无法正常捕获异常【异常子类】
        System.out.println("我被还行了");
        //ps: 在开发中如何处理多个catch的问题？因为代码中如果异常过多，那么会造成代码中catch语句非常多
        // 代码的简洁基本上就没有，所以面临这种多个异常需要处理是，就是直接提供父类异常抓取
        try {
            int[] arr = new int[1];
            System.out.println(arr[2]);//try代码块中如果代码出现异常，后续代码都无法执行【try中】
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date parse = sdf.parse("1990-10-10");
            System.out.println(parse);
        } catch (Exception e) { //这个父类Exception的原则就是谁出现异常就抓取谁吗，而且都可以匹配
            e.printStackTrace();
        }
        //提供多个catch的时候父类异常一定要在最后一个catch中，不要放置到之前否则无法正常捕获异常【异常子类】
        System.out.println("我被换行了");
    }
}

import java.text.SimpleDateFormat;
import java.util.Date;

public class TryCatchFinallyDemo {
    public static void main(String[] args) {
        try {
            int[] arr = new int[1];
            //让代码出现异常
            System.out.println(arr[2]);
            //System.out.println(arr[0]);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date parse = sdf.parse("1990-10-10");
            System.out.println(parse);
            //return; //---> 提供一个return关键字让方法结束 --》 return是不会阻止
            finally与就块执行
             // System.exit(1);---> 终止虚拟机 所以finally遇到它时候是不会执行
        } catch (Exception e) {
             // System.exit(1);
            e.printStackTrace();
        }finally {
            // 所以利用finally代码块进行资源释放
            System.out.println("无论是否发生异常finally都将执行");
        }
        System.out.println("我换行行了");
    }
}