在 Java 中抛出多个异常

Question

有没有办法在java中抛出多个异常？

Answer 1

A method can throw one of several exceptions . Eg:

 public void dosomething() throws IOException, AWTException {
      // ....
 }

This signals that the method can eventually throw one of those two exceptions (and also any of the unchecked exceptions). You cannnot (in Java or in any language AFAIK) throw simultaneously two exceptions, that would not make much sense.

You can also throw a nested Exception, which contains inside another one exception object. But that would hardly count that as "throwing two exceptions", it just represents a single exception case described by two exceptions objects (frequently from different layers).

Answer 2

I suppose you could create an exception containing a list of caught exceptions and throw that exception, eg:

class AggregateException extends Exception {
    List<Exception> basket;
}

Answer 3

You can't throw two exceptions. Ie you can't do something like:

try {
    throw new IllegalArgumentException(), new NullPointerException();
} catch (IllegalArgumentException iae) {
    // ...
} catch (NullPointerException npe) {
    // ...
}

Alternative 1: Exception A is caused by exception B

You could nest exceptions using the cause-constructor to do the following:

try {
    Exception ex1 = new NullPointerException();

    // Throw an IllegalArgumentException that "wraps" ex1
    throw new IllegalArgumentException(ex1);
} catch (IllegalArgumentException iae) {
    // handle illegal argument...
    throw iae.getCause(); // throws the cause (the NullPointerException)
}

Good article on chained exceptions: Programming.Guide: Chained Exceptions

Alternative 2: Use suppressed exception

One exception can suppress another exception.

try {
    Exception ex1 = new NullPointerException();

    // Throw an IllegalArgumentException that "suppresses" ex1
    IllegalArgumentException ex2 = new IllegalArgumentException();
    ex2.addSuppressed(ex1);
    throw ex2;
} catch (IllegalArgumentException iae) {
    // handle illegal argument...
    ... iae.getSuppressed() ... // get hold of the suppressed exceptions
}

Good article on suppressed exceptions: Programming.Guide: Suppressed Exceptions

Answer 4

I've seen a pattern, where a custom exception internally stores other exceptions (can't remember, why they did it), but it was like:

public class ContainerException extends Exception {

  private List<Exception> innerExeptions = new Arrayist<Exception>();

  // some constructors

  public void add(Exception e) {
    innerExceptions.add(e);
  }

  public Collection<Exception> getExceptions() {
    return innerExceptions;
  }
}

and it was used like this:

try {
  // something
} catch (ContainerException ce) {
  ce.add(new RunTimeException("some Message");
  throw ce; // or do something else
}

Later in the code, the container exception was evaluated and dumped to a log file.

Answer 5

Throwing more than a single exception doesn't make sense because you can't have more than a single error (the error can have multiple reasons but there can't be more than a single error at any time).

If you need to keep track of the reasons, you can chain exceptions:

} catch (Exception ex) {
    throw new RuntimeException("Exc while trying ...", ex);
}

These are available via getCause() .

Answer 6

To throw multiple exceptions in Java you'll first have to suppress each exception into one customized exception and then throw the same customized exception. Please check the below code snippet to achieve the same.

  public class AggregateException extends Exception {


        public void addException(Exception ex){

        addSuppressed(ex);
        exception = true;
    }
}


public class AnyClass{

    public AggregateException aggExcep = new AggregateException();

    public void whereExceptionOccurs(){
        try{

              //some code
        }catch(Exception e){

              aggExcep.addException(e);
              //throw aggExcep;
        }  
    }
}

Call the method addException with the same reference aggExcep wherever you want to(Inside the catch block obviously) suppress any exception. And at the end explicitly throw aggExcep using 'throw' keyword where ever you want to.

The

void addSuppressed(Throwable exception)

is a predefined method of Throwable class which appends the specified exception to the exceptions that were suppressed in order to deliver this exception.

Answer 7

The pattern described by Andreas_D is definitely useful whenever you're handling, say, the server-side compilation of a user-provided file and want to report back the errors.

For example, you might have a CompilationException which gets generated if the resource fails to compile. Compiling might mean any number of things. For example, you might evaluate the text inside of a file that an end user uploads, parse out tokens, check for syntax errors and determine whether the file is valid. At the end, the thing is either valid or it is invalid and you want to hand back a proper CompilationException to propagate back up the call stack.

Like Andreas describes, you can have an add() method that lets you add compilation issues to your exception. Those issues don't have to be Exceptions themselves, but that's up to you. It often helps to stick to a single exception framework so that you can use the same validation logic in multiple places.

At any rate, what you want is a single CompilationException falling back through the call stack because that tells the framework that the thing did not compile. If anyone up the chain wants to know why, then they can get at the underlying issues with a call to, say, getCauses().

It's also useful from a UI perspective. That information sticking around on the Exception can be properly handled before going back over the wire so that you can give your end user some information as to why the compilation failed.

Answer 8

You can have the possibility of throwing multiple different exceptions. For example:

if (obj == null)
    throw new NullPointerException();

if (some other case)
    throw new IllegalArgumentException();

if (this == this)
    throw new IOException();

This code may throw multiple different exceptions, but this can never happen at the same time.

Answer 9

I am unsure if you are asking whether multiple exceptions can be thrown at a time or we can have a code to handle multiple exceptions at a time. I will try to answer both of these. This is my first answer on StackOverflow so pardon any errors.

1) If you want to throw multiple exceptions at a time,I think you can't do that. Consider an analogous situation. When you are solving a Math questions and reach a point where you are dividing by 0, there is only one error AT THIS POINT of time and that is dividing by zero. So I guess you can just throw one error for a given statement. However there can exist many statements in your try catch block each of which might throw a different error.

2) IF you want to handle/catch multiple errors there are two ways to do it. i) Before Java 7:

`try{
     ...
     //some method/action that can be a cause of multiple errors,say X and Y
     ...
 }catch(XException e){
      //Do something if exception X arises.
 }catch(YException e){
      //Do something if exception Y arises.
 }
`

ii) After Java 7,you have the multi catch feature.

try{
     ...
     //some method/action that can be a cause of multiple errors,say X and Y
     ...
 }catch(XException|YException e){
   // Take action appropriate to both types of exception.
  ...
 }

I believe this will solve your doubt. This being my first answer,all suggestions are welcome!

Answer 10

there is a way for a method to throw mutiple exeptions, but not at one time. eg when compilation fails for some reason your method can only throw one exception. if you have to cover different opportunities you might declare you method to throw the parent class of all exceptions "Exception". so, if you declare a method to throw an Exception in general, an exception of any type can be thrown by this method.

for example:

public static void main(String[] args) throws Exception
{
  getClipboard();    // throws an UnsupportedFlavorException
  initIOActivity();  // throw an IOException
}

i don't know what you actually needed to know but maybe this helps. although it has passed a lot of time since your post ^^

greetings

Answer 11

Piggybacking on aioobe's answer, what I did was throw each Exception into a list before adding them as suppressed exceptions to a new Exception, then threw the new one:

Example:

public JSONObject jsonExceptionExample(int value) throws JSONException {
    //Create Exception List
    List<JSONException> jsonExceptions = new ArrayList<>();
    JSONObject jsonObject = new JSONObject();
    try {

        //Your code that could throw an Exception
        jsonObject.put("key", value);

    } catch (JSONException e){
        //Exception is caught and added to list instead of being thrown
        jsonExceptions.add(e);
    }    
    //Check to see if any Exceptions were caught
    if (jsonExceptions.size() > 0) {
        //Create a new Exception to be the 'parent' Exception
        JSONException jsonException = new JSONException("JSONException(s) thrown");
        //Iterate through your list of errors
        for (JSONException e : jsonExceptions) {
            //Add each one to the parent Exception as 'Suppressed'
            jsonException.addSuppressed(e);
        }
        //Throw your new nested error
        throw jsonException;
    }
    //If no Exceptions were found, resume your code
    return jsonObject;
}

To avoid an import if you don't already have a List elsewhere, you could also just throw a new Exception instead of initializing a list, add your errors to it with addSuppressed()`` in the catch block, and later call Exception.getSuppressed().length > 0``` to determine if any were added to it, but I just like the list for the readability and the general rationale that I don't want to create an Exception without there actually being an error.