异常处理：抛出，抛出和抛出

Question

你们能解释什么是throw,throws和Throwable之间的差异以及何时使用哪个？

Answer 1

• throws：编写方法时，用于申报有问题的方法抛出指定的（检查）异常。

  与检查异常相反，可能会抛出运行时异常（NullPointerExceptions等），而无需声明方法声明throws NullPointerException。

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

  该throw关键字后面跟着一个Throwable（通常是一个例外）的引用。

例子：

---

• Throwable：你必须为了创建自己的，定制的，抛出扩展类。

例子：

---

• Official exception-tutorial

Answer 2

Throw用于抛出异常，throws（如果我猜对了），用来表示该方法可以抛出特定的异常，而Throwable类是所有错误和异常的在Java

How to Throw Exceptions

超

Answer 3

掷 - 它是用来抛出Exception.The throw语句需要一个参数：可抛出类对象

抛出 - 这是用来指定方法可以抛出异常

Throwable - 这是Java语言中所有错误和异常的超类。您只能抛出从Throwable类派生的对象。抛出包含在其创建

Answer 4

• throw时间的线程的执行堆栈的快照：声明抛出对象t其中t instanceof java.lang.Throwable必须是真实的。
• throws：通过该方法指定检查异常的方法签名令牌throw。
• java.lang.Throwable：可以引发（并捕获）的所有对象的父类型。

See here for a tutorial on using exceptions.

Answer 5

这很容易理解。

的java.lang.Throwable的：

的Throwable类是 所有错误，并在Java语言 异常的超类。只有 对象是此类 类（或其某个子类）的实例为 的Java虚拟机或 可引发的Java throw语句。 类似地，只有这个类或其中的一个 其子类可以是catch子句中的参数 类型。 More

的关键词抛出在方法声明中使用，这说明什么样的异常[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 
    } 
} 

当我们要使用的方法throwMeAException()，我们不得不照顾它在特定的方式，因为我们有它抛出的东西，在这种情况下，我们有三个选择的信息。

使用块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 6

投掷：

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

throw new MyException("Exception!); 

抛出：

这是当你没有在你的代码中使用的try catch语句中使用，但你知道，这个特殊的类是能够投掷某某异常（只检查例外）。在这里，你不使用try catch块，而是在你的代码的适当位置使用throw子句来写入，并且抛出异常给方法的调用者并由它处理。当函数可能抛出检查异常时，也会使用throws关键字。

public void myMethod(int param) throws MyException 

Answer 7

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

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; 
    } 
} 

Answer 8

在Java中Throwable :，所有的错误的和execption的类是从java.lang.Throwable的类drieved。它是错误和例外类的层次结构的顶部。只有作为此类（或其某个子类）的实例的对象由Java虚拟机抛出，或者可以由Java throw语句抛出。

Throws:是post-method修饰符，并指定该方法可能抛出哪些执行选项。如果它们是检查异常，编译器将保证调用该方法的代码必须捕获这些检查的异常。

Throw:语句用于引发错误或异常。 throw语句需要一个参数：Throwable类或Throwable类的任何子类的实例。执行throw语句会触发JVM引发此异常并导致发生异常。

Answer 9

列出几个...

掷

1. 的Java throw关键字用来明确throw异常。
2. 只有使用throw才能传播检查异常。
3. Throw后面是一个实例。
4. Throw在该方法内使用。
5. 您不能throw多个例外。

抛出

1. 的Java throws关键字来声明一个例外。
2. 检查异常可以用throws传播。
3. Throws其次是类。
4. Throws与方法签名一起使用。
5. 您可以声明多个例外 public void method()throws IOException,SQLException

Answer 10

有两种主要类型的例外：
运行时例外（未选中）：例如。 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 11

1. throw keyword used to throw user defined exceptions.(we can throw predefined exception too). 
2. Using throws keyword we can explicitly provide the information about unhand-led exceptions of the method to the end user, Java compiler, JVM. 

掷VS抛出

http://www.instanceofjava.com/2016/04/exception-handling-interview-questions.html