现有如下代码：
class Main {
public static void main(String[] args) {
  try {
  FenShu fs1=new FenShu(4,0);
  FenShu fs2=new FenShu(5,0);
  FenShu result=fs1.cheng(fs2);
  String s=result.getString();
   System.out.println("乘运算后="+s);
  FenShu result1=fs1.chu(fs2);
  String s1=result1.getString();
   System.out.println("除法运算后="+s1);
  FenShu result2=fs1.jia(fs2);
  String s2=result2.getString();
   System.out.println("加法运算后="+s2);
  FenShu result3=fs1.jian(fs2);
  String s3=result3.getString();
   System.out.println("减法运算后="+s3);
   
  } catch (ArithmeticException e) {
   System.out.println("分数分母为零不能运算");
   System.out.println(e.getMessage());
   e.printStackTrace();
  }
   }
  
  
}
public class FenShu {
private int fz;
private int fm;

public FenShu() {}

public FenShu(int fz, int fm) {
  this.fz = fz;
  this.fm = fm;
  yueFen(fz,fm);
}
public void yueFen(int f1, int f2){
  int x = f1;
  int y = f2;
   if(x < y){
    int t;
    t = x;
    x = y;
    y = t;
   }
    int n = x % y;
     while(n!=0){
      x = y;
      y = n;
      n = x % y;
        }
                  this.fz /= y;
                  this.fm /= y;
    }
public FenShu jia(FenShu fs) {
  int zi=this.fz*fs.fm+fs.fz*this.fm;
  int mu=this.fm*fs.fm;
  return new FenShu(zi,mu);
}

public FenShu jian(FenShu fs) {
  int zi=this.fz*fs.fm-fs.fz*this.fm;
  int mu=this.fm*fs.fm;
  return new FenShu(zi,mu);

}

public FenShu cheng(FenShu fs) {
  int zi = this.fz * fs.fz;
  int mu = this.fm * fs.fm;
  return new FenShu(zi, mu);
}

public FenShu chu(FenShu fs) {
  int zi =this.fz*fs.fm;
  int mu =this.fm*fs.fz;
  return new FenShu(zi,mu);

}

public double doubleValue() {
  return fz / fm;
}

public String getString() {
  return fz + "/" + fm;
}
}
该代码用来计算两个分数的加、减、乘、除，在该代码中，如果两个分数分母同时为0，控制台只能发现第一个分母为零的位置，请问如何使用多异常发现两处都为零的情况下的各个位置，并声明如何处理？

求解答，送金钱，，，

哎 我给看下吧

呜 我只能说是java异常机制如此,普通有被定义的异常发现后就不会继续运行下去,而是交给异常机制进行处理,那么可想而知,代码的道路就变了.

呜 一般在处理这样的定义问题时,我的习惯是在内部就规范好 比如这个分母不为零,因为对分数的规范是:分母不能为零的，那么就会对录入数据进行判断 如果分母为零就直接跳出请重新输入这类 不会让程序继续运行下去 ----对可以预知的程序进行合理的判断并操作

推荐还是定义规范 因为一旦程序报错基本就直接中止了，那么后面的代码就没用了，除非全放进catch块里。。不过那就颠覆了异常机制的初衷:于主程序分开 不参杂在代码编译里。。

这样修改一下，就两个都能打印出来了！

1. public class Main {
   
2.         public static void main(String[] args) {
   
3.                 try {
   
4.                         
   
5.                         FenShu fs1=new FenShu(4,0);
   
6.                         FenShu fs2=new FenShu(5,0);
   
7.                         FenShu result=fs1.cheng(fs2);
   
8.                         String s=result.getString();
   
9.                         System.out.println("乘运算后="+s);
   
10.                         FenShu result1=fs1.chu(fs2);
    
11.                         String s1=result1.getString();
    
12.                         System.out.println("除法运算后="+s1);
    
13.                         FenShu result2=fs1.jia(fs2);
    
14.                         String s2=result2.getString();
    
15.                         System.out.println("加法运算后="+s2);
    
16.                         FenShu result3=fs1.jian(fs2);
    
17.                         String s3=result3.getString();
    
18.                         System.out.println("减法运算后="+s3);
    
19.    
    
20.                 } catch (ArithmeticException e) {
    
21.                         System.out.println("分数分母为零不能运算");
    
22.                         System.out.println(e.getMessage());
    
23.                         
    
24.                       <FONT color=red>  //这儿修改一下，就两个都打印出来了
    
25.                         try {
    
26.                                 FenShu fs2=new FenShu(5,0);
    
27.                         } catch (Exception e1) {
    
28.                                 // TODO Auto-generated catch block
    
29.                                 e1.printStackTrace();
    
30.                         }
    
31. </FONT>                        e.printStackTrace();
    
32.                 }
    
33.         }
    
34. 
    
35. }
    
36. 
    
37. //声明一个分数类
    
38. class FenShu {
    
39.         
    
40.         //定义分子、分母两个int型变量
    
41.         private int fz;
    
42.         private int fm;
    
43. 
    
44.         //构造方法
    
45.         public FenShu() {}
    
46.         
    
47.         //方法重载
    
48.         public FenShu(int fz, int fm) {
    
49.                 this.fz = fz;
    
50.                 this.fm = fm;
    
51.                         yueFen(fz,fm);
    
52.         }
    
53.         
    
54.         //对分子、分母进行约分
    
55.         public void yueFen(int f1, int f2){
    
56.                 int x = f1;
    
57.                 int y = f2;
    
58.                 if(x < y){
    
59.                         int t;
    
60.                         t = x;
    
61.                         x = y;
    
62.                         y = t;
    
63.                 }
    
64.                 int n = x % y;
    
65.                 while(n!=0){
    
66.                         x = y;
    
67.                         y = n;
    
68.                         n = x % y;
    
69.                 }
    
70.                 this.fz /= y;
    
71.                 this.fm /= y;
    
72.         }
    
73.         
    
74.         //对分数进行加、减、乘、除四则运算
    
75.         public FenShu jia(FenShu fs) {
    
76.                 int zi=this.fz*fs.fm+fs.fz*this.fm;
    
77.                 int mu=this.fm*fs.fm;
    
78.                 return new FenShu(zi,mu);
    
79.         }
    
80. 
    
81.         public FenShu jian(FenShu fs) {
    
82.                 int zi=this.fz*fs.fm-fs.fz*this.fm;
    
83.                 int mu=this.fm*fs.fm;
    
84.                 return new FenShu(zi,mu);
    
85. 
    
86.         }
    
87. 
    
88.         public FenShu cheng(FenShu fs) {
    
89.                 int zi = this.fz * fs.fz;
    
90.                 int mu = this.fm * fs.fm;
    
91.                 return new FenShu(zi, mu);
    
92.         }
    
93. 
    
94.         public FenShu chu(FenShu fs) {
    
95.                 int zi =this.fz*fs.fm;
    
96.                 int mu =this.fm*fs.fz;
    
97.                 return new FenShu(zi,mu);
    
98. 
    
99.         }
    
100. 
     
101.         public double doubleValue() {
     
102.                 return fz / fm;
     
103.                 }
     
104. 
     
105.         public String getString() {
     
106.                 return fz + "/" + fm;
     
107.         }
     
108. }
     

复制代码

又是老问题了。。就像thinking in java作者和java 之父 。。争论的。
老实说。刚开始我还喜欢异常，，后面发现，，异常多了。整个代码块非常难看。
而且很多异常其实都该用运行时异常。 我支持spring作者的观点。

至于你这个。。因为java的异常机制就是这样。你要一个一个的排除才可以。但如果实在要想这样。

你可以试下。再finally{}里面。再放你要抓的东西。。看看结果。

我刚才测试了下，代码如下：

        public static void main(String[] args) {
                try{
                        int []arr=new int[3];
                     System.out.println(arr[5]);
                }catch(Exception e){
                        e.printStackTrace();
                }
                finally{
                        try{
                                int a=3/0;
                              System.out.println(a);
                        }catch(Exception e){
                                e.printStackTrace();
                        }
                     
                }
       
        }
输出结果：
java.lang.ArrayIndexOutOfBoundsException: 5
        at basic.program.test.SDFSFS.main(SDFSFS.java:11)
java.lang.ArithmeticException: / by zero
        at basic.program.test.SDFSFS.main(SDFSFS.java:17)

这样貌似就能抓2个异常了。。不过结构难看，特别是代码多了。
不建议这样用。。如果你还要同时抓3个以上。这代码阅读性很不好了。。

陈军 发表于 2012-11-12 08:57
又是老问题了。。就像thinking in java作者和java 之父 。。争论的。
老实说。刚开始我还喜欢异常，，后面 ...

谢谢 ！我懂了！