第 6 章 异常处理、递归

第1章 绪论
第2章 结构化程序设计
第4章 数组、字符串、向量

• Java系列文章
• 异常处理
• • 一、介绍
  • • 什么是异常(Exception)?
    • 异常的分类
    • 常见的异常
  • 二、异常处理中五个关键字
  • • 1.范例一
    • 2.范例二
    • 3.要点
• 递归
• • 一、介绍
  • 二、实例

提示：以下是本篇文章正文内容，下面案例可供参考

异常是正常程序流程所不能处理或没有处理的异常情况或异常事件，也称为例外。

来源：
Java异常的分类和类结构图

java常见的几种异常[通俗易懂]

基础语句

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。

举个栗子，使用其中四个关键字try、catch、finally、throw

public class J_ExceptionCatch
{
    public static void main(String args[ ])
    {
        try
        {
            System.out.println("try语句块");
            throw new Exception( );    //抛出异常
        }
        catch(Exception e)    //捕捉异常
        {
            System.err.println("catch语句块");
            e.printStackTrace( );    //输出异常的类型以及异常发生的方法调用堆栈跟踪信息
        }
        finally
        {
            System.out.println("finally语句块");
        } // try-catch-finally结构结束
    } // 方法main结束
} // 类J_ExceptionCatch结束

输出结果

如图
当catch语句块能捕捉到try语句块中抛出的异常
则try-catch-finally结构之后的代码会被执行，否则不会被执行
所以上图输出了“catch语句块”及输出异常的类型以及异常发生的方法调用堆栈跟踪信息

一个除数为0导致的异常

public class J_ExceptionCatchCase {
public static void main(String[] args) {
        int a= 10;
        int b = 0;
        System.out.println("a=" + a);
        System.out.println("b=" + b);
        try
           {        
                 System.out.println("try语句块");
                if(b==0)   
                     throw new ArithmeticException(“除数不能为0”);   //抛出异常
                else     
                      System.out.println("a/b=" + a/b);
           }
        catch(ArithmeticException e)      //捕捉异常
          {
            System.out.println("catch语句块");
            System.out.println(e);  // 输出异常信息
          }
        finally
         { 
            System.out.println("finally语句块");
         } // try-catch-finally结构结束
    }
}

输出结果

public class J_Test {
 public static void mb_createException() {
     throw new ArrayIndexOutOfBoundsException();
     }
 public static void mb_method() 
    {
        try
           { 
               mb_createException();  //方法调用后，抛出一个数组下标越界异常
               System.out.print("a");
           }
         catch(ArithmeticException e)  //没有捕获到数组下标越界异常
          { 
             System.err.print("b");  
           }
         finally
           {
             System.out.print("c");
           }
         System.out.print(“d”);  //上面未捕获到异常，这里不输出
  }
 public static void main(String[] args) {
    try
     { 
         mb_method();
     }
    catch(Exception e)   //捕获到抛出的数组下标越界异常
    { 
         System.err.print('m');
    }
     System.out.print(‘n’); //上面捕获到异常，这里会输出
  }
}

读者可以自己运行该类，看看输出与自己预期的是否一致
若不一致，则再仔细阅读上方要点

如果在方法定义中直接或间接地调用该方法本身，就称为递归。

利用递归求解问题的基本思路：
（1）将要求解的原问题分解成规模较小的同类问题；
（2）将利用递归求解原问题转变成在分解之后产生的小规模同类问题上进行求解。

问题范例

问题：求某个整数的Fibonacci数。
Fibonacci数的定义如下：
Fibonacci(1)=1;
Fibonacci(2)=1;
Fibonacci(3)=Fibonacci(2)+Fibonacci(1);
………
Fibonacci(n)=Fibonacci(n-1)+Fibonacci(n-2); //n为大于2的整数

解决

public class J_Fibonacci
{
    public static int mb_fibonacci(int n)
    {
        if (n< 1)
            return(0);
        else if (n==1 || n==2)
            return(1);
        return(mb_fibonacci(n-1)+mb_fibonacci(n-2));
    } // 方法mb_fibonacci结束

    public static void main(String args[ ])
    {
        int n = 30;
        System.out.println("Fibonacci(" + n + ")=" + mb_fibonacci(n));
    } // 方法main结束
} // 类J_Fibonacci结束