异常：

就是程序在运行时出现不正常情况。

对于问题的的划分可分为：严重的和不严重的：

对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。

对与非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。

无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。这就形成了Throwable类。

Throwable
|--Error
|--Exception

异常的处理：

方式一：

try
{
需要被检测的代码；
}
catch(异常类 变量)
{
处理异常的代码；(处理方式)
}
finally
{
一定会执行的语句；
}

例如：

class Demo
{
	double divd(int a,int b) throws Exception //在功能上通过throws的关键字声明了该功能有可能会出现问题。----声明异常
	{
		return a/b;
	}
}
class ExceptionDemo 
{
	public static void main(String[] args) 
	{

		Demo d=new Demo();
		try
		{
			System.out.println(d.divd(4,0));
		}
		catch (Exception e)	//可以通过e调用Exception类中方法
		{
			System.out.println("被零除啦！");
			System.out.println(e.getMessage());//  / by zero;
			System.out.println(e.toString());// 异常名称 ： 异常信息。
			e.printStackTrace();//异常名称，异常信息，异常出现的位置。
							//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。
							//打印异常的堆栈的跟踪信息。
		}
		System.out.println("over");	
	}
}

在函数上声明异常，便于提高安全性，让调用者进行处理。不处理编译失败——RuntimeException类例外，下面会说。

通过这个方式，发现即使程序异常，依旧可以输出最后一个over，也就是不影响程序的运行。

方式二：继续throws，如果一直throws最终交给JVM处理。

class Demo
{
	double divd(int a,int b) throws Exception //在功能上通过throws的关键字声明了该功能有可能会出现问题。
	{
		return a/b;
	}
}
class ExceptionDemo 
{
	public static void main(String[] args) throws Exception //此时没有调用者了，JVM默认处理
	{
		Demo d=new Demo();
		System.out.println(d.divd(4,0));
		System.out.println("over");	
	}
}

异常处理须知：

1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
3，建议在进行catch处理时，catch中一定要定义具体处理方式。不要简单定义一句 e.printStackTrace()，也不要简单的就书写一条输出语句。

自定义异常：

因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题。进行自定义的异常的封装。

例如：除数不能为零，这是系统存在的一种异常类。精确地说它的类是：ArithmeticException

java.lang.Object
  java.lang.Throwable
      java.lang.Exception
          java.lang.RuntimeException
             java.lang.ArithmeticException

如果我们要求除数不能为负数时，我们便需要自定义异常类，然后同一般异常类一样抛出异常类。

例：

class FuShuException extends Exception	//必须继承Exception类
{
	private int b;
	FuShuException()
	{
		super();
	}
	FuShuException(String msg,int b)
	{
		super(msg);	//调用Exception类中的带String参数的方法
		this.b=b;
	}
	int getValue()
	{
		return b;
	}
}
class Demo
{
	double divde(int a, int b) throws FuShuException
	{
		if(b<0)
			throw new FuShuException("不能是负数！",b); //抛出自定义异常对象，如果判读成立，就把异常抛出。
		return a/b;
	}
}
class ExceptionDemo2 
{
	public static void main(String[] args) 
	{
		Demo d=new Demo();
		try
		{
			System.out.println("输出:"+d.divde(6,-2));
		}
		catch (Exception e) //多态特性
		{
			System.out.println(e.toString()); //输出：FuShuException:不能是负数！
			System.out.println(e.getMessage());//输出：不能是负数！
			System.out.println(e.getValue());//编译出错,多态原因，Exception中并没有getValue方法。需要将catch括号中改为FuShuException
		}
		System.out.println("over");
	}
}

继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。只有这个体系中的类和对象才可以被throws和throw操作。

throw和throws的区别：

throws使用在函数上<————>throw使用在函数内。

throws后面跟的异常类。可以跟多个。用逗号隔开。<————>throw后跟的是异常对象。

特殊的异常子类RuntimeException:

1、如果在函数内抛出（throw）该异常，则函数上可以不用声明，编译一样通过。

2、如果在函数上声明了（throws）该异常。调用者可以不用进行处理。编译一样通过；

关于这二点的作用：

前面曾说过，有时候希望中断程序运行，因为try的话很有可能隐藏了问题，比如上面除数为0时，运行没有报错，直接输出over了，但我们希望运行中断，让调用者修改传入参数。此时要利用RuntimeException类的特性——编译不会报错的特性。

所以自定义异常时：如果希望该异常的发生，无法在继续进行运算，就让自定义异常继承RuntimeException。

finally代码块部分：

定义一定会执行的代码，通常用来关闭资源。

例如：对数据库的访问。

void function()

{

1.连接数据库

2.数据操作 //可能会发生异常。如果异常关闭数据库就不会发生

3.关闭数据库 //放在finally代码块中

}

只有try和finally也是可以的。但注意一点：catch是用于处理异常。如果没有catch就代表异常没有被处理过，如果该异常是检测编译时异常（非RunTimeException）。那么必须在函数上声明异常。此时finally通常用来关闭资源，try将异常继续抛出。

void method() throws Exception
{
	try
	{
		throw new Exception();
	}
	finally
	{
		//关资源。
	}
}

父类的方法抛出异常，子类的方法覆盖规则：

2，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。

3，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。

/*
Exception 
	|--AException
		|--BException
	|--CException
*/
class Fu
{
	void show()throws AException
	{
	
	}
}


class Zi extends Fu
{
	void show()throws AException //AException可以，BException可以，CException不可以
	{
		
	}
}

JAVA基础——异常处理