Meerdere uitzonderingen in Java gooien

Is er een manier om meerdere uitzonderingen in Java te gooien?

Antwoord 1, autoriteit 100%

Een methode kan een van meerdere uitzonderingenveroorzaken. Bijv.:

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

Dit geeft aan dat de methode uiteindelijk éénvan die twee uitzonderingen kan veroorzaken (en ook alle niet-aangevinkte uitzonderingen). Je kunt (in Java of in welke taal dan ook AFAIK) niet tegelijkertijd twee uitzonderingen maken, dat zou niet veel zin hebben.

Je kunt ook een genesteException gooien, die een ander exception-object bevat. Maar dat zou nauwelijks tellen als “twee uitzonderingen gooien”, het vertegenwoordigt slechts een enkel uitzonderingsgeval dat wordt beschreven door twee uitzonderingsobjecten (vaak uit verschillende lagen).

Antwoord 2, autoriteit 50%

Ik veronderstel dat je een uitzondering zou kunnen maken met een lijst van gevangen uitzonderingen en die uitzondering zou kunnen weggooien, bijvoorbeeld:

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

Antwoord 3, autoriteit 48%

Je kunt geen twee uitzonderingen maken. D.w.z. je kunt niet zoiets doen als:

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

Alternatief 1: Uitzondering A wordt veroorzaakt dooruitzondering B

U kunt uitzonderingen nestenmet behulp van de cause-constructorom het volgende te doen:

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

Goed artikel over geketende uitzonderingen: Programming.Guide: Chained Exceptions

Alternatief 2: Gebruik onderdrukteuitzondering

Eén uitzondering kan een andere uitzondering onderdrukken.

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
}

Goed artikel over onderdrukte uitzonderingen: Programming.Guide: onderdrukte uitzonderingen

Antwoord 4, autoriteit 15%

Ik heb een patroon gezien waarbij een aangepaste uitzondering intern andere uitzonderingen opslaat (ik weet niet meer waarom ze het deden), maar het was als:

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

en het werd als volgt gebruikt:

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

Later in de code werd de containeruitzondering geëvalueerd en naar een logbestand gedumpt.

Antwoord 5, autoriteit 12%

Het heeft geen zin om meer dan één uitzondering te maken, omdat u niet meer dan één enkele fout kunt hebben (de fout kan meerdere redenen hebben, maar er kan nooit meer dan één enkele fout zijn).

p>

Als u de redenen wilt bijhouden, kunt u uitzonderingen koppelen:

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

Deze zijn beschikbaar via getCause().

Antwoord 6, autoriteit 12%

Als u meerdere uitzonderingen in Java wilt genereren, moet u eerst elke uitzondering onderdrukken in één aangepaste uitzondering en vervolgens dezelfde aangepaste uitzondering genereren. Controleer het onderstaande codefragment om hetzelfde te bereiken.

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

Roep de methode addException aan met dezelfde referentie aggExcep waar je maar wilt (uiteraard binnen het catch-blok) en onderdruk elke uitzondering.
En aan het einde gooi je expliciet aggExcep met het trefwoord ‘throw’ waar je maar wilt.

De

void addSuppressed(Gooibare uitzondering)

is een vooraf gedefinieerde methode van de Throwable-klasse die de gespecificeerde uitzondering toevoegt aan de uitzonderingen die werden onderdrukt om deze uitzondering te leveren.

Antwoord 7, autoriteit 6%

U kunt de mogelijkheid hebben om meerdere verschillende uitzonderingen te genereren. Bijvoorbeeld:

if (obj == null)
    throw new NullPointerException();
if (some other case)
    throw new IllegalArgumentException();
if (this == this)
    throw new IOException();

Deze code kan meerdere verschillende uitzonderingen veroorzaken, maar dit kan nooit tegelijkertijd gebeuren.

Antwoord 8, autoriteit 6%

Het patroon beschreven door Andreas_D is zeker nuttig wanneer u bijvoorbeeld de server-side compilatie van een door de gebruiker geleverd bestand afhandelt en de fouten wilt rapporteren.

U kunt bijvoorbeeld een CompilationException hebben die wordt gegenereerd als de bron niet kan worden gecompileerd. Compileren kan van alles betekenen. U kunt bijvoorbeeld de tekst in een bestand evalueren dat een eindgebruiker uploadt, tokens ontleden, controleren op syntaxisfouten en bepalen of het bestand geldig is. Aan het einde is het ding ofwel geldig of ongeldig en je wilt een goede CompilationException teruggeven om een back-up van de call-stack te verspreiden.

Zoals Andreas beschrijft, kunt u een methode add() gebruiken waarmee u compilatieproblemen aan uw uitzondering kunt toevoegen. Die problemen hoeven zelf geen uitzonderingen te zijn, maar dat is aan jou. Het helpt vaak om bij één uitzonderingskader te blijven, zodat u dezelfde validatielogica op meerdere plaatsen kunt gebruiken.

Wat je in ieder geval wilt, is dat een enkele CompilationException terugvalt door de call-stack, omdat dat het framework vertelt dat het ding niet is gecompileerd. Als iemand hogerop in de keten wil weten waarom, dan kunnen ze de onderliggende problemen achterhalen door bijvoorbeeld getCauses() aan te roepen.

Het is ook handig vanuit een UI-perspectief. Die informatie die op de Exception blijft hangen, kan op de juiste manier worden verwerkt voordat u weer over de draad gaat, zodat u uw eindgebruiker wat informatie kunt geven over waarom de compilatie is mislukt.

Antwoord 9, autoriteit 2%

Ik weet niet zeker of je vraagt of er meerdere uitzonderingen tegelijk kunnen worden gegenereerd of dat we een code kunnen hebben om meerdere uitzonderingen tegelijk af te handelen. Ik zal proberen deze beide te beantwoorden. Dit is mijn eerste antwoord op StackOverflow, dus sorry voor eventuele fouten.

1) Als je meerdere uitzonderingen tegelijk wilt maken, denk ik dat je dat niet kunt doen. Overweeg een analoge situatie. Wanneer je een wiskundevraag oplost en een punt bereikt waarop je deelt door 0, is er OP DIT PUNT slechts één fout en dat is delen door nul. Dus ik denk dat je gewoon een fout kunt geven voor een bepaalde verklaring. Er kunnen echter veel instructies in uw try-catch-blok voorkomen, die elk een andere fout kunnen veroorzaken.

2) ALS u meerdere fouten wilt afhandelen/opvangen, zijn er twee manieren om dit te doen.
i) Vóór 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) Na Java 7 heb je de multi-catch-functie.

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

Ik denk dat dit je twijfel zal oplossen.
Dit is mijn eerste antwoord, alle suggesties zijn welkom!

Antwoord 10

er is een manier voor een methode om meerdere uitzonderingen te genereren, maar niet in één keer. bijv. wanneer de compilatie om de een of andere reden mislukt, kan uw methode slechts één uitzondering genereren.
als je verschillende opportunities moet dekken, zou je je methode kunnen declareren om de bovenliggende klasse van alle uitzonderingen “Uitzondering” te geven.
dus als je een methode declareert om een uitzondering in het algemeen te genereren, kan een uitzondering van elk type worden gegenereerd door deze methode.

bijvoorbeeld:

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

Ik weet niet wat je eigenlijk moest weten, maar misschien helpt dit.
hoewel het veel tijd is verstreken sinds je bericht ^^

gegroet

Antwoord 11

Meeliften op het antwoord van aioobe, wat ik deed was elke uitzondering in een lijst gooien voordat ik ze als onderdrukte uitzonderingen aan een nieuwe uitzondering toevoeg, en vervolgens de nieuwe gooide:

Voorbeeld:

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

Om een import te voorkomen als je nog geen List ergens anders hebt, kun je ook gewoon een nieuwe Exception gooien in plaats van een lijst te initialiseren, je fouten eraan toevoegen met addSuppressed()`` in the catchblock, and later callException.getSuppressed().length > 0“` om te bepalen of er iets aan is toegevoegd, maar ik hou gewoon van de lijst vanwege de leesbaarheid en de algemene redenering dat ik geen uitzondering wil maken zonder dat er daadwerkelijk een fout is opgetreden.