例外处理：投掷，投掷和抛出

StackOverflow https://stackoverflow.com/questions/3940213

题

你们中的任何人都可以解释彼此之间的差异吗 throw, throws 和 Throwable 什么时候使用哪个？

有帮助吗？

解决方案

  • throws: ：在编写方法时使用，以声明所讨论的方法会抛出指定的（检查）异常。

    与检查异常相反，可以在没有方法声明的情况下抛出运行时异常（NullPoInterExceptions等） throws NullPointerException.

  • throw: ：指令实际上引发例外。 （或更具体地说， 可投掷).

    投掷关键字之后是对 Throwable （通常是例外）。

例子：

enter image description here

  • Throwable: ：您必须扩展的课程才能创建自己的自定义，可投掷。

例子：

enter image description here

其他提示

  • throw: ：语句扔对象 t 在哪里 t instanceof java.lang.Throwable 必须是真实的。
  • throws: ：一个方法签名令牌以指定检查的异常 thrown通过该方法。
  • java.lang.Throwable: ：可以扔（并捕获）的所有对象的父型。

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

这真的很容易理解。

这 java.lang.throwable:

这 Throwable 类是Java语言中所有错误和异常的超类。仅Java虚拟机抛出了该类别的实例（或其子类之一）的实例（或其中一个子类），或者可以被Java抛出 throw 陈述。同样，只有此类或其子类之一可以是一个参数类型 catch 条款。 更多的

关键词 扔 被用于方法声明中，这说明了我们从此方法可能期望的例外[可投掷类]。

关键词 扔 用于抛出一个可投掷类的实例的对象。

获取一些例子：

我们创建自己一个例外类

public class MyException super Exception {

}

我们创建了一种从我们的异常类创建对象的方法， 扔 它使用关键词 扔.

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(), ，我们被迫以特定的方式照顾它，因为我们拥有它提供的东西的信息，在这种情况下，我们有三个选项。

第一个选项是使用块尝试捕获以处理例外：

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 这些不必被宣布。这是另一个故事，作为例外用法的方面。

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

投掷 - 这用于指定该方法可以抛出异常

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

Throw 用于抛出例外， throws （如果我猜对的话）被用来指示方法可以抛出特定的异常，并且 Throwable 课程是Java中所有错误和异常的超类

如何投掷例外

扔 ：

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

throw new MyException("Exception!);

扔：

当您不使用代码中的Try Catch语句时，可以使用此功能，但是您知道该特定类能够投掷SO so异常（仅检查例外）。在此中，您不使用尝试捕获块，而是在代码中适当的点使用“投掷子句”编写，并且将异常抛向该方法的呼叫者并由其处理。同样，当功能可能引发检查的异常时，请使用抛出关键字。

public void myMethod(int param) throws MyException

有两种主要类型的例外类型：
运行时异常（未选中）: ：例如。 NullPoInterException，ClassCastException，..
检查例外： 例如。 filenotfoundException，clonotsupportedException，..

运行时异常是在运行时发生的例外，开发人员不应尝试捕获或停止它。您只编写代码来避免它们或发布命令 扔, ，当满足错误标准时。我们在方法主体内使用投掷。

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

与上面的答案相同，但 复制愉悦:

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;
    }
}
许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top