Czy można powiedzieć kompilatorowi, że metoda zawsze generuje wyjątek

Question

Ogólnie rzecz biorąc, kompilator Java nie propaguje informacji, że metoda "zawsze" zgłasza wyjątek, a zatem nie wykrywa, że ​​wszystkie ścieżki kodu są kompletne .

(Wynika to z faktu, że kompilator Java kompiluje każdą klasę niezależnie).

To jest problem, gdy chcesz napisać coś takiego.

public class ErrorContext { 
    public void fatalISE(String message) { 
     String context = "gather lots of information about the context of the error"; 
     throw new IllegalStateException(context +": " + message); 
    } 
} 

public class A { 
    public MyObject myMethod() { 
     if (allIsGood()) { 
      return new MyObject(); 
     } 
     ErrorContext.fatalISE("all is not good"); 
    } 
} 

(tj. Rodzaj "pomocnika potwierdzającego", który zbiera informacje kontekstowe).

Ponieważ kompilator będzie narzekał, że myMethod nie zawsze zwraca obiekt MyObject.

Według mojej wiedzy nie ma adnotacji, która wskazywałaby, że metoda zawsze rzuca.

Answer 1

Prostym rozwiązaniem jest pozwolić wasz nie metoda fatalISErzucać wyjątek, ale tylko go utworzyć:

public class ErrorContext { 
    public IllegalStateException fatalISE(String message) { 
     String context = "gather lots of information about the context of the error"; 
     return new IllegalStateException(context +": " + message); 
    } 
} 

public class A { 
    public MyObject myMethod() { 
     if (allIsGood()) { 
      return new MyObject(); 
     } 
     throw ErrorContext.fatalISE("all is not good"); 
    } 
} 

ten sposób kompilator będzie wiedział nie narzekać brakującym return. Zapomnienie o użyciu throw jest mało prawdopodobne, właśnie dlatego, że kompilator zwykle narzeka.

Answer 2

Sztuczka, że ​​używam jest zastąpienie

public void fatalISE(String message) { 
    String context = "gather lots of information about the context of the error"; 
    throw new IllegalStateException(context +": " + message); 
} 

z

public <T> T fatalISE(String message) { 
    String context = "gather lots of information about the context of the error"; 
    throw new IllegalStateException(context +": " + message); 
} 

Następnie w myMethod, użytkowania:

public MyObject myMethod() { 
    if (allIsGood()) { 
     return new MyObject(); 
    } 
    return ErrorContext.fatalISE("all is not good"); 
} 

To będzie działać niezależnie od typu zwracanej myMethod , w tym typy pierwotne. Wciąż możesz używać fatalISE w metodzie void, po prostu nie używając słowa kluczowego return.

Answer 3

dodać

return null; 

na końcu. (i tak nigdy nie dojdzie do tego, ale żeby uciszyć kompilator powinien to zrobić)

Answer 4

Co powiesz na cofnięcie warunku if?

public MyObject myMethod() { 
    if (!allIsGood()) { 
     ErrorContext.fatalISE("all is not good"); 
    } 
    return new MyObject(); 
} 

Powodzenia!

Answer 5

Właśnie natknąłem się na ten przypadek użycia, ale z metodą, która powinna zawsze wyrzucać 2 lub więcej typów wyjątków.

Aby kod został skompilowany, można dodać return null; jako MouseEvent.

lub lepiej zastąpić go throw new AssertionError() które uniemożliwiają powrót wartość null, poprawiają czytelność i upewnić się, że jeśli ktoś zmodyfikować checkAndAlwaysThrowException() wil nadal Zawsze rzutów wyjątkiem

public Object myMehtod() throws ExceptionType1, ExceptionType2 { 
    //.... 
    checkAndAlwaysThrowException(); 
    throw new AssertionError("checkAndAlwaysThrowException should have throw exception"); 
} 

public void checkAndAlwaysThrowException() throws ExceptionType1, ExceptionType2 { 
    if (cond) { 
     throw new ExceptionType1(); 
    } else { 
     throw new ExceptionType2(); 
    } 
}