Quali sono i criteri per il lancio di eccezioni nella sottoclasse

Question

Quello che ho saputo fino ad ora è che una sottoclasse se si sostituisce un metodo di superclasse dovrebbe generare la stessa eccezione o una sottoclasse dell'eccezione.

Ad esempio:

questo è corretto

class SuperClass { 
    public int doIt(String str, Integer... data)throws ArrayIndexOutOfBoundsException{ 
String signature = "(String, Integer[])"; 
System.out.println(str + " " + signature); 
return 1; 
} 
} 

public final class SubClass extends SuperClass { 
    public int doIt(String str, Integer... data) throws ArrayIndexOutOfBoundsException { 
     String signature = "(String, Integer[])"; 
     System.out.println("Overridden: " + str + " " + signature); 
     return 0; 
    } 

    public static void main(String... args) { 
     SuperClass sb = new SubClass(); 
     try { 
      sb.doIt("hello", 3); 
     } catch (Exception e) { 
     } 
    } 
} 

questo non è corretto

class SuperClass { 
    public int doIt(String str, Integer... data)throws ArrayIndexOutOfBoundsException{ 
String signature = "(String, Integer[])"; 
System.out.println(str + " " + signature); 
return 1; 
} 
} 

public final class SubClass extends SuperClass { 
    public int doIt(String str, Integer... data) throws Exception { 
     String signature = "(String, Integer[])"; 
     System.out.println("Overridden: " + str + " " + signature); 
     return 0; 
    } 

    public static void main(String... args) { 
     SuperClass sb = new SubClass(); 
     try { 
      sb.doIt("hello", 3); 
     } catch (Exception e) { 
     } 
    } 
} 

Ma la mia domanda è, perché questo blocco di codice viene considerata corretta dal compilatore ?

class SuperClass { 
    public int doIt(String str, Integer... data)throws ArrayIndexOutOfBoundsException{ 
String signature = "(String, Integer[])"; 
System.out.println(str + " " + signature); 
return 1; 
} 
} 

public final class SubClass extends SuperClass { 
    public int doIt(String str, Integer... data) throws RuntimeException { 
     String signature = "(String, Integer[])"; 
     System.out.println("Overridden: " + str + " " + signature); 
     return 0; 
    } 

    public static void main(String... args) { 
     SuperClass sb = new SubClass(); 
     try { 
      sb.doIt("hello", 3); 
     } catch (Exception e) { 
     } 
    } 
} 

Answer 1

Questo perché in Java ogni metodo può lanciare una RuntimeException (o un Error) in qualsiasi momento. Non è nemmeno necessario dichiararlo nella parte throws della firma del metodo. Quindi è possibile anche lanciare un'eccezione che è un tipo super di quello dichiarato nel metodo sovrascritto, purché sia ​​ancora un sottotipo di RuntimeException.

Vedere Chapter 11 (Exceptions) of the Java Language Specification per la specifica di questo comportamento, in particolare 11.1.1. The Kinds of Exceptions che definisce controllato (deve essere specificato nella clausola throws) e incontrollati (non ha bisogno di essere specificati in throws clausola) eccezioni.

Answer 2

Quando si esegue l'override un metodo, è necessario definire le stesse eccezioni controllate. In questo caso, il metodo SuperClass#doIt dichiara che genera un ArrayIndexOutOfBoundsException, quindi ogni bambino che esegue l'override di quel metodo deve dichiarare le stesse eccezioni controllate o le sue sottoclassi.

Maggiori informazioni:

• Method overriding and exceptions.

Answer 3

di fare un tentativo per rendere più semplice, RuntimeException e Error non hanno bisogno di essere dichiarati in throws clausole, ma sono sempre implicita. Se si includono le eccezioni implicite nella dichiarazione, è possibile scrivere la dichiarazione del metodo superclasse;

public int doIt(String str, Integer... data) 
    throws ArrayIndexOutOfBoundsException, Error, RuntimeException { 

Ciò significa, la dichiarazione esplicita RuntimeException sul metodo della sottoclasse è una sottoclasse di un (implicito) eccezione esistente sul metodo della superclasse, quindi è permesso.

Answer 4

Se il metodo super-classe non dichiara alcuna eccezione, quindi sub classe metodo sottoposto a override non può dichiarare "controllato" eccezione ma può dichiarare eccezioni "incontrollato"