黑马程序员- java-Exception

---------------------- android培训、 java培训、期待与您交流！ ----------------------

  java中的异常就是指在程序运行过程中出现了问题，现实生活中的问题是一个具体的事物，java作为面向对象的语言，则通过类描述问题，把
问题封装成对象。
    异常体系：
       Throwable
           --Error
           --Exception
                 --RuntimeException
  Throwable类是Java语言中所有错误或异常的超类，Error和Exception是他的2个子类。对于Error，是严重的问题，一般不编写针对性的代码对其处理，
对于Exception则可以使用针对性的方式进行处理。 
java可以通过try-catch语句来捕获程序中出现的问题的对象
  try{程序}
  catch{Exception e}
  {
     e.printStackTrace();
  }
  Exception为异常问题被封装的对象的类型，e为一异常对象，内部封装了异常的信息; e.printStackTrace()就是打印出该问题对象中的异常信息。
 
 
如果定义一个方法可能会出现异常，则可通过在方法上加throws来声明异常,在调用该方法的函数中用try-catch捕获
int div(int a,int b) throws Exception
{
     return a/b;
}
当然在声明异常时，建议声明为更具体的异常，这样处理可以更具体：int div(int a,int b) throws ArithmeticException
，也可以声明多个具体的异常int div(int a,int b) throws A,B,C,
具体异常类都为Exception的子类。

对于项目中出现的特有问题，我们可以通过继承Exception类定义自己的异常：
class SelfException extends Exception
{ }

可以通过throw关键字抛出一个自定义的异常对象：
int div(int a,int b)
{
     if(b<0)
       throw new SelfException();
     return a/b;
}
当在方法内部出现了throw抛出的异常对象，要么在方法上声明让调用者处理，要么在内部try-catch处理：

int div(int a,int b) throws SelfException
{
     if(b<0)
       throw new SelfException();
     return a/b;
}
或者int div(int a,int b)
 {
      if(b<0)
   try
   {
    throw new SelfException();
   }
   catch (SelfException e)
   {
    
    e.printStackTrace();
   }
      return a/b;
 }
如果方法上声明了异常，则调用者处理的方法有throws或try 
 
 
因为父类Exception已经把异常信息都操作完成了，所以子类在构造时将异常信息传递给父类通过super语句，
就可以直接通过getMessage方法获取自定义的异常。
class SelfException extends Exception
{
 SelfException(String message)
 {
  super(message);
 }
}

我们自定义的异常继承Exception的原因：
因为异常类和异常对象都被抛出，他们都具备可抛出性，这个可抛性是Throwable这个体系独有的特点，
只有这个体系中的类和对象才可以被throw和throws操作。
throws使用在函数上，throw使用在函数内，throws后面跟的异常类，可以用多个逗号隔开，
throw后面跟的是异常对象。

在异常的子类中，有一个RuntimeException类及其子类，未检查异常类，就是该类在编译过程中不检查，编译可以通过，
如果在方法内抛出该异常，方法上可以不声明，如果在方法上声明了该异常，调用者可以不处理，因为该异常如果发生，
程序会停止，无法继续执行，希望对程序代码进行修正。
当在自定义问题的时候，如果发生的问题自己可以处理，继承Exception;如果问题自己不能处理，则继承RuntimeException

异常处理中，当我们捕获到异常，但本功能处理不了时，可以在catch中继续抛出：
try
{
 throw new AException();
}
catch (AException e)
{
 throw e;
}

异常处理中，如有一个方法run()抛出A异常，有一个对象t他只能处理B异常，所以我们在处理run()方法的时候可以捕获A异常然后
抛出B异常(调用者可以处理的异常)。
class A extends Exception{}
class B extends Exception{}
public class Test2
{

 public void run() throws B
 {
        try
  {
   throw new A();
  }
  catch (A e)
  {
   //处理A异常
   throw new B();
   
  }
 }

 public static void main(String[] args)
 {
  Test2 t = new Test2();
  
  try
  {
   t.run();
  }
  catch (B e)
  {
   
   e.printStackTrace();
  }

 }
}

在异常处理中，还有try-finally块的应用，finally块中存放着一定会被执行的代码，常用于关闭资源，如下
在JDBC中，java与数据库的连接conn资源及st,rs等一定要关闭：
try
{
  建立连接
 conn = DriverManager.getConnection(url,user,password);
  创建语句
 st = conn.createStatement();
  执行结果
 rs = st.executeQuery("select * from user");

}
finally
{
 if(rs!=null)
  rs.close();
 if(st!=null)
  st.close();
 if(conn!=null)
  conn.close();
}
在上面程序中，如果rs.close()处抛出了异常，那么连接conn就没有关闭，程序应改为：
finally
  {
   try
   {
    if (rs != null)
     rs.close();
   }
   finally
   {
    try
    {
     if (st != null)
      st.close();
    }
    finally
    {
     if (conn != null)
      conn.close();
    }
   }
  }
finally块只有一种情况不会执行，当程序执行到System.exit(0); finally不会执行

 

异常在子父类覆盖中的体现：
1，子类在覆盖父类时，如果父类方法抛出异常，则子类的覆盖方法只能抛出父类的异常或者是该异常的子类；
2，如果父类方法抛出多个异常，那么子类在覆盖方法时，只能抛出父类异常的子集；
3，如果父类或者接口的方法中没有抛出异常，则子类的覆盖方法也不可以抛出异常，如果子类方法发生了异常，则必须进行try处理，绝对不能抛。

异常处理补充：当调用到抛出异常的功能时，抛出几个，就处理几个，一个try对应多个catch,
如果多个catch块中的异常出现继承关系，父类的异常catch要放到最下面。
catch内，需要定义针对性的处理方式，不要简单的定义printStackTrace，输出语句等。

 

 

---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima