java--异常

异常：就是程序在运行时出现不正常情况。阻止当前方法或作用域继续执行的问题。

异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

异常的好处：
1，将问题进行封装。
2，将正常流程代码和问题处理代码相分离，方便于阅读。

java的异常体系：
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");
}