Exceptions - Fehlerklassen

Auf dieser Seite lernst du, wie du → Fehlerklassen einsetzen kannst.

→ Fehlerklassen dienen dazu Fehler, die zur Laufzeit eines Programms auftreten können, zu behandeln und Lösungen anzubieten.

Aufgabe:

• Erstelle das Arbeitsfeld exception_keinkornda.
• Der Hamster soll bis zur Mauer laufen und auf seinem Weg die Körner einsammeln.
• Befindet sich auf seiner Position kein Korn, gibt er eine Meldung aus und geht zum Ausgangspunkt zurück.
• Erstelle eine → Fehlerklasse KeinKornDaFehler.
• Erstelle eine Klasse VorsichtigerHamster, die die Methode vorsichtigesNimm() enthält und die Fehlerklasse KeinKornDaFehler → "wirft".
• Speichere das Programm unter exception_keinkornda.
  
  
  

Tipps:

• Zunächst brauchst du eine → Fehlerklasse KeinKornDaFehler, die den Fehler (auf der aktuellen Position liegt kein Korn) behandelt und eine → entsprechende Meldung ausgibt.
• Erstelle eine Klasse <VorsichtigerHamster, und definiere die Methode VorsichtigesNimm().

      void vorsichtigesNimm() throws KeinKornDaFehler
      {
          if(this.kornDa())
          {
              this.nimm();
          }
          else
          {
              . . .
          }
      }
  

• Erstelle
  • einen → try-Block, der die normale Programmausführung versucht
  • einen → catch-Block, der den Fehler behandelt
  • und einen → finally-Block, der die weitere Programmausführung regelt.
  

Aufgabe:

• Der Hamster berechnet die ihm gestellten Aufgaben der Grundrechenarten (+ - * /).
• Nach Abschluss der Berechnung kann das Programm fortgesetzt oder abgebrochen werden.
• Speichere das Programm unter exception_hamsterrechnen.
  
  
  

Tipps:

• Es sind mehrere Fehler möglich:
  • der Fehler Division durch 0 soll durch eine Fehlerklasse abgefangen werden

    class DivisionDurchNullFehler extends Exception 
    {
    }	
    

  • eine weitere Fehlerklasse regelt das Fehlen eines Rechenzeichens

    class RechenzeichenFehltFehler extends Exception 
    {
    }
    

  • versehentlich eingegebene Buchstaben oder Leerzeichen lösen einen Fehler aus, der durch die Standardfehlerklasse NumberFormatException behandelt wird.
• Erstelle eine Klasse RechnenHamster.
• Innerhalb einer Methode erstelleRechenaufgaben() sorgt ine → do ... while-Schleife dafür, dass das Programm solange läuft, bis der Buchstabe "n" eingegeben wird.
• Erstelle eine Methode bearbeiteRechenaufgaben().
  Sie versucht zunächst die Standardausführung des Programms.

      void bearbeiteRechenaufgabe() 
      [
          try 
          { 
              String aufgabe = this.liesZeichenkette("Bitte eine Rechenaufgabe eingeben!\nRechenzeichen sind: + - / *");
              
              String rechenZeichen = this.ermittleRechenzeichen(aufgabe);
              
              int zahl1 = this.ermittleErsteZahl(aufgabe, rechenZeichen);
              int zahl2 = this.ermittleZweiteZahl(aufgabe, rechenZeichen);
              
              int ergebnis = this.berechne(zahl1, zahl2, rechenZeichen);
           }
  

  Wenn Fehler auftreten, werden sie im catch-Block behandelt und eine entsprechende Fehlermeldung ausgegeben:

          catch (RechenzeichenFehltFehler fehlerObjekt) 
          {
              . . .
          } 
          
          catch (DivisionDurchNullFehler fehlerObjekt) 
          {
              . . .
          }
          
          // Standardfehler NumberFormatException ausgeloöt durch 
          // Integer.parseInt(zahlString)
          catch (NumberFormatException fehlerObjekt)
          {
              . . .
          }
      }
  

  
  Zunächst wird mit → indexOf() und → substring()das Rechenzeichen ermittelt und das Fehlerobjekt RechenzeichenFehltFehler geworfen:

                 
      String ermittleRechenzeichen(String aufgabe) throws RechenzeichenFehltFehler 
      {
          int index = aufgabe.indexOf("+");
          if (index >= 0) 
          { 
              return aufgabe.substring(index, index + 1);
          }
          . . .
      }
      throw new RechenzeichenFehltFehler();
  

• Anschließend werden die Zahlen gelesen. Das Rechenzeichen trennt die Zahlen.
  Mit → Integer.parseInt() wird der String zahlString nach int umgewandelt.

      int zahl1 = this.ermittleErsteZahl(aufgabe, rechenZeichen);
       
      int ermittleErsteZahl(String aufgabe, String rechenZeichen)
      {
          int index = aufgabe.indexOf(rechenZeichen);
          String zahlString = aufgabe.substring(0, index);
          return Integer.parseInt(zahlString);
      }
      
      int ermittleZweiteZahl(String aufgabe, String rechenZeichen)  
      {
  		. . . 
      }
  

• Im letzten Schritt wird das Ergebnis berechnet. Das Rechenzeichen wird abgefragt und die entsprechende Rechnung wird durchgeführt.
  Da die Division durch nicht möglich ist, wird das Fehlerobjekt DivisionDurchNullFehler geworfen.

      int berechne(int zahl1, int zahl2, String rechenZeichen) throws DivisionDurchNullFehler
      {
          int ergebnis = 0;
          if (rechenZeichen.equals("+")) 
          {
              . . .
          } 
          else if (rechenZeichen.equals("-")) 
          {
              . . .
          } 
          . . .
      }
  

• Im Hauptprogramm wird nur der Hamster paul als Standardhamster initialisiert und die Methode bearbeiteRechenaufgaben() aufgerufen:

  void main() 
  {
      RechnenHamster paul = new RechnenHamster(Hamster.getStandardHamster());
      paul.erfrageRechenaufgaben();
  }
  

  

Aufgabe:

• Erweitere das Programm:
  • mit der Methode → zahlFormat()
  • Sollten versehentlich Buchstaben und Zahlen eingegeben werden. müssen die Buchstaben heraus gefiltert werden

Tipps:

• Zunächst wird der zahlString in → Großbuchstaben umgewandelt.
• Erstelle ein → Array mit großen Buchstaben.
• Zwei ineinander verschachtelte → for-Schleifen &löschen" die Buchstaben aus dem zahlString.

      String buchstabenEntfernen (String zahlEingabe)
      {
          . . .
          
          
          for (int zaehler = 0; zaehler < alphabet.length; zaehler ++)
          {
              for (int zaehler1 = 0; zaehler1 < zahlEingabe.length(); zaehler1 ++)
              {
                  index = zahlEingabe.indexOf(alphabet[zaehler]);
                  if(index >= 0) 
                  {
                      zahlEingabe = . . .
                  }
              }
          }
  
          return zahlEingabe;
      }