1. import java.io.IOException;
   
2. public class ExceptionTest {
   
3.         public static void main(String args[]) {
   
4.                 try {
   
5.                         new ExceptionTest().methodA(5);
   
6.                 } catch (IOException e) {
   
7.                         System.out.println("caught IOException");
   
8.                 } catch (Exception e) {
   
9.                         System.out.println("caught Exception");
   
10.                 }finally{
    
11.                         System.out.println("no Exception");
    
12. 　　}
    
13.         }
    
14. 
    
15.         void methodA(int i) throws IOException {
    
16.                 if (i%2 != 0)
    
17.                         throw new IOException("methodA IOException");
    
18.         }
    
19. }

复制代码

代码的运行结果为：caught IOException  noException
代码中try块中new ExceptionTest()调用methodA()方法，
而方法本身抛出异常，它们之间的关系搞得有些混乱了
谁可以帮我理顺说明下么？

话不多说，直接代码加注释，注意，同学你写的这个处理异常的顺序是正确的，就是具体的异常写在前面，父类的异常写在后面

import java.io.IOException;
public class A {
        public static void main(String args[]) {
                try{
                        new A().methodA(5);//运行到这里时，肯定捕获IOException
                }catch(IOException e) {//这里捕获了IOException
                        System.out.println("caught IOException");//所以这里执行了
                }catch(Exception e){//因为没有其它的异常了，出现的IOException已经被前面的捕获了，到这里就没有异常了，所以不会执行这个catch代码块
                 System.out.println("caught Exception");
                }finally{//finally代码块是总是执行的代码块
                 System.out.println("finally");//所以这里当然打印了
                }
        }
        void methodA(int i) throws IOException {
                if (i%2 != 0)
                        throw new IOException("methodA IOException");//你抛出了一个IOException异常
        }
}

楼上都说的不错，既然他调用了Method()方法并且抛出了IO异常，那么后面就先捕捉到了IO异常，然后处理输出caught IOException，这样就完成了异常的捕捉，最后执行finally，自己好好理理吧

注意，处理异常的顺序是正确的，先捕获小的异常在前面，大的异常在后面



    import java.io.IOException;
    public class A {
            public static void main(String args[]) {
                    try{
                            new A().methodA(5);//运行到这里时，抛出异常：注意，只是抛出异常，但是没有处理
                    }catch(IOException e) {//捕获IOException，因为methodA(int i)继承了IOException异常，所以抛出异常
                            System.out.println("caught IOException");//处理异常，所以输出 caught IOException
                    }catch(Exception e){//IOException已经被前面的捕获了，所以不会执行这个catch代码块
                     System.out.println("caught Exception");
                    }finally{//finally代码块程序的出口
                     System.out.println("finally");//所以输出finally
                    }
            }
            void methodA(int i) throws IOException {
                    if (i%2 != 0)
                            throw new IOException("methodA IOException");//你抛出了一个IOException异常
            }
    }