java - 异常处理：throw、throws 和 Throwable

Question

你们中的任何人都可以解释 之间有什么区别throw，throws以及Throwable何时使用哪个？

Answer 1

• throws ：在编写方法时使用，以声明有问题的方法抛出指定的（检查的）异常。

  与检查异常相反，运行时异常（NullPointerExceptions 等）可能会在没有方法 declare 的情况下被抛出throws NullPointerException。

• throw: 实际抛出异常的指令。（或者更具体地说，Throwable）。

  throw 关键字后跟对 a 的引用Throwable（通常是异常）。

例子：

---

• Throwable：一个你必须扩展的类，以便创建你自己的、自定义的、可抛出的。

例子：

---

• 官方异常教程

Answer 2

• throwt: 抛出对象的语句t instanceof java.lang.Throwable必须为真。
• throws: 一个方法签名令牌，用于通过该方法指定检查的异常thrown。
• java.lang.Throwable：可以抛出（和捕获）的所有对象的父类型。

有关使用异常的教程，请参见此处。

Answer 3

这真的很容易理解。

java.lang.Throwable：_

该类Throwable是 Java 语言中所有错误和异常的超类。只有作为此类（或其子类之一）实例的对象才会被 Java 虚拟机抛出或可以被 Java throw语句抛出。同样，只有此类或其子类之一可以是 catch子句中的参数类型。 更多的

在方法声明中使用了关键字throws ，它指定了我们可以从该方法中期望什么样的异常[Throwable 类]。

关键字throw用于抛出作为 Throwable 类的实例的对象。

---

以免看到一些例子：

我们为自己创建一个异常类

public class MyException super Exception {

}

我们创建了一个方法，该方法从我们的异常类创建一个对象并使用关键字throw抛出它。

private  void throwMeAException() throws MyException //We inform that this method throws an exception of MyException class
{
  Exception e = new MyException (); //We create an exception 

  if(true) {
    throw e; //We throw an exception 
  } 
}

当我们要使用 methodthrowMeAException()时，我们不得不以特定的方式处理它，因为我们知道它会抛出一些东西，在这种情况下，我们有三个选项。

第一个选项是使用块 try 和 catch 来处理异常：

private void catchException() {

   try {
     throwMeAException();
   }
   catch(MyException e) {
     // Here we can serve only those exception that are instance of MyException
   }
}

第二种选择是传递异常

   private void passException() throws MyException {

       throwMeAException(); // we call the method but as we throws same exception we don't need try catch block.

   }

第三种选择是捕获并重新抛出异常

private void catchException() throws Exception  {

   try {
     throwMeAException();
   }
   catch(Exception e) {
      throw e;
   }
}

---

恢复，当您需要停止某些操作时，您可以通过一些 try-catch 块抛出异常，该异常将返回直到不是服务器。无论您在哪里使用引发异常的方法，您都应该通过 try-catch 块来处理它，或者将声明添加到您的方法中。

这条规则的例外是java.lang.RuntimeException那些不必声明的。这是关于异常使用方面的另一个故事。

Answer 4

throw - 用于抛出异常。 throw 语句需要一个参数：可抛出的类对象

throws - 用于指定方法可以抛出异常

Throwable - 这是 Java 语言中所有错误和异常的超类。您只能抛出从 Throwable 类派生的对象。throwable 包含其线程在创建时的执行堆栈的快照

Answer 5

Throw用于抛出异常，throws（如果我没猜错的话）用于表示方法可以抛出特定的异常，并且Throwable该类是Java中所有错误和异常的超类

如何抛出异常

Answer 6

扔 ：

用于实际抛出异常，而 throws 是该方法的声明性。它们不可互换。

throw new MyException("Exception!);

抛出：

当您没有在代码中使用 try catch 语句但您知道该特定类能够抛出某某异常（仅检查异常）时，将使用此方法。在这种情况下，您不使用 try catch 块，而是在代码中的适当位置使用 throw 子句编写异常，并将异常抛出给方法的调用者并由它处理。当函数可能抛出检查异常时，也会使用 throws 关键字。

public void myMethod(int param) throws MyException 

Answer 7

有两种主要类型的异常：
运行时异常（未选中）：例如。NullPointerException，ClassCastException，..
检查异常：例如。FileNotFoundException，CloneNotSupportedException，..

运行时异常是在运行时发生的异常，开发人员不应试图捕捉或停止它。当满足错误标准时，您只需编写代码以避免它们或发出命令throw 。我们在方法体内使用 throw。

public Rational(int num, int denom){
if(denom <= 0) {
  throw new IllegalArgumentException("Denominator must be positive");
}
this.num=num;
this.denom=denom;
}

但是对于检查的异常，JVM 希望您处理它，如果不处理它会给出编译器错误，因此您声明它会抛出该类型的异常，如下面的 clone() 方法所示。

Class Employee{
public Employee clone() throws CloneNotSupportedException{
    Employee copy = (Employee)super.clone();
    copy.hireDate = (Date)hireDate.clone();
    return copy;
}
}

Answer 8

与上述相同的答案，但有复制粘贴的乐趣：

public class GsonBuilderHelper {
    // THROWS: method throws the specified (checked) exception
    public static Object registerAndRun(String json) throws Exception {

        // registering of the NaturalDeserializer
        GsonBuilder gsonBuilder = new GsonBuilder();
        gsonBuilder.registerTypeAdapter(Object.class, new NaturalDeserializer());
        Gson gson = gsonBuilder.create();

        Object natural = null;
        try {
            // calling the NaturalDeserializer
            natural = gson.fromJson(json, Object.class);
        } catch (Exception e) {
            // json formatting exception mainly
            Log.d("GsonBuilderHelper", "registerAndRun(json) error: " + e.toString());
            throw new Exception(e);  // <---- THROW: instance of class Throwable. 
        }
        return natural;
    }
}