异常：
就是程序在运行时出现不正常的情况。
异常的由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。其实就是Java对不正常情况进行描述后的对象的体现。
两种问题：
严重问题（Error）、非严重问题（Exception）。
Error和Exception具有一些共性内容。(都是Throwable的子类)
try
{
需要被检测的代码
}
catch(异常类 变量)
{
处理异常的代码；（处理方式）
}
严重问题：
Java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。
非严重问题：
Java通过Exception类进行描述。对Exception可以使用针对性的代码进行处理。
异常的处理：
try
{
需要被检测的代码
}
catch(异常类 变量)
{
处理异常的代码；（处理方式）
}
异常的常见操作：
getMessage() :返回信息：异常原因
toString():反馈信息：异常类+异常原因
printStackTrace():反馈堆栈中的异常信息 异常类+异常原因+异常出现的位置，其实jvm默认的异常处理机制就是在调用printStackTrace方法
例如，除数是零
class Demo
{
int div(int a, int b)
{
return a/b;
}
} class ExceptionDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,0);//捕获到异常对象 new AritchmeticException()
System.out.println("x=" + x);
}
catch (Exception e)//把捕获到的异常给了catch: Exception e = new AritchmeticException();
{
System.out.println("除数是零！");
System.out.println(e.getMessage());
System.out.println(e.toString());
e.printStackTrace();
} System.out.println("Program Over!");
}
}
但我们在定义Class时就应该提示是否会出现异常，提醒调用该Class时是需要处理Exception。当调用者使用该Class时，必须捕获该类的异常进行处理或者抛出。
捕获：try-catch处理
class Demo
{
int div(int a, int b)throws Exception//在功能上通过throws关键字声明了该功能在使用时有可能出现问题
{
...
}
} class ExceptionDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
...
}
catch (Exception e)
{
...
}
}
}抛出：调用该有标识异常的类的方法上通过throws抛出，不处理
class Demo
{
int div(int a, int b)throws Exception//在功能上通过throws关键字声明了该功能在使用时有可能出现问题
{
...
}
} class ExceptionDemo
{
public static void main(String[] args)throws Exception
{
...
}
}
·声明异常时，建议声明更为具体的异常，这样处理的可以更具体。
例如上面的例子，可以把异常由Exception更改为ArithmeticExcption
·有多个异常时，可以针对性用多个catch处理。如果多个异常有继承关系，父类异常的catch放在最下面
建议进行catch处理时，catch中一定要定义具体的处理方式，不要简单的使用printStackTrace()等等
class Demo
{
int div(int a, int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//抛出多个异常
{ int[] arr = new int[a];
System.out.println(arr[5]);//可能出现异常的地方 return a/b;//可能出现异常的地方
}
} class ExceptionDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,0);
System.out.println("x=" + x);
}
catch (ArithmeticException e)//处理异常
{
System.out.println("除数是零！");
e.printStackTrace();
}
catch (ArrayIndexOutOfBoundsException e)//处理异常
{
System.out.println("数组角标异常！");
e.printStackTrace();
} System.out.println("Program Over!");
}
}
自定义异常：
因为项目中会出现特有问题，而这些问题是Java未对其描述并封装成对象。所以对这些特有问题可以按照Java对问题的封装思想，对其封装。
当在函数内部出现了throw抛出异常对象，那么就必须要给出对应的处理。要么在内部try-catch，要么在函数上声明让调用者处理。 一般情况下，函数内出现异常，函数上需要声明。
如何自定义异常信息呢？
因为父类已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类，通过super语句。那么就可以直接通过getMessage方法获取自定义的异常信息了。
继承Exception的原因
异常体系都有一个特点：异常类和异常对象都被抛出。
他们都具有可抛性，是Throwable这个体系的独有特点。只有这个体系中的类和对象才可以被throws和throw操作。
throws 和 throw 的区别：
1，throws使用在函数上，throw使用在函数内
2，throws后面跟的是异常类，可以跟多个，用逗号隔开；throw后跟的是异常对象
/*
需求：在本程序中，不允许除数为负数。
因为该需求是特殊要求，所以要对这个问题进行自定义的描述；
*/
class DefinedException extends Exception
{
private int value; DefinedException()
{
System.out.println("自定义异常的空参数的构造函数：除数不能为负数");
}
DefinedException(String msg)
{
super(msg);
}
DefinedException(String msg, int value)
{
super(msg);
this.value = value;
} public int getValue()
{
return value;
}
} class Demo
{
int div(int a,int b)throws DefinedException
{
if (b<0)
{
//throw new DefinedException();
//throw new DefinedException("除数不能为负数！");
throw new DefinedException("除数不能为负数！",b);//手动通过throw抛出
}
return a/b;
}
}
class DefinedExceptionDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,-1);
System.out.println("a/b="+x);
}
catch (DefinedException e)
{
System.out.println("除数不能为负数！");
System.out.println("错误的数是："+e.getValue());
//d.printStackTrace();
} System.out.println("Program Over!");
} }
RuntimeException：
Exception中有一个特殊的子类异常RuntimeException 运行时异常。
RuntimeException或者其子类的异常，可以不用在函数上使用throws申明。如果在函数上申明了该异常，调用者可以不用处理就可以通过编译。不申明的原因：当程序运行时遇到该异常，导致下面的程序不能预期运行，希望停止运行后修正该程序。（比如如果一个函数只申明了一个异常，而在函数内抛出了三个异常，那么另外两个异常必然就是RuntimeException或者其子类）
自定义异常时，如果该异常发生后无法继续工作，就让该异常继承RuntimeException
异常分两种：
1，编译时被检测的异常
2，编译时不被检测的异常，但运行时异常。RuntimeException及其子类
finally:
finally中的代码是一定会执行的代码，一般存放必须要操作的内容比如释放与数据库的连接、关闭IO等等。
finally只有一种情况不会被执行到：finally前面有System.exit(0)
异常处理的三种各式：
1， try-catch
2， try-catch-finally
3, try-fiinally
异常在子父类覆盖时的体现：
1，子类在覆盖父类方法时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常或者该异常的子类
2，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集
3，如果父类或者接口的方法中，没有异常抛出，那么子类在覆盖方法时也不可以抛出异常
如果子类方法发生了异常，就必须要try处理，绝对不能抛。