异常体系：
Throwable
---Error
通常出现重大问题：如类不存在或者内存溢出。停止运行，不对代码进行处理
---Exception
在运行时出现的情况，可以进行针对性处理。可以通过try catch finally
---RuntimeException 运行时异常。
异常处理：
try
{
需要被检测的代码
}
catch (异常类 变量)
{
处理异常的代码
}
finally
{
一定会执行的代码
通常是关闭资源或连接。
}
例子：
class Div
{
private int a;
private int b;
public int div(int a,int b)
{
this.a=a;
this.b=b;
return a/b;
}
}
class DivDemo
{
public static void main(String[] args)
{
try
{
Div d1=new Div();
int x=d1.div(6,0);
System.out.println(x);
}
catch (Exception e)
{
System.out.println(e.getMessage());/// by zero
System.out.println(e.toString());///java.lang.ArithmeticException: / by zero
e.printStackTrace();//详细的堆栈信息
//java.lang.ArithmeticException: / by zero
// at Div.div(Divdemo.java:9)
// at DivDemo.main(Divdemo.java:22)
}
}
}
对多异常的处理：
1.声明异常时，建议声明更为具体的异常。这样处理的可以具体些
2.对方声明几个异常，就对应有几个catch块，不要定义多余的catch块。
3.如果多个catch块中的异常出现继承关系，父类异常一定要放在最下面
自定义异常：
当函数内部出现了throw抛出异常对象，那么就必须给对应的处理动作。
1.要么在内部try catch处理
2.要么在函数上声明让调用者处理
3.如何自定义异常信息:因为父类中已经异常信息的操作都完成了。所以子类只要在构造时，讲异常信息传递给父类，通过super语句。
一般情况，函数内部出现异常，函数上需要声明。
4.自定义类必须继承Exception.
5.throws和throw的区别:
1)throws 使用在函数上，用于函数声明；throw 使用在函数内。
2)throws 后面紧跟着声明的异常类，可以多个，用逗号隔开；throw后面跟着是抛出异常类的对象。
6.catch 是用于处理异常。如果没有catch就代表异常没有被处理过，如果该异常是检测时异常，那么必须声明
7.finall一种情况下不会执行，当程序执行到System.exit(0)，finally不会执行。例如：
class Test
{
public static String output="";
public static void foo(int i)
{
try
{
if(i==1)
throw new Exception();
output+="1";
}
catch(Exception e)
{
output+="2";
return; //returun后finally继续执行，但是其他语句就不再执行了
}
finally
{
output+="3";
}
output+="4";
}
public static void main(String args[])
{
foo(0);
System.out.println(output);//134
foo(1);
System.out.println(output); //13423
}
}
8.throw单独存在，下面不要定义语句，因为执行不到。
class FushuException extends Exception
{
FushuException(String msg)
{
super(msg);
}
}
class Div
{
private int a;
private int b;
public int div(int a,int b) throws FushuException//函数内部出现throw抛出异常，函数上需要throws声明。
{
this.a=a;
this.b=b;
if (b<0)
{
throw new FushuException("出现了负数");
//System.out.print("dddd");//throw单独存在，下面不要定义语句，因为执行不到。
}
return a/b;
}
}
class FuDemo
{
public static void main(String[] args)
{
try
{
Div D1=new Div();
D1.div(3,-1);
}
catch (FushuException e)
{
System.out.print(e.toString());
}
}
}
Exception 中有一个特殊的子类异常叫RuntimeException 运行时异常。特点：出现了无法运行的情况，需要对代码进行修改
1.如果在函数内throw抛出异常，函数上可以不用声明，编译一样通过。
2.如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。
自定义异常时：如果该类的发生，无法在继续进行运行，可让自定义异常类继承RuntimeException
异常分类：
1.编译时被检测的异常
2.编译时不被检测的异常（RuntimeException以及子类）
catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。
也不要不写。
当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}
如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，在抛出和该功能相关的异常。
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，
当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。
try
{
throw new AException();
}
catch (AException e)
{
// 对AException处理。
throw new BException();
}
比如，汇款的例子。
异常在子父类覆盖中的体现：
1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。
2.如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
3.如果父类或者接口的方法没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。
如果子类方法发生了异常，必须进行try处理，绝对不能抛
class NoValueException extends RuntimeException
{
NoValueException(String message)
{
super(message);
}
}
interface Shape
{
void getArea();
}
class Rec implements Shape
{
private int len,wid;
Rec(int len ,int wid)//throws NoValueException
{
if(len<=0 || wid<=0)
throw new NoValueException("出现非法值");
this.len = len;
this.wid = wid;
}
public void getArea()
{
System.out.println(len*wid);
}
}
class Circle implements Shape
{
private int radius;
public static final double PI = 3.14;
Circle(int radius)
{
if(radius<=0)
throw new NoValueException("非法");
this.radius = radius;
}
public void getArea()
{
System.out.println(radius*radius*PI);
}
}
class ExceptionTest1
{
public static void main(String[] args)
{
Rec r = new Rec(3,4);
r.getArea();
Circle c = new Circle(-8);
System.out.println("over");
}
}