class Demo
{        
        public static void func()
        {
                try
                {
                        throw  new Exception();
                                                
                                                
                }
                finally
                {
                        System.out.println("B");
                }
        }
        public static void main(String[] args)
        {
                try
                {
                        func();
                        System.out.println("A");
                }
                catch(Exception e)
                {
                        System.out.println("C");
                }
                System.out.println("D");
        }
}

class Demo
{        
        public static void func() throws Exception//因为你程序没有处理掉这个异常，所以你还得往外抛
        {
                try
                {
                        throw  new Exception();
                                                
                                                
                }
                finally
                {
                        System.out.println("B");
                }
        }
        public static void main(String[] args)
        {
                try
                {
                        func();
                        System.out.println("A");
                }
                catch(Exception e)
                {
                        System.out.println("C");
                }
                System.out.println("D");
        }
}

楼主你在func()方法没有进行抛

1. package com.ctj.www;
   
2. 
   
3. public class Democ {
   
4.         public static void func()throws Exception{
   
5.                 try{
   
6.                         throw new Exception();
   
7.                 }
   
8.                 finally{
   
9.                         System.out.println("B");
   
10.                 }
    
11.         }
    
12.         public static void main(String[] args) {
    
13.                 try{
    
14.                         func();
    
15.                         System.out.println("A");
    
16.                 }
    
17.                 catch(Exception e){
    
18.                         System.out.println("C");
    
19.                 }
    
20.                 System.out.println("D");
    
21.         }
    
22. }
    

复制代码

修改后的代码：
class Demo
{        
        public static void func() throws Exception
        {
                try
                {
                        throw  new Exception();            
                }
                finally
                {
                        System.out.println("B");
                }
        }
        public static void main(String[] args)
        {
                try
                {
                        func();
                        System.out.println("A");
                }
                catch(Exception e)
                {
                        System.out.println("C");
                }
                System.out.println("D");
        }
}
分析：当主函数运行func()时，此函数边抛出一个异常Exception，因此就必须在函数上对其进行声明。此时编译通过。
进入finally块输出B，同时主函数中的catch块捕捉到这个异常，并处理输出C，接着输出D；
于是结果是：
B
C
D

class Demo
{      
        public static void func() throws Exception()      //在此处 声明
        {
                try
                {
                        throw  new Exception();      //此处的异常没有捕捉就需要在函数上进行声明
                                               
                                               
                }
                finally
                {
                        System.out.println("B");
                }
        }

1. class Test9
   
2. {
   
3. public static void func()
   
4. {
   
5. try
   
6. {
   
7. try {
   
8. throw new Exception();
   
9. catch (Exception e) {
   
10. 
    
11. e.printStackTrace();
    
12. }
    
13. 
    
14. }
    
15. finally
    
16. {
    
17. System.out.println("B");
    
18. }
    
19. }
    
20. public static void main(String[] args)
    
21. {
    
22. try
    
23. {
    
24. func();
    
25. System.out.println("A");
    
26. }
    
27. catch(Exception e)
    
28. {
    
29. System.out.println("C");
    
30. }
    
31. System.out.println("D");
    
32. }
    
33. 
    
34. 
    
35. }

复制代码

如果你把异常捕获掉 ，那么抛出的肯定是异常  且输出的是   B   A    D

1. class Test9
   
2. {
   
3. public static void func()   throws Exception
   
4. {
   
5. try
   
6. {
   
7. 
   
8. throw new Exception();
   
9. 
   
10. 
    
11. }
    
12. finally
    
13. {
    
14. System.out.println("B");
    
15. }
    
16. }
    
17. public static void main(String[] args)
    
18. {
    
19. try
    
20. {
    
21. func();
    
22. System.out.println("A");
    
23. }
    
24. catch(Exception e)
    
25. {
    
26. System.out.println("C");
    
27. }
    
28. System.out.println("D");
    
29. }
    
30. 
    
31. 
    

复制代码

如果您把异常抛出就没事了   因为异常类中抛出了异常 所以创建异常对象的时候必须抛出异常或者捕获    且输出的是 B  C  D

1. package A;
   
2. class Demo
   
3. {        
   
4.         public static void func() throws Exception    //在这里抛出一下就可以了
   
5.         {
   
6.                 try
   
7.                 {
   
8.                   throw  new Exception();  //在没有修改之前  这里提示错误  未处理的异常类型Exception
   
9.                                                 
   
10.                                                 
    
11.                 }
    
12.                 finally
    
13.                 {
    
14.                         System.out.println("B");
    
15.                 }
    
16.         }
    
17.         public static void main(String[] args)
    
18.         {
    
19.                 try
    
20.                 {
    
21.                         func();
    
22.                         System.out.println("A");
    
23.                 }
    
24.                 catch(Exception e)
    
25.                 {
    
26.                         System.out.println("C");
    
27.                 }
    
28.                 System.out.println("D");
    
29.         }
    
30. }

复制代码

func中的try块抛出了异常throw  new Exception();   抛出异常却没有处理异常，所以在编译的时候出错。

胡帅冰 发表于 2013-3-30 22:59
func中的try块抛出了异常throw  new Exception();   抛出异常却没有处理异常，所以在编译的时候出错。 ...

class Demo
{        
        public static void func() throws Exception
        {
                try
                {
                        throw  new Exception();
                                                
                                                
                }
                finally
                {
                        System.out.println("B");
                }
        }
        public static void main(String[] args)
        {
                try
                {
                        func();
                        System.out.println("A");
                }
                catch(Exception e)
                {
                        System.out.println("C");
                }
                System.out.println("D");
        }
}

你上面的try抛出了一个异常,你是准备把这个异常抛给谁那?没有表示出抛给谁,怎么去处理那?

class MyDemo
{        
        public static void func()//throws Exception 方法一：方法中如果抛出了一个异常，而且是编译时异常，方法上必须声明。
        {
                try  {
                        throw  new Exception();  // throw new RuntimeException     方法二：如果方法上不声明的话，可以在此抛一个运行时异常。                                                      
                }
                finally{
                        System.out.println("B");
                }
        }
        public static void main(String[] args){
                try{
                        func();
                        System.out.println("A");
                }
                catch(Exception e) {
                        System.out.println("C");
                }
                System.out.println("D");
        }
}

两种方式都可以，希望对你有帮助。