java--异常
异常：就是程序在运行时出现不正常情况。阻止当前方法或作用域继续执行的问题。
异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。
异常的好处：
1，将问题进行封装。
2，将正常流程代码和问题处理代码相分离，方便于阅读。
Throwable 类是 Java 语言中所有错误或异常的超类（这就是一切皆可抛的东西）。它有两个子类：Error和Exception。
Error：用于指示合理的应用程序不应该试图捕获的严重问题。这种情况是很大的问题，大到你不能处理了，所以听之任之就行了，你不用管它。比如说VirtualMachineError：当 Java 虚拟机崩溃或用尽了它继续操作所需的资源时，抛出该错误。好吧，就算这个异常的存在了，那么应该何时，如何处理它呢？？交给JVM吧，没有比它更专业的了。
Exception：它指出了合理的应用程序想要捕获的条件。Exception又分为两类：一种是CheckedException，编译时被检测的异常。一种是UncheckedException，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)。这两种Exception的区别主要是CheckedException需要用try...catch...显示的捕获，而UncheckedException不需要捕获。通常UncheckedException又叫做RuntimeException。对于可恢复的条件使用被检查的异常（CheckedException），对于程序错误（言外之意不可恢复，大错已经酿成）使用运行时异常（RuntimeException）。
RuntimeException和非RuntimeException的区别 ：
RuntimeException：RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等。处理RuntimeException的原则是：如果出现RuntimeException，那么一定是程序员的错误。例如，可以通过检查数组下标和数组边界来避免数组越界访问异常。
非RuntimeException（IOException等等）：这类异常一般是外部错误，例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。
NullPointerException - 空指针引用异常
ClassCastException - 类型强制转换异常。
IllegalArgumentException - 传递非法参数异常。
ArithmeticException - 算术运算异常
ArrayStoreException - 向数组中存放与声明类型不兼容对象异常
ArrayIndexOutOfBoundsException - 数组下标越界异常
IndexOutOfBoundsException - 下标越界异常
NegativeArraySizeException - 数组负下标异常
NumberFormatException - 数字格式异常
SecurityException - 违背安全原则异常
UnsupportedOperationException - 不支持的操作异常
FileNotFoundException - 文件未找到异常
EOFException - 文件已结束异常
SQLException - 操作数据库异常
IOException - 输入输出异常
NoSuchMethodException - 方法未找到异常
下面是这几个类的层次图：
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
java.lang.Error
java.lang.ThreadDeath
对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。
对与非严重的，java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。
无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等。
异常的处理
一、
java 提供了特有的语句进行处理。
try
{
需要被检测的代码；
}
catch(异常类 变量)
{
处理异常的代码；(处理方式)
}
finally
{
一定会执行的语句；
}
对捕获到的异常对象进行常见方法操作。
String getMessage()：获取异常信息。
package Test;
class Test
{
public static void main(String[] args) //throws Exception
{
Demo d = new Demo();
try
{
int x = d.div(4,0);//new ArithmeticException();
System.out.println("x="+x);
}
catch (Exception e)//Exception e=ArithmeticException();
{
System.out.println("异常了："+e.getMessage());//返回此 异常信息
System.out.println("异常了："+e.toString());//返回此 异常名称：异常信息
e.printStackTrace();//异常名称，异常信息，异常出现的位置。
//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。
//打印异常的堆栈的跟踪信息。
}
System.out.println("over");
}
}
class Demo
{
int div(int a,int b)
{
return a/b;
}
}结果是：
异常了：/ by zero
异常了：java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zero
at Test.Demo.div(Test.java:25)
at Test.Test.main(Test.java:9)
over
二、
java异常处理的throw和throws的区别
1. 区别
throws是用来声明一个方法可能抛出的所有异常信息。
throw则是指抛出的一个具体的异常类型。此外throws是将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理。
2.分别介绍
throws：用于声明异常，throws使用在函数上。throws后面跟的异常类。可以跟多个。用逗号隔开。例如，如果一个方法里面不想有任何的异常处理，则在没有任何代码进行异常处理的时候，必须对这个方法进行声明有可能产生的所有异常（其实就是，不想自己处理，那就交给别人吧，告诉别人我会出现什么异常，报自己的错，让别人处理去吧）。
当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。
注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。
格式是：方法名（参数）throws 异常类1，异常类2，.....
class Test
{
public static void main(String[] args) throws Exception//将异常抛出
{
int a=4,b=0,c;
c=new Demo().div(a,b);
System.out.println("over");
}
}
class Demo
{
int div(int a,int b)throws Exception
{
return a/b;
}
}
throw：就是自己进行异常处理，处理的时候有两种方式，要么自己捕获异常（也就是try catch进行捕捉），要么声明抛出一个异常（就是throws 异常~~）。throw使用在函数内。throw后跟的是异常对象注意：throw一旦进入被执行，程序立即会转入异常处理阶段，后面的语句就不再执行，而且所在的方法不再返回有意义的值！
class Test
{
public static void main(String[] args) throws Exception//将异常抛出
{
int a=3,b=0,c;
//int a=0,b=3,c;
//int a=0,b=0,c
c=new Demo().div(a,b);
System.out.println("over");
}
}
class Demo
{
int div(int a,int b)throws Exception,ArithmeticException
{
if(b==0)
throw new ArithmeticException("除数异常");
if(a==0)
throw new Exception("被除数异常");
return a/b;
}
}
当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
要么在内部try catch处理。
要么在函数上声明让调用者处理。
一般情况在，函数内出现异常，函数上需要声明。
自定义异常：
自定义异常通常是定义一个继承自Exception类的子类。一般情况下我们都会直接继承自Exception类，而不会继承某个运行时的异常类。
继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
//自定义异常：
//1、创建自定义异常：
public class MyException extends Exception
{
public MyException()
{
super();
}
public MyException(String msg)
{
super(msg);
}
}
//2、在类中使用异常：
public class ExceptionTest
{
public static void Demo(String a) throws MyException
{
System.out.println("Demo...");
if("true".equals(a))
{
throw new MyException("参数不能为 true");
}
}
}
//3、捕获自定义异常：
public static void main(String[] args) throws MyException
{
Demo("true");
}