黑马程序员--异常

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IO开发S</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！
----------------------

异常：是在程序运行时期出现的不正常情况。如用户输入错误、除数为零、需要处理的文件存在、数组下标越界等。其实异常就是java通过面向对象的思想将问题封装成了对象。在java中，将异常情况分为两种Exception（异常）和Error（错误）两大类。Error是由jvm抛出的严重性的问题。这种问题发生一般不编写针对性代码，对其进行处理。Exception可以使用针对性的处理方式来处理。

异常的分类：

（1）编译时被检测异常:只要是Exception和其子类都是，除了特殊子类RuntimeException体系。 这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。这样的问题都可以针对性的处理。

（2）编译时不检测异常(运行时异常):就是Exception中的RuntimeException和其子类。这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的而或者引发了内部状态的改变导致的。那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止,让调用者对代码进行修正。

异常的处理方式：

（1）是用对异常进行捕获和处理。

（2）是通过throw和throws抛出异常。

try...catch...finally结构：

try

{

需要检测的代码

}

catch（异常量 变量）

{

处理异常的代码（处理方式）

}

finally

{

一定会执行的语句

}

异常类：用来描述和处理异常的类。

对捕获到的异常对象进常见方法操作：

（1）String getMessage();获取异常信息

（2）String toString();返回此throwable的简短描述（异常名称：异常信息）。

（3）printStackTrace();获取异常详细信息（异常名称：异常信息
异常出现的位置）。是jvm默认的异常处理机制。

例子：

import java.io.*;
class ExcDemo
{
public static void main(String[] args)
{
try
{
int x=9;
int y=0;
System.out.println(x/y);
System.out.println("Successfully! ");
}
catch (ArithmeticException e)
{
System.out.println("ArithmeticException catched!");
System.out.println(e.toString());//打印结果：java.lang.ArithmeticException: / by zero
System.out.println(e.getMessage());//打印结果：/ by zero
e.printStackTrace();//结果：java.lang.ArithmeticException: / by zero
//		at ExcDemo.main(ExcDemo.java:10)
}

}
}

异常处理的原则：
（1）函数内容如果抛出需要检测的异常，那么函数上必须要声明。
否则必须在函数内用try...catch捕捉，否则编译失败。
（2）如果调用到了声明异常的函数，要么try...catch要么throws，否则编译失败。
（3）什么时候catch，什么时候throws呢？
功能内容可以解决，用catch。
解决不了，用throws告诉调用者，由调用者解决。
（4）一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性的处理。
内部又几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。

异常的注意事项：
（1）子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。
（2）如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集。
注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try .

throws
和throw的区别：
（1）throws使用在函数上。
throw使用在函数内。
（2）throws抛出的是异常类，可以抛出多个，用逗号隔开。 throw抛出的是异常对象。

对多异常的处理：
（1）声明异常时，建议声明更为具体的异常。这样处理更为具体。
如 throws ArithmeticException
throws ArrayIndexOutOfBoundsException
（2）对方声明几个异常，就对应有几个catch块，不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
建立在进行catch处理时，catch中一定要定义具体处理方式。不要简单定义一句e.printStackTrace()，也不要简单的就写一条输出语句。
当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try...catch处理，要么在函数上声明让调用者处理。一般情况，在函数内部出现异常，在函数上需要声明。

在有些项目中可能会出现特有问题，而这些问题并没有被java所描述并封装成对象。所以对这些特有问题，我们可以按照java对问题的封装，对特有的问题进行自定义的异常封装。
自定义的异常类需要继承Exception这个类，是因为异常体系有一个特点：异常类和异常对象都被抛出，他们都具有可抛性，这个可抛性是Throwable这个体系中独有特点。只有这个体系中的类和对象才可以被throws和throw操作。
如何定义异常信息呢？因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类，通过super语句，那么就可以直接通过getMessage方法获取自定义的异常信息。
在自定义异常时，如果该异常的发生无法正常进行运算，就让自定义的异常继承RuntimeException。
RuntimeException：是Exception中一个特殊的子类异常。如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。如果在函数上声明了该异常，调用者可以不用进行处理，编译样通过。之所以不用再函数上声明，是因为不需要调用者处理。当该异常发生，希望程序终止。因为在运行时出现了无法继续运算的情况，希望停止程序后，对代码进行修正。

例子：自定义异常（除数为负数）

class MinusNumException extends Exception
{
private int value;
MinusNumException()
{
super();
}
MinusNumException(String msg,int value)
{
super(msg);
this.value = value;
}

public int getValue()
{
return value;
}

}
class Demo
{
int div(int a,int b)throws MinusNumException
{
if(b<0)
throw new MinusNumException("出现了除数是负数的情况-----/by minus number",b);
return a/b;
}
}

class ExceptionDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,-4);

}
catch(MinusNumException e)
{
System.out.println(e.toString());
System.out.println("错误的负数是："+e.getValue());
}
System.out.println("over");
}
}

其实处理异常有三种格式：

第一种：try

{

}

catch()

{

}

finally

{

}

第二种：try

{

}

catch()

{

}

第三种：try

{

}

finally

{

}

finally是用来定义一定能够执行的代码，通常用来关闭资源。finally只有一种情况不会执行，那就是到System.exit(0)语句。

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a
href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------