Java教程-Java中的方法重写与异常处理

Java中的方法重写与异常处理

如果我们谈论使用异常处理进行方法重写，有许多规则需要遵守。

以下是其中一些规则：

• 如果超类方法未声明异常

  • 如果超类方法未声明异常，则子类重写方法不能声明已检查异常，但可以声明未检查异常。

• 如果超类方法声明异常

  • 如果超类方法声明异常，则子类重写方法可以声明相同的异常、子类异常或不声明异常，但不能声明父类异常。

如果超类方法未声明异常

规则1：如果超类方法未声明异常，则子类重写方法不能声明已检查异常。

让我们根据上述规则考虑以下示例。

TestExceptionChild.java

import java.io.*;    
class Parent{   
  
  //定义方法     
  void msg() {  
    System.out.println("parent method");  
    }    
}    
    
public class TestExceptionChild extends Parent{    
  
  // 重写子类中的方法
  // 给出编译时错误  
  void msg() throws IOException {    
    System.out.println("TestExceptionChild");    
  }  
  
  public static void main(String args[]) {    
   Parent p = new TestExceptionChild();    
   p.msg();    
  }    
}    

输出：

规则2：如果超类方法未声明异常，则子类重写方法不能声明已检查异常，但可以声明未检查异常。

TestExceptionChild1.java

import java.io.*;    
class Parent{    
  void msg() {  
    System.out.println("parent method");  
  }    
}    
    
class TestExceptionChild1 extends Parent{    
  void msg()throws ArithmeticException {    
    System.out.println("child method");    
  }    
  
  public static void main(String args[]) {    
   Parent p = new TestExceptionChild1();    
   p.msg();    
  }    
}   

输出：

如果超类方法声明异常

规则1：如果超类方法声明异常，则子类重写方法可以声明相同的子类异常或不声明异常，但不能声明父类异常。

示例：子类重写方法声明父类异常

TestExceptionChild2.java

import java.io.*;    
class Parent{    
  void msg()throws ArithmeticException {  
    System.out.println("parent method");  
  }    
}    
    
public class TestExceptionChild2 extends Parent{    
  void msg()throws Exception {  
    System.out.println("child method");  
  }    
    
  public static void main(String args[]) {    
   Parent p = new TestExceptionChild2();    
     
   try {    
   p.msg();    
   }  
   catch (Exception e){}   
  
  }    
}     

输出：

示例：子类重写方法声明相同异常

TestExceptionChild3.java

import java.io.*;    
class Parent{    
  void msg() throws Exception {  
    System.out.println("parent method");  
  }    
}    
    
public class TestExceptionChild3 extends Parent {    
  void msg()throws Exception {  
    System.out.println("child method");  
  }    
    
  public static void main(String args[]){    
   Parent p = new TestExceptionChild3();    
     
   try {    
   p.msg();    
   }  
   catch(Exception e) {}    
  }    
}    

输出：

示例：子类重写方法声明子类异常

TestExceptionChild4.java

import java.io.*;    
class Parent{    
  void msg()throws Exception {  
    System.out.println("parent method");  
  }    
}    
    
class TestExceptionChild4 extends Parent{    
  void msg()throws ArithmeticException {  
    System.out.println("child method");  
  }    
    
  public static void main(String args[]){    
   Parent p = new TestExceptionChild4();    
     
   try {    
   p.msg();    
   }  
   catch(Exception e) {}    
  }    
}    

输出：

示例：子类重写方法不声明异常

TestExceptionChild5.java

import java.io.*;    
class Parent {    
  void msg()throws Exception{  
    System.out.println("parent method");  
  }    
}    
    
class TestExceptionChild5 extends Parent{    
  void msg() {  
    System.out.println("child method");  
  }    
    
  public static void main(String args[]){    
   Parent p = new TestExceptionChild5();    
     
   try {    
   p.msg();    
   }  
   catch(Exception e) {}  
       
  }    
}     

输出：