Lanciare più eccezioni in un metodo di un'interfaccia in Java

Question

volevo chiedere che il modo di parlare di questo nel mio interfaccia

public class find(int x) throws A_Exception, B_Exception{ 
---- 
---- 
--- 
} 

voglio dire che posso menzionare Un'eccezione in un'interfaccia ma come parlare nella mia interfaccia che il mio metodo getterà Due eccezioni e cioè una e B ...

il frammento di codice di cui sopra funziona solo per a e B non per ... Aiuto

public interface dictionary{ 
    public void insert(int x) throws Dictionary_FullException, Duplicate_Element_FoundException; 
} 
... 
public class SortedArray implements dictionary{ 
    public void insert(int x) throws Dictionary_FullException, Duplicate_Element_FoundException { 
--------- 
} 

ma quando compi Le si ... si dice ..

SortedArray.java:66: inserire (int) in assign.SortedArray non può implementare inserto (int) in assign.dictionary; metodo sottoposto a override non genera assign.SortedArray.Duplicate_Element_FoundException pubblico void insert (int x) throws Dictionary_FullException

Answer 1

È possibile dichiarare il maggior numero di eccezioni come si desidera per il metodo di interfaccia. Ma la lezione che hai dato nella tua domanda non è valida. Dovrebbe essere

public class MyClass implements MyInterface { 
    public void find(int x) throws A_Exception, B_Exception{ 
    ---- 
    ---- 
    --- 
    } 
} 

Poi un'interfaccia sarebbe simile a questa

public interface MyInterface { 
    void find(int x) throws A_Exception, B_Exception; 
} 

Answer 2

È necessario specificare che sui metodi che possono gettare le eccezioni. Li si separa con un ',' se è possibile lanciare più di 1 tipo di eccezione. ad es.

public interface MyInterface { 
    public MyObject find(int x) throws MyExceptionA,MyExceptionB; 
} 

Answer 3

Penso che si sta chiedendo qualcosa come il codice qui sotto:

public interface A 
{ 
    void foo() 
     throws AException; 
} 

public class B 
    implements A 
{ 
    @Overrides 
    public void foo() 
     throws AException, 
       BException 
    { 
    } 
} 

Questo non funziona a meno che BException è una sottoclasse di AException. Quando si esegue l'override di un metodo, è necessario conformarsi alla firma fornita dal genitore e le eccezioni fanno parte della firma.

La soluzione è dichiarare che l'interfaccia genera anche una BException.

La ragione di questo è che non si desidera che il codice come:

public class Main 
{ 
    public static void main(final String[] argv) 
    { 
     A a; 

     a = new B(); 

     try 
     { 
      a.foo(); 
     } 
     catch(final AException ex) 
     { 
     } 
     // compiler will not let you write a catch BException if the A interface 
     // doesn't say that it is thrown. 
    } 
} 

Che cosa accadrebbe se B :: foo ha gettato un BException? Il programma dovrebbe uscire in quanto non ci potrebbero essere catture. Per evitare situazioni come queste classi figlie non è possibile modificare i tipi di eccezioni lanciate (tranne che possono rimuovere eccezioni dall'elenco).