为什么一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类？

其实理解这个很简单，比如说宪法规定骂人只承担民事责任，到了刑法里就不能说直接枪毙了，这就是一个约束能力的问题，子类行为不能超出父类约束范畴。否者就容易乱套。就像父类的某方法公有的，子类就不能重写改成私有的了。这就是一个约束力的问题。

子类继承父类的同时也继承了父类可能出现的异常，所以要抛出相同的异常或者该异常的子类异常

Java异常处理：

（1） 如果重新一个方法，需要抛出与它原方法完全相同的异常或者不抛异常（这是一条规则，必须记住,除了这两种情况其他的都不允许）

（2） 如果父类抛出多个异常，那么覆盖方法必须抛出那些异常的一个子集，也就是说，不能抛出新的异常。

种生祥 发表于 2013-1-22 17:05
子类继承父类的同时也继承了父类可能出现的异常，所以要抛出相同的异常或者该异常的子类异常 ...

楼上的回答好像不正确，我记得是只能抛出相同的异常或者不抛异常
除了这两种情况，其他的都不允许的呀

也可以不抛出异常  需要抛出异常的话 得抛出父类方法的异常或其异常的子类
public class yichang {

        /**
         * @param args
         * @throws Exception
         */
        public static void main(String[] args) throws Exception {
                // TODO Auto-generated method stub
                A a = new Son();
                a.a();//用多态方式调用  需处理异常
                Son b = new Son();
                b.a();//此处不需要
        }

}
class A
{
        public void a()throws Exception
        {
                System.out.println("aaaa");
        }
}
class Son extends A
{
        public void a()//这里没有抛出异常
        {
                System.out.println("bbbbb");
        }
}

给你看一段代码吧

1. abstract class Shape {                //定义一个几何图形抽象类，
   
2.          public abstract int getArea() throws MyException2;                        //声明一个计算面积的抽象方法
   
3. }
   
4. 
   
5. class Rectangle extends Shape {                //定义一个矩形类
   
6.        
   
7.         private int len, width;
   
8.        
   
9.         public Rectangle(int len,int width) {
   
10.                 this.len = len;
    
11.                 this.width = width;
    
12.         }
    
13.         public int getArea() throws MyException2 {                //重写父类的抽象方法
    
14.                
    
15.                 if(len <= 0 | width <= 0) {
    
16.                         throw new MyException2("输入的数据错误");
    
17.                 } else {
    
18.                         return len*width;
    
19.                 }
    
20.         }
    
21. }

复制代码

1.父类方法抛异常，子类覆盖他时只能抛该异常或该异常的子类，否则编译无法通过。

2.父类方法没有抛任何异常时，子类也不能抛，只能在本方法中用try.....catch语句捕捉。

1. 类如：public class Test2{
   
2. public static void main(
   
3. String[] args)throws Exception{ C c = new C(); c.test();
   
4. }
   
5. }
   
6. interface A{
   
7. public void test()throws ArithmeticException;
   
8. }
   
9. class B{
   
10. public void test()throws IllegalArgumentException{ System.out.println("B.test");
    
11. }
    
12. }
    
13. class C extends B implements A{
    
14. @Override
    
15. public void test()throws ArithmeticException{
    
16. System.out.println("C.test");
    
17. }
    
18. }

复制代码

这样的话编译时和运行时都不会报错！也就是说，如果接口和基类抛出的都是运行时异常，那么子类覆盖了后不管抛出的是接口的异常还是基类的异常都不会报错！坦白说：           父类方法如果抛出的是运行时异常或者不抛异常 子类抛出的是其它运行时异常 编译器也不能限定它 编译也能成功的！如果父类抛出的是ClassNotFoundException这样的非运行时异常，那么子类抛的是别的异常的话，肯定会报错！

子类异常属于子集吧，而且应该分运行时异常和编译时异常

因为Java异常强制我们去考虑程序的强健性和安全性,所以覆盖了父类的方法也就必须去解决或抛出. 异常处理不应用来控制程序的正常流程。异常处理的主要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码时处理某个方法可能出现的异常

定义抛出异常类，是标识该方法可能会出现因不正当调用而出现的异常，以便加以捕捉处理异常，