抛出Java异常

当一个方法抛出和异常时，我们是否需要在该方法内部有一个try块

比如说,

    public void foo() throws SomeException{
        try{
            // content of method
        }
    }

是否需要try块？或者，该方法是否能够在没有SomeException的情况下抛出SomeException：

    public void foo() throws SomeException{
            // content of method
    }

---

如果

SomeException

是选中的异常，则也必须使用throw

显式抛出SomeException

• 使用

  try{}catch

  块或
• 声明您的方法抛出它

你不必同时做这两件事，你在问题中展示的任何一个例子都很好

---

区别在于使用

try

子句，您可以自己处理

SomeException

，然而，通过声明您自己的方法

抛出它，您将处理
SomeException
的责任委托给调用方法。
如果
SomeException
是选中的异常，您必须


使用
try{}catch
块或
声明您的方法抛出它

你不必同时做这两件事，你在问题中展示的任何一个例子都很好

区别在于使用
try
子句，您可以自己处理
SomeException
，然而，通过声明您自己的方法
抛出
它，您将处理
SomeException
的责任委托给调用方法。
当方法抛出异常时，它将处理异常的责任传递给其调用方。
所以，若将异常放入签名中，则不需要处理它。如下所示

public void foo(){
        try{
            // content of method
        }
    }

try{

   foo();
}

但如果你这样写的话

public void foo() throws SomeException{

    }

您将按如下方式调用您的方法

public void foo(){
        try{
            // content of method
        }
    }

try{

   foo();
}

当方法抛出异常时，它将处理异常的责任传递给调用方。
所以，若将异常放入签名中，则不需要处理它。如下所示

public void foo(){
        try{
            // content of method
        }
    }

try{

   foo();
}

但如果你这样写的话

public void foo() throws SomeException{

    }

您将按如下方式调用您的方法

public void foo(){
        try{
            // content of method
        }
    }

try{

   foo();
}

1。如果从程序调用的方法抛出异常
，则需要在方法调用周围使用
try/catch
。

2.假设我们正在编写一个方法，该方法
抛出异常
，那么我们需要
抛出新的异常对象
。

3。异常是类型为exception的对象。我们有
已检查异常
，和
未检查异常（运行时异常）
1。如果从程序调用的
方法引发异常
，那么我们需要在方法调用周围使用
try/catch
。

2.假设我们正在编写一个方法，该方法
抛出异常
，那么我们需要
抛出新的异常对象
。

3。异常是类型为exception的对象。我们有
已检查异常
，以及
未检查异常（运行时异常）
您不需要try块

public void foo() throws SomeException {
  // do some stuff
  // you decide to throw the exception by yourself:
  if (throwAnException) throw new SomeException();
  // or you call a method that throws SomeExpection:
  methodThatCanThrowSomeException();
  // do more stuff
}

只要你在签名上声明，你就完好无损。方法的调用方必须处理异常，而不是您。因此，调用方可能会执行以下操作：

try {
  foo();
} catch (SomeException e) {
  // handle exception
}

或者他可以自己把它传得更远。
你不需要试块

public void foo() throws SomeException {
  // do some stuff
  // you decide to throw the exception by yourself:
  if (throwAnException) throw new SomeException();
  // or you call a method that throws SomeExpection:
  methodThatCanThrowSomeException();
  // do more stuff
}

只要你在签名上声明，你就完好无损。方法的调用方必须处理异常，而不是您。因此，调用方可能会执行以下操作：

try {
  foo();
} catch (SomeException e) {
  // handle exception
}

或者他可能会自己把它传得更远。
您经常遇到的最有问题的情况是调用一个声明已检查异常的方法。在绝大多数实际案例中，在现场处理该异常是不合适的，而是让它向上传播。不幸的是，Java让您一路重新声明同一个异常，这会造成混乱，暴露实现细节，并且通常还会破坏现有方法的契约

在这种情况下，继续操作的方法是包裹并重新缩回：

catch (RuntimeException e) {throw e;} catch (Exception e) {throw new RuntimeException(e);}

您经常遇到的最有问题的情况是调用声明已检查异常的方法。在绝大多数实际案例中，在现场处理该异常是不合适的，而是让它向上传播。不幸的是，Java让您一路重新声明同一个异常，这会造成混乱，暴露实现细节，并且通常还会破坏现有方法的契约

在这种情况下，继续操作的方法是包裹并重新缩回：

catch (RuntimeException e) {throw e;} catch (Exception e) {throw new RuntimeException(e);}

实际上，您不需要在其中设置try块

      public void foo() throws SomeException {
// do some stuff
// you decide to throw the exception by yourself:
if (throwAnException) throw new SomeException();
// or you call a method that throws SomeExpection:
methodThatCanThrowSomeException();
// do more stuff
 }

实际上，您不需要在其中设置try块

      public void foo() throws SomeException {
// do some stuff
// you decide to throw the exception by yourself:
if (throwAnException) throw new SomeException();
// or you call a method that throws SomeExpection:
methodThatCanThrowSomeException();
// do more stuff
 }

这不是他所要求的，但这是一种非常有趣的技术。谢谢；）这不是他所要求的，但这是一种非常有趣的技术。谢谢；）