Collections und Exceptions

Collections

Einführung

Die Java Collections sind eine Menge von Abstrakten Datentypen, die sich im Package java.util befinden. Der Name Collection steht dabei für ein Interface, dass allgemeine Methoden wie add, remove spezifiziert.

Eine Besonderheit bei diesen ADT's ist, sie speichern nur Objekte, keine primitiven Datentypen wie int oder float.

SubInterfaces

Niemand braucht dieses Collection Interface zu implementieren, denn Java stellt vererbt die Eigenschaften von Collection an 3 Subinterfaces die, die zu speichernde Menge etwas genauer spezifiziert.

1. Sets - Menge

Wie die mathematische Definition der Menge, enthalten Sets keine Duplicate ihrer Elemente. Eine Besonderheit von Sets ist die Art und Weise wie mit Fehlerhaften Eingaben umgegangen wird. Die add Methode wirft nicht wie sonst in Java üblich eine Eception sondern liefert einen true/false Wert zurück. add ist spezifiziert durch:

boolean add(Object o)

2. Lists

Listen haben die Eigenschaft, dass sie sortiert sind und auch Duplikate enthalten dürfen. Wichtige Methoden sind:

boolean add(Object o) - Speichere o in die Liste
Object remove(int Index) - Liefere Objekt an Position Index zurück und lösche es
void clear - Löscht alle Elemente in der Liste

3. Maps

Maps haben wie die Sets die Eigenschaft keine Duplikate zu enthalten. Dabei werden die Elemente in Maps im sog. key=value Verfahren gespeichert. D.h. Jedem Wert den man speichern möchte, wird ein Schlüssel zugewiesen über den man dann auf das Objekt zugreifen kann. Eine besondere Map Implementierung sind die HashMap's. Diese erlauben einen sehr effizienten zugriff auf die Elemente.

Vorteile / Nachteile

Eine der wichtigsten Vorteile von Collections ist ihre dynamische Erweiterbarkeit. D.h. man kann soviele Elemente speichern wie man will. Nur der Speicher begrenzt die Anzahl.

Ausserdem kann man mit den ADT's jede nur erdenkliche Form von Behältern programmieren, die dann dank des collection Interfaces über eine einheitliche Schnittstelle verfügen.

Ein ganz grosser Nachteil bei ADT's ist die Geschwindigkeit. Damit meine ich nicht unbedingt die Zeit zum suchen usw. Jedes Objekt erzeugt bei seiner Erzeugung Overhead (Speicher sammeln, Objektverwaltung, Konstruktor aufrufe, ...

Beispiele

Das Beispiel zeigt wie man Elemente in einen vector einfügt. Anschliessend wird durch den vector gelaufen und jedes Objekt implizit mittels seiner toString Methode zur Ausgabe gezwungen. Bei genauem hinsehen fällt auf, dass die Elemente nicht vom gleichen Typ sein müssen.

import java.awt.*;
import java.util.*;
public class Vec{
    public void amethod () {
        Vector mv = new Vector();
        //Note how a vector can store objects
        //of different types
        mv.addElement("Hello");
        mv.addElement(Color.red);
        mv.addElement(new Integer(99));
        //This would cause an error
        //As a vector will not store primitives
        //mv.addElement(99)
        //Walk through each element of the vector
        for(int i=0; i< mv.size(); i++){
            System.out.println(mv.elementAt(i));
            }
   }//End of amethod

   public static void main(String argv[]){
    Vec v = new Vec();
    v.amethod();
    }//End of main public void amethod(){

}
      

Quellen und Infos

Exceptions

Überblick

In jedem Programm können Fehler auftreten. Sei es durch fehlerhafte Programmierung oder durch fehlerhafte Benutzereingabe. Um effizient und einfach auf Fehler reagieren zu können, hat man das Konzept der exceptions entwickelt.

Durch die Möglichkeit "Exceptions zu werfen", kann man ganz individuell auf Fehler reagieren. Z.B. kann eine Exception den User veranlassen die Eingabe zu wiederholen, wenn er etwas falsch gemacht hat.

Exceptions werden in Java wie ganz normale Klassen programmiert und auch wie solche behandelt. Die einzige Besonderheit bei der Programmierung von fehlerklassen ist, dass diese die Klasse java.lang.Exception erweitern müssen. Dazu weiter unten mehr.

Arbeiten mit Exceptions

Erstellen einer Fehlerklasse

Möchte man mit Exceptions arbeiten, so braucht man, wie schon erwähnt, eine Klasse die den Fehler spezifiziert. Dabei kann man entweder die in Java vorgegebenen und gut dokumentierten Exceptions verwenden (Was man auch so oft wie möglichen machen sollte) oder man programmiert sich seine eigene Fehlerklasse. Das möchte ich im folgenden kurz Erläutern:

public class MyOwnException extends java.lang.Exception {
   }
    

... stellt schon eine funktionierende Fehlerklasse dar. Der Name des Fehlers ist "MyOwnException". Dieser Name wird später benutzt um die Exceptions zu werfen. natürlich gilt auch hier einen möglichst Aussagekräftigen Namen zu wählen. Dieser sollte auch den fehler so gut wie möglich beschreiben. Mein Vorschlag ist stets ein "Exception" an den namen zu hängen, damit man im Quelltext und auch ausserhalb im Dateisystem (Die Klasse würde ja "MyOwnException.java" heissen) erkennt, dass es sich um eine Exception Klasse handelt.

Der Rot dargestellte Teil, ist sehr wichtig für die Definition von Exceptions. Das bedeutet, man macht seine Fehlerklasse als möglichen Fehler dem Java System bekannt, indem man eben von der java.lang.Exception Klasse erbt.

Damit man unserer Exception auch verständliche Informationen entlocken kann, sollte man die Fehlerklasse um einen Konstruktor erweitern, der z.B. eine Fehlermeldung als String bekommt.

public class MyOwnException extends java.lang.Exception {

   MyOwnException (String errorString) {
      super (errorString);
      }
   }
    

An dem Konstruktor Kopf ist eigentlich nix Besonderes dran. Aber der Inhalt des Konstruktors bedarf vielleicht einiger Erklärung. Der Rot dargestellte Code ruft den Vater Konstrukor auf und übergibt ihm unseren Fehlerstring. Dieser Vater Konstruktor ist in java.lang.Exception definiert.

Die Klasse java.lang.Exception und damit auch unserer enthält Methoden um auf diesen Fehlerstring zuzugreifen. Eine wichtige ist String getMessage () die, den Fehlerstring zurückliefert.

Wie "wirft" man eine Exception?

Das ich "wirft" in Gänsefüsse gesetzt habe, hat seinen Grund. In Java werden Exception durch das Schlüsselwort throw geworfen. Doch bevor man eine Exception werfen kann, muss man dem System erst mitteilen welche Methode welche Exceptions wirft. Dies geschieht durch Angabe im Methoden Kopf mit dem Schlüsselwort "throws".

public class MeinFehlerProgramm {
...
   public static void IchHabNenFehler (int i) throws MyOwnException {
      }
...
   }
    

Stellt einen Beispiel Methoden Kopf dar. Mehrere Exceptions werden durch Komma getrennt hinter throws angegeben. Eigentlich nichts besonderes. Die Klasse macht nichts weiter als Java zu sagen "Hier wird könnte eine "MyOwnException" geworfen werden". Wie man nun unsere Exception wirft, zeigt folgendes Beispiel.

public class MeinFehlerProgramm {
...
   public static void IchHabNenFehler (int i) throws MyOwnException {
      if (i < 1) {
         throw new MyOwnException ("Wert zu klein");
         }
      }
...
   }
    

Wenn der übergebene Parameter i kleiner als 1 ist, wird eine Exception geworfen. Dazu wird eine Instanz unserer "MyOwnException" Klasse mit new erzeugt. Diese Instanz wird durch throw an das Java Laufzeit System übergeben und dieses sucht dann nach dem Code (bzw. weiss es schon vorher), der den Fehler behandelt.

Der Code der den Fehler behandelt

Jede Exception die unser Programm werfen soll muss irgendwo behandelt werden. Sonst wirft Java beim kompilieren einen Fehler. Dies geschieht durch try - catch Blöcke. Der try Block enthält unseren normalen Programm Quelltext in dem auch unsere "IchHabNenFehler" Methode vorkommen muss. Der catch Block enthält Code, der ausgeführt wird wenn das Programm den Fehler wirft. Dabei muss es für jeden möglichen Fehler im try Block einen catch Block geben.

public class MeinFehlerProgramm {

   public static void IchHabNenFehler (int i) throws MyOwnException {
      if (i < 1) {
         throw new MyOwnException ("Wert zu klein");
         }
      }

   public static void main (String [] argv) {
      try {
         // hier wird kein Fehler geworfen
         IchHabNenFehler (5);
         // hier wird ein fehler geworfen und im
         // "catch" Block weitergearbeitet
         IchHabNenFehler (0);
         // Dieser Code wird nie ausgeführt
         System.out.println ("Hallo Welt");
         }
      catch (MyOwnException moe) {
         System.out.println (moe.getMessage ());
         System.exit (1);
         }
      }  
   }
    

Im grünen Teil wird das Programm normal abgearbeitet bis der Fehler auftritt. Dann wird in den roten Teil gesprungen, die Fehler Meldung ausgegeben und das Programm mit Fehlercode 1 beendet.

Quellen und Infos

top