我有以下情况。
我有一个继承自另一个基类并覆盖方法的 Java 类。
基本方法不会抛出异常，因此没有throws ... 声明。
现在我自己的方法应该能够抛出异常，但我可以选择任一方法
两者都不令人满意，因为第一个会默默地忽略异常（好吧，我可以执行一些日志记录），第二个会因为不同的方法头而产生编译器错误。
public class ChildClass extends BaseClass {
@Override
public void SomeMethod() {
throw new Exception("Something went wrong");
}
}
【问题讨论】：
如果你真的想的话，你可以抛出未经检查的异常而不必声明它们。未经检查的异常扩展RuntimeException。扩展 Error 的 Throwable 也未选中，但只能用于完全无法处理的问题（例如无效的字节码或内存不足）。
作为一个具体案例，Java 8 添加了UncheckedIOException 用于包装和重新抛出IOException。
【讨论】：
这里有一个技巧：
class Utils
{
@SuppressWarnings("unchecked")
private static <T extends Throwable> void throwException(Throwable exception, Object dummy) throws T
{
throw (T) exception;
}
public static void throwException(Throwable exception)
{
Utils.<RuntimeException>throwException(exception, null);
}
}
public class Test
{
public static void main(String[] args)
{
Utils.throwException(new Exception("This is an exception!"));
}
}
【讨论】：
throws 声明的情况下将检查异常方法分配给 SAM 接口。
第三种选择是退出异常检查（就像标准 API 本身有时必须做的那样）并将检查的异常包装在 RuntimeException 中：
throw new RuntimeException(originalException);
您可能希望使用RuntimeException 的更具体的子类。
【讨论】：
我只是想添加一个替代答案，纯粹作为仅供参考：
是的，有一种方法可以在不添加 throws 声明的情况下引发检查异常，方法是使用 sun.misc.Unsafe 类。以下博客文章对此进行了描述：
Throw a checked exception from a method without declaring it
示例代码：
public void someMethod() {
//throw a checked exception without adding a "throws"
getUnsafe().throwException(new IOException());
}
private Unsafe getUnsafe() {
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
return (Unsafe) field.get(null);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
但是，不建议这样做。最好像其他一些答案中所述包含未经检查的异常。
【讨论】：
Unsafe是有原因的。
为什么不抛出未经检查的异常？这不必声明。
有两种选择
final，您可以重新抛出异常，并且编译器知道您可能捕获了哪些已检查异常。当您在代码中抛出检查异常并在调用代码中捕获它时，后者更有用，但中间的层对异常一无所知。
【讨论】：
是的，这是有原因的，但完全不建议您使用：
Java 不安全包
getUnsafe().throwException(new IOException());
此方法会抛出已检查异常，但您的代码不会强制捕获或重新抛出它。就像运行时异常一样。
【讨论】：
下面是一个拦截已检查异常并将它们包装在未检查异常中的示例：
public void someMethod() {
try {
doEvil();
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
【讨论】：
如果你使用Project lombok 并且想要在没有throws 声明的情况下抛出检查异常，你可以在方法中添加@SneakyThrows：
public void yourCaller(){
yourMethod();
}
@SneakyThrows
public void yourMethod(){
throw new Exception("Something went wrong");
}
这可以抛出已检查的异常，而调用者不需要捕获它们。
Lombok 提供了一个annotation processor，它在编译时修改代码。使用@SneakyThrows，它在没有throws 声明的情况下捕获并重新抛出异常。
如the description of @SneakyThrows 中所述，它将代码转换为类似的内容：
public void yourMethod() {
try {
throw new Exception("Something went wrong");
} catch (Exception t) {
throw Lombok.sneakyThrow(t);
}
}
来自the sources of Lombok.sneakyThrow()：
public static RuntimeException sneakyThrow(Throwable t) {
if (t == null) throw new NullPointerException("t");
return Lombok.<RuntimeException>sneakyThrow0(t);
}
@SuppressWarnings("unchecked")
private static <T extends Throwable> T sneakyThrow0(Throwable t) throws T {
throw (T)t;
}
如您所见，它使用泛型诱使 Java 认为这是一个未经检查的异常，如 this answer 所示。
【讨论】：
在 Java 8 中，由于类型推断，可以更容易地在不声明的情况下抛出已检查异常。
public class Main {
public static void main(String[] args) {
throwException(new Exception("exception"));
}
public static <T extends Throwable> void throwException(Throwable t) throws T {
throw (T) t;
}
}
【讨论】：
是的，使用类型转换到运行时异常并引发运行时异常。
像这样创建一个异常帮助器类。
public class ExceptionHelper {
public static <T> void throwException(Throwable t) throws Throwable {
throw (Throwable) t;
}
}
class ServiceClass {
public void actualFlow() {
try {
//somethinf
} catch (Exception e) {
ExceptionHelper.throwException(e);
}
}
}
【讨论】：
你可以在你的方法中使用 try-catch 块来捕获异常。 那么你就不需要声明 throws- 语句了。
【讨论】：
您可以使用从 RuntimeException 或 RuntimeException 本身派生的任何异常
或
对抛出异常的代码使用 try-block 并在那里处理它
【讨论】：