Anweisungen für die Ausnahmebehandlung

Ausnahmekonfiguration

Bevor Sie eine Ausnahme abfangen können, muss der Code irgendwo eine Ausnahme auslösen. Jeder Java™ -Code kann eine Ausnahmebedingung auslösen.

Ein throw -Ausdruck ist jede Art von Ausdruck, dessen Typ dem Java-Typ Throwable oder der Unterklasse zugeordnet werden kann. Ein throw -Ausdruck kann entweder in der API oder in einer Regeln angegeben werden. Wenn eine Ausnahmebedingung ausgelöst wird, kann sie von der API oder einer Regel-mit einer Anweisung try-catch-finally oder von einem beliebigen Java-Code-abgefangen werden, wodurch der IRL-Code ausgeführt wird.

Anweisungen "try-catch-finally"

Im Folgenden sind die Anweisungen "try-catch-finally" beschrieben.

• Die Anweisung try identifiziert einen Block von Anweisungen, in denen eine Ausnahme ausgelöst werden kann.

• Die Anweisung catch muss einer Anweisung try zugeordnet werden und identifiziert einen Block von Anweisungen, der einen bestimmten Typ von Ausnahme behandeln kann. Die Anweisungen werden ausgeführt, wenn innerhalb des Try-Blocks eine Ausnahme eines bestimmten Typs auftritt. Es kann beliebig viele Anweisungen geben, denen bei Bedarf eine Anweisung try folgt. Jede Anweisung behandelt alle Ausnahmen, die Instanzen der in Klammern aufgelisteten Klasse und deren Unterklassen sind, oder einer Klasse, die die in Klammern aufgelistete Schnittstelle implementiert.

• Die Anweisung finally muss einer Anweisung try zugeordnet werden und gibt einen Block von Anweisungen an, die ausgeführt werden, unabhängig davon, ob ein Fehler innerhalb des try-Blocks auftritt oder nicht. Die Anweisung finally wird im Allgemeinen verwendet, um nach dem Code in der Anweisung try eine Bereinigung durchzuführen. Wenn eine Ausnahme im try-Block eintritt und es einen zugehörigen catch-Block für die Behandlung der Ausnahme gibt, wird die Steuerung zuerst an den catch-Block und dann an den finally-Block übergeben.

Im Folgenden sehen Sie das allgemeine Format dieser Anweisungen:

try {
    statements
} 
catch (ExceptionType1 name) {
    statements
} 
catch (ExceptionType2 name) {
    statements
} 
...
finally {
    statements
}

IRL lässt allgemeine Ausnahmehandler zu, die mehrere Typen von Ausnahmen behandeln. Spezialisiertere Ausnahmehandler können jedoch bestimmen, welcher Typ von Ausnahme eingetreten ist und Sie bei der Wiederstellung nach solchen Fehlern unterstützen. Handler, die zu allgemein sind, können den Code fehlerträchtiger machen, indem sie Ausnahmen abfangen und behandeln, die nicht vorhersehbar waren und für die der Handler nicht bestimmt ist.

Die folgenden try-Anweisungen veranschaulichen, wie eine Ausnahme erstellt und ausgelöst wird.

then {
   try {
      method1(1) ; 
      System.out.println("Call method1(1) was OK") ; 
   }
   catch ( Exception e ) { 
   System.out.println("Catch from method1(1) call") ; 
   }
   try {
      method1(2) ;
      System.out.println("Call method1(2) was OK") ;
   }
   catch ( Exception e ) { 
      System.out.println("Catch from method1(2) call") ; 
      System.out.println("Exception details :-") ;
      System.out.println("Message: " + e) ; 
   }
}

Die Anweisungen try-catch verwenden einen Methodenaufruf aus einer Java-Klasse, um eine Ausnahmebedingung auszulösen, wenn die an method1 übergebene Variable ungleich 1ist. Hier ist method1:

public static void method1(i) throws Exception{
   if (i == 1) { 
      System.out.println("method1 - Things are fine \n") ; 
   }
   else {        
      System.out.println("method1 - Somethings wrong! \n") ;
      throw new Exception("method1 - Its an exception! \n") ; 
   } 
}

Ausnahmen, die von einer Regel oder einem Java-Code im Geltungsbereich der Regelengine ausgelöst werden, werden von den try-catch -Anweisungen für diese spezielle Ausnahme abgefangen.

Die folgende CatchCustomer Regel ist ein Beispiel für einen try-catch Anweisungsblock, der Ausnahmen abfangen kann, die von der ILOG®-Regelsprache und/oder Java-Code ausgelöst werden. Die Regel verwendet zwei Klassen, Customer und Item, sowie zwei Unterklassen der Java-Klasse Exception , TooHighExpense und IsNotMember.

rule CatchCustomer
{
  when {
   ?c: Customer();
   ?item: Item();
  }
  then {
    try {  
      System.out.println("Customer " + ?c.getName() + " wants to buy "
                         + " item " + ?item.getLabel() + " for a price of " +
                         ?item.getPrice() + "$");
      IsMember(?c);
      ?c.buy(?item);
    }
    catch (TooHighExpense ex) {
      System.out.println("M/Mrs/Mz " + ?c.getName() + " you have already
                         bought:");
      int j = 0;
      for(j = 0; j<?c.getItems().size(); j++) {
        java.util.Enumeration ?i = ?c.getItem(j);
        System.out.println("   Item: " + ?i.getLabel() + " costs " +
                           ?i.getPrice() + "$");
      }
      System.out.println("You have at your disposal " + ?c.getBudget() + "$");
      System.out.println("The current purchase is not allowed");
    }
    catch (IsNotMember ex) {
      System.out.println("M/Mrs/Mz " + ?c.getName() + 
                         ", you are not a member; would you like to
                          subscribe?");
    }
  }
}

In dem Beispiel wird einem Kunden ein Budget zugewiesen. Der Kunde darf keine Artikel kaufen, die das zugewiesene Budget überschreiten. Wenn der Kunde versucht, Artikel zu kaufen, die das Budget überschreiten, wird eine Ausnahme TooHighExpense ausgelöst. Zum Kaufen von Artikel muss der Kunde außerdem Mitglied (Member) sein. Wenn ein Kunde, der kein Mitglied ist, versucht, einen Artikel zu kaufen, wird eine Ausnahme IsNotMember ausgelöst.

Nachfolgend sind die beiden Java-Klassen IsNotMember und TooHighExpense dargestellt, die in der Regel CatchCustomer verwendet werden:

public class IsNotMember extends Exception
{
    public IsNotMember(String name){
      super();
      this.customer = name;
    }
    public void printStackTrace(PrintWriter s){ 
      s.println("An IsNotMember exception has been caused by customer "
                + customer + ". We are sorry but you can not make a purchase "
                + "without being a member.");
      super.printStackTrace(s);
      }
    String customer;
};


public class TooHighExpense extends Exception
{
    public TooHighExpense(String name, int expense, int limit, int price){
      super();
      this.expense = expense;
      this.limit = limit;
      this.price = price;
      this.customer = name;
    }
    public void printStackTrace(PrintWriter s){ 
      s.println("A TooHighExpense exception has been caused by customer "
                + customer + ". For this customer, the current expense is " + expense + 
                " and the authorized budget is " + limit +
                ". The purchase of the item whose price is " + price
                + " is not allowed.");
      super.printStackTrace(s);
      }
    private int price;
    private int limit;
    private int expense;
    String customer;
};