在本文中，我们将探讨try-catch-finally的所有可能组合，每当引发异常时都可能发生，以及每种给定情况下控制流的发生方式。

• 1. try-catch子句或try-catch-finally子句中的控制流
     • 情况1：异常发生在try块中，并在catch块中处理
     • 情况2： try块中发生异常，而catch块中未处理
     • 情况3： try-block中未发​​生异常
  2. try-finally子句
     • 情况1： try块中发生异常
     • 情况2： try-block中未发​​生异常

在try-catch或try-catch-finally中控制流

1. 异常在try块中发生，并在catch块中处理：如果try块中的语句引发异常，则try块的其余部分不执行，控制权传递给相应的catch块。执行catch块后，控制权将转移到finally块(如果存在)，然后执行其余程序。
   • 尝试捕获中的控制流：

     // Java程序展示try-catch或try-catch-finally中控制流
     class GFG
     {
         public static void main (String[] args)
         {
             // size为4的array
             int[] arr = new int[4];
             try
             {
                 int i = arr[4];
                 // 这个块没机会执行
                 System.out.println("在try内");
             }
             catch(ArrayIndexOutOfBoundsException ex)
             {
                 System.out.println("异常被捕获");
             }
             // rest program will be excuted
             System.out.println("在try-catch之外");
         }
     }

     输出：

     异常被捕获
     在try-catch之外

   • try-catch-finally子句中的控制流：

     // Java展示try-catch-finally子句中的控制流
     class GFG
     {
         public static void main (String[] args)
         {
             // size为4的array
             int[] arr = new int[4];
             try
             {
                 int i = arr[4];
                 // 这个块没机会执行
                 System.out.println("在try内");
             }
             catch(ArrayIndexOutOfBoundsException ex)
             {
                 System.out.println("在catch内的异常");
             }
             finally
             {
                 System.out.println("finally块被执行");
             }
             // 剩下的程序被执行
             System.out.println("在try-catch-finally之外");
         }
     }

     输出：

     在catch内的异常
     finally块被执行
     在try-catch-finally之外

2. 在try块中发生的异常未在catch块中处理：在这种情况下，将遵循默认的处理机制。如果finally块存在，它将执行默认的处理机制。
   • try-catch子句：

     // Java展示在try块中发生的异常未在catch块中处理
     class GFG
     {
         public static void main (String[] args)
         {
             // size为4的array
             int[] arr = new int[4];
             try
             {
                 int i = arr[4];
                 // 这个块没机会执行
                 System.out.println("在try块内");
             }
             // 非一个合适的异常handler
             catch(NullPointerException ex)
             {
                 System.out.println("异常被捕获");
             }
             // 剩下的程序被执行
             System.out.println("在try-catch之外");
         }
     }

     运行时错误：

     Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
         at GFG.main(GFG.Java:12)

   • try-catch-finally子句：

     // Java展示在try块中发生的异常未在catch块中处理
     class GFG
     {
         public static void main (String[] args)
         {
             // size为4的array
             int[] arr = new int[4];
             try
             {
                 int i = arr[4];
                 // 这个块没机会执行
                 System.out.println("在try块内");
             }
             // 非一个合适的异常handler
             catch(NullPointerException ex)
             {
                 System.out.println("异常被捕获");
             }
             finally
             {
                 System.out.println("finally被执行");
             }
             // 剩下的不会执行
             System.out.println("在try-catch-finally之外");
         }
     }

     输出：

     finally被执行
     

     运行时错误：

     Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
         at GFG.main(GFG.Java:12)

3. try块中不会发生异常：在这种情况下，catch块永远不会运行，因为它们仅在发生异常时才运行。最后，将执行块(如果存在)，然后执行其余程序。
   • try-catch子句：

     // Java展示try块中不会发生异常
     class GFG
     {
         public static void main (String[] args)
         {
             try
             {
                 String str = "123";
                 int num = Integer.parseInt(str);
                 // 下面将会被执行
                 System.out.println("在try内");
             }
             catch(NumberFormatException ex)
             {
                 System.out.println("catch块被执行...");
             }
             System.out.println("在try-catch之外");
         }
     }

     输出：

     在try内
     在try-catch之外

   • try-catch-finally子句：

     // Java展示try-catch-finally子句，try没有异常
     class GFG
     {
         public static void main (String[] args)
         {
         try
         {
             String str = "123";
             int num = Integer.parseInt(str);
             //  下面将会被执行
             System.out.println("try块全部执行");
         }
         catch(NumberFormatException ex)
         {
             System.out.println("catch块被执行...");
         }
         finally
         {
             System.out.println("finally块被执行");
         }
         System.out.println("在try-catch-finally之外");
         }
     }

     输出：

     try块全部执行
     finally块被执行
     在try-catch-finally之外

finally控制流程

在这种情况下，无论try块中是否发生异常，都将始终执行finally块。但是控制流程将取决于try块中是否发生了异常。

1. 引发异常：如果try块中发生了异常，则控制流将最终被阻止，然后是默认的异常处理机制。

   // Java展示try-finally块，异常在try内发生
   class GFG
   {
       public static void main (String[] args)
       {
           // size为4的array
           int[] arr = new int[4];
           try
           {
               int i = arr[4];
               // 这不会被执行
               System.out.println("在try内");
           }
           finally
           {
               System.out.println("finally块被执行");
           }
           // 剩下的被执行
           System.out.println("在try-finally之外");
       }
   }

   输出：

   finally块被执行
   Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
       at GFG.main(GFG.Java:11)

2. 未引发异常：如果try块中未发生异常，则控制流将最终被阻止，然后是程序的其余部分

   // Java程序，展示try-finally
   // 在try内没有发生异常
   class GFG
   {
       public static void main (String[] args)
       {
           try
           {
               String str = "123";
               int num = Integer.parseInt(str);
               // 下面的块将被执行
               System.out.println("在try内");
           }
           finally
           {
               System.out.println("finally块被执行");
           }
           // rest program will be executed
           System.out.println("在try-finally之外");
       }
   }

   输出：

   在try内
   finally块被执行
   在try-finally之外