一个try块只能有一条catch语句吗？我一直以为是一个try匹配一个catch，难道还能匹配多个？求解释，求示例

可以一个try对应多个catch。下边的例子a/b，b可能为0，报ArithmeticException；div(int a,int b)中，int[] arr=new int[a];    System.out.println(arr[3]);  a如果小于3，就报ArrayIndexOutOfBoundsException。代码如下。

1. class Demo
   
2. {
   
3.         int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException
   
4.         {
   
5.                 int[] arr=new int[a];
   
6.                 System.out.println(arr[3]);
   
7.                 return a/b;
   
8.         }
   
9. }
   
10. class ExceptionDemo
    
11. {
    
12.         public static void main(String[] args) //throws Exception
    
13.         {
    
14.                 Demo d=new Demo();
    
15.                 try
    
16.                 {
    
17.                         int res=d.div(3,2);
    
18.                         System.out.println(res);
    
19.                        
    
20.                 }
    
21.                 catch (ArithmeticException e)
    
22.                 {
    
23.                         e.printStackTrace();
    
24.                        
    
25.                 }
    
26.                 catch(ArrayIndexOutOfBoundsException e)
    
27.                 {
    
28.                         //System.exit(0);
    
29.                         System.out.println("角标越界");
    
30.                        
    
31.                 }
    
32.                 catch(Exception e)
    
33.                 {
    
34.                         e.printStackTrace();
    
35.                 }
    
36.                 finally
    
37.                 {
    
38.                         System.out.println("finally");
    
39.                 }
    
40.                
    
41.                
    
42. 
    
43.                 System.out.println("over");
    
44.         }
    
45. }
    

复制代码

可以匹配多个

大哥，你是怎么混到高级黑马的？太恐怖了！

毕向东老师第9天视频异常有讲的，你看看吧，那是最好的例子了

有几个异常，就catch几个

不是，可以处理多个异常。
try {
...
}
catch (ExceptionType1 exOb){
...
}
//可以抛出多个异常
catch (ExceptionType2 exOb){
...
}
也可以只写一个
try {
...
}
catch (Exception e){
...
}

有多少个异常就应该有多是个catch

可以把所有有问题的语句放在一try中，在会出现不同类型的异常时，每个异常都应该catch

异常的处理原则：
        1.处理方式有两种：try和throws
        2.调用到抛出异常的功能时，抛出几个，就处理几个。
                一个try对应多个catch
        3.多个catch，父类的catch放到最下面
        4.catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。
                也不要不写

比如：

1. class  ExceptionDemo1
   
2. {
   
3.         public static void main(String[] args) throws Exception
   
4.         {
   
5.                 Demo d=new Demo();
   
6.                 try
   
7.                 {
   
8.                         int x=d.div(5,0);
   
9.                         System.out.println("x="+x);
   
10.                 }
    
11.                 catch ( ArithmeticException e)
    
12.                 {
    
13.                         System.out.println(e.toString());
    
14.                         System.out.println("被零除了");
    
15.                 }
    
16.                 catch ( ArrayIndexOutOfBoundsException e)
    
17.                 {
    
18.                         System.out.println(e.toString());
    
19.                         System.out.println("角标越界");
    
20.                 }
    
21.                 /*
    
22.                 catch(Exception e)//与try匹配的处理catch
    
23.                 {
    
24.                         System.out.println("haha:"+e.toString());
    
25.                 }
    
26.                 */
    
27.                 System.out.println("over");
    
28.         }
    
29. }
    

复制代码

Cola 发表于 2013-12-31 21:54
可以一个try对应多个catch。下边的例子a/b，b可能为0，报ArithmeticException；div(int a,int b)中，int[]  ...

这个例子好经典，给个赞

love~陌 发表于 2014-1-1 11:39
异常的处理原则：
        1.处理方式有两种：try和throws
        2.调用到抛出异常的功能时，抛出几个，就处理几个。

get，谢谢

一个try可以对应多个catch，具体格式如下：
try
{
      需要被检测的代码；
}
catch（异常类  变量）
{
   处理异常的代码； （ 处理方式）
}
catch
{

}
......

浮出一个美 发表于 2013-12-31 22:10
大哥，你是怎么混到高级黑马的？太恐怖了！

呵呵，共同学习，我也在为进黑马努力，新年快乐。

一个try可以匹配多个不同类型的异常，每个异常用一个catch分别处理

这个可以是多个的，他是跟switch中的case一样的，根据不同的情况，处理相应的异常

readFile {//结构清楚，无需自己判断，代码量小。
    try {
       打开文件；  
       判断大小;　
       分配内存;　
       读入内存;
       关掉文件;   
   } catch (文件打开失败) {
       处理代码；   
   } catch (大小取不到失败) {
        处理代码;
    } catch (内存分配失败) {
        处理代码;
    } catch (读取失败) {
        处理代码;
    } catch (文件关闭失败) {
        处理代码;   
    }
}

一个try可以有多个catch，假如你不知道你的代码会有哪些错误，可以在catch中全部写上，在try中哪个有个，则catch自动会捕获你的错误并显示出来

不是，可以处理多个异常。  try {  ...  }  catch (ExceptionType1 exOb){  ...  }  //可以抛出多个异常  catch (ExceptionType2 exOb){  ...  }  也可以只写一个  try {  ...  }  catch (Exception e){  ...  }