如果父类中方法没有定义异常，子类重写的方法中产生了异常，那么子类中是否可以抛出异常？

不可以，
异常在子父类中覆盖的体现：
        1：子类在重写父类中的方法时，如果父类方法抛出异常，子类中重写的方法，只能抛出父类的异常或者该异常的子类异常

  2：如果父类方法抛出多个异常，那么子类再覆盖该方法时，只能抛出父类异常的子集
        3：如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常
           如果子类方法发生了异常，就必须要进行try处理，绝对不能抛

so sorry按了tab+回车，所以搞成了两部分

1. class F{
   
2.        
   
3.         public F(){}
   
4.        
   
5.         public void run(){        }
   
6. }
   
7. 
   
8. 
   
9. class Child extends F{
   
10.        
    
11.         public Child(){}
    
12. 
    
13. /*
    
14.         @Override
    
15.         public void run() throws Exception  {        //这样不行
    
16.                 super.run();
    
17.                 throw new Exception();
    
18.                
    
19.         }
    
20. */
    
21. /*       
    
22.         @Override
    
23.         public void run()   {        //这样可以
    
24.                 super.run();
    
25.                 try {
    
26.                         throw new Exception();
    
27.                 } catch (Exception e) {
    
28.                         // TODO Auto-generated catch block
    
29.                         e.printStackTrace();
    
30.                 }
    
31.                
    
32.         }
    
33. */
    
34.         @Override
    
35.         public void run()   {        //这样可以
    
36.                 super.run();
    
37.                 throw new RuntimeException();
    
38.         }
    
39. }
    

复制代码

你可以自己测试下

在java 中，当我们子类要重写父类中的方法，如果父类的方法有异常声明，那么子类重写这个方法时候，所要声明的异常不应该比父类的大。只能是小于等于，或者没有。
//假如我们自定意义一个异常：
public class MyException extends Exception {
public MyException(String message) {

}
public MyException() {

}
}

//那么我们有一个父类它将有一个方法，将声明抛出这个异常。我们把它做成抽象的（无所谓）
public abstract class ParentException {
public abstract void test() throws MyException;
}
//那么将有一个类使用到上面这个类
public class ExceptionTest {
private ParentException exception;
public ExceptionTest(ParentException exception){
this.exception=exception;
}
public void app(){
try {
exception.test();
} catch (MyException e) {
e.printStackTrace();
}
}
}
//对于以上的try~catch 我们就直接捕获MyException异常。这是正确的，它在编译的时候是没有问题的。
//假如，有一个ParentException的有一个子类
public class ChildException extends ParentException{
public void test() throws Exception{

}
}
//他的方法可以声明抛出比父类大的异常，假如它是正确的。
//那么问题来了。当我们执行ExceptionTest类的时候，我们以这个子类做为对象传进去。
//exception.test();这个地方将在运行的时候实际调用的是ChildException这个子类的test()方法，而它的声明抛 出却是比父类大的异常，这就使得ExceptionTest类中，捕获异常处出现了毛病，因为它无法捕获Exception异常。
//综上所诉，子类重写父类的方法时候不能声明抛出比父类大的异常

不能抛出比父类更多的异常，也不能抛出比父类的异常更大的异常