异常：在程序执行过程中发生的不正常情况，但是语法错误和错误的逻辑思想不算异常。
IDEA添加异常处理的快捷键：选中要处理的代码块——>Ctrl+alt+T——>选择添加的处理，这样，有了异常也不会终止程序，在相应处理后仍会继续向下执行。
一、异常分类：
（1）ERROR（错误）：JVM无法解决的严重问题，如栈溢出、内存不足等
（2）Exception（异常）：
（2.1）运行时异常：在运行过程中，一般是由于逻辑错误导致的，编译器检查不出，这类异常不要求强制处理。
（2.2）编译时异常：编译时编译器检查出的异常，一般为网络、文件、数据库异常，这类异常编译器要求必须处理，否则编译不通过。
二、常见的运行时异常：
（1）ClassCastException:类型转换异常，当试图将对象转换为不能转换的类类型时
（2）NumberFormatException:数字格式不正确异常，试图将字符串转换成数字，但是字符串的形式不符合
（3）空指针异常、数组越界异常等等
三、异常处理机制：
（1）try-catch-finally：在代码块中捕获异常，自行处理
（2）throws：将异常抛出，交给方法的调用者处理，最顶级的处理者是JVM
四、try-catch详细：
try{
? ? ? ? 可能存在异常的代码，如果出现了异常，try块中异常后面的代码不再执行，进入后面的catch匹配处理异常；如果try中没有出现异常，则不执行catch块
}catch（异常1）{
? ? ? ? 出现的异常为异常1，将其捕获，程序员对其处理
}catch（异常2）{
? ? ? ? 同理异常1
}finally{
? ? ? ? 不管try中是否有异常，始终都会执行，通常将释放资源的操作放在这里
}
执行顺序：
try中出现异常，try块中的后续代码不执行——>直接跳到catch处理匹配——>finally块——>后续的代码继续执行；
try中无异常，执行try块——>finally块——>后续代码
注：
（1）可以有多个catch语句，可以针对不同的异常做出不同的处理，但是这里只是对异常进行了细分，不会一下捕获好几个异常都同时处理，因为在try中只要碰到一个异常就不会在往下执行了，而且catch的异常类型前面不能是后面的子类。
package exception_;
import pra13.Person;
public class TryCatch {
public static void main(String[] args) {
//这里的多个catch只是对可能出现的异常进行了更细致的划分处理，当try中出现异常之后，后面的语句不管有无异常都不会再执行
//这里出现了空指针之后下面即使有算数异常也不会被执行，也就不会被捕获，也就是说只能捕获处理一个异常
try {
Person person = null;
person.getAge();
System.out.println("出现空指针异常之后的语句");
int a = 5;
int b = 0;
int c = a/b;
System.out.println("出现算数运算异常之后的语句");
}catch (NullPointerException e){
System.out.println("空指针异常");
}catch (ArithmeticException e){
System.out.println("算数异常");
}catch (Exception e){
System.out.println("其他异常");
}
System.out.println("catch 之后的语句。。。");
}
}
（2）finally块必须执行，即使在catch中有return，也要临时将结果保存起来，执行完finally后，在将临时结果保存！！！
例如：
?（3）try-finally结构的使用场景：执行一段代码，不管是否发生异常，都想要执行的操作。但是这相当于没有捕获异常，执行顺序为：
try发生异常，try块后续不再执行——>finally——>抛出异常，结构后面的语句不再执行
package exception_;
public class TryFinally {
public static void main(String[] args) {
//try中的异常出现后，不执行后续语句，执行finally，然后JVM将异常抛出，try-finally后面的语句也不再执行
try{
int a = 5;
int b = 0;
int c = a/b;
System.out.println("try中发生异常之后的语句");
}finally {
System.out.println("执行finally");
}
System.out.println("finally之后的语句");
}
}
练习：
package exception_;
import java.util.Scanner;
public class Exercise {
public static void main(String[] args) {
//提示用户输入一个整数，如果不是，持续输入，直到输入为整数为止
Scanner scanner = new Scanner(System.in);
int num = 0;
while (true){
System.out.println("请输入一个整数：");
try {
num = Integer.parseInt(scanner.next());
break;
}catch (Exception e){
System.out.printf("输入有误，请继续输入");
}
}
System.out.println("输入的数为："+num);
}
}
?五、throws详细：
（1）用throws可以声明抛出一个异常列表，异常类型可以是产生的异常类型，也可以是他的父类
（2）子类重写父类方法时，子类重写的方法抛出的异常要么和父类抛出的一致，要么是父类抛出异常类型的子类
（3）如果出现了异常，没有try-catch，也没有显示的throws抛出，会有默认的抛出异常，一层层向上抛出，直到JVM输出异常信息，退出程序
（4）try-catch和throws二选一即可
注意：
package exception_;
import java.io.FileNotFoundException;
import java.nio.channels.FileLock;
public class Throws {
public static void main(String[] args) {
fun();
System.out.println("调用者异常后面的语句不会执行");
}
public static void fun() throws ArithmeticException{
int a = 5;
int b = 0;
int c = a/b;
System.out.println("throws中的异常后面的语句不会执行");
}
public void fun1(){
//fun2();//这里编译报错，因为fun2抛出的是一个编译异常，编译异常是要求必须处理的
}
public void fun2() throws FileNotFoundException {}
public void fun3(){
fun4();//这里编译不会报错，因为这里相当于有一个运行时异常的可能，但是会有默认的throws向上抛出
}
public void fun4() throws NullPointerException{}
}
六、自定义异常
继承Exception或RuntimeException，建议继承第二个，因为在创建后会有默认的throws异常处理，不包含编译时异常
package exception_;
public class MyException {
public static void main(String[] args) {
int age = 190;
if(!(age>=18 && age<=100)){
throw new CustomException("age is wrong");
}
System.out.println("年龄正确");
}
}
class CustomException extends RuntimeException{//继承运行时异常不会有编译错误，可以使用默认的处理机制
public CustomException(String message) {
super(message);
}
}七、throw 和 throws之间的区别：
throw：是手动生成异常的一个关键字，在方法体中，后面跟的是创建的异常对象，
如 throw new XXX（传参）；
throws：是异常处理的一种方式，用在方法的声明中，后面跟的是异常的类型
注：当有异常时，System.out.println(e.getMessage());时，才会输出异常中传入的参数内容