Es gibt immer mal wieder Stellen, an denen es passieren kann, das Ausnahmen, unvorhergesehene Ereignisse also, eintreten können. Und die sollte behandelt werden, wenigstens insofern, das eine Meldung generiert wird, die den Nutzer darüber informiert, das etwas schief gelaufen ist.

Grundsätzlich lässt sich aber sagen, das ist meine persönliche Empfindung, das Fehler, also Error im Programmablauf nicht behandelt werden sollten, da sie den Programmablauf derart stören und negativ beeinflussen, das die JVM die Ausführung des Programm abbricht und mit der Ausgabe des StackTrace reagiert.

Treten dahin gegen Exceptions auf, also ein Programm erwartet Integer-Werte und der Benutzer tippt aber Fließkomma-Zahlen ein, dann kann man eine Abfolge erstellen, wie darauf reagiert werden soll, diese verhält sich nach dem Prinzip
try-catch-finally.

// ...

try
{
    System.out.println("Zahl eingeben: ");
    int i = Integer.parseInt(br.readLine());
}
catch(IOException ioEx)
{
    System.out.println("Es ist ein I/O-Fehler aufgetreten!");
}
catch(NumberFormatException nfEx)
{
    System.out.println("Fehlerhafte Eingabe! Nur Ganzzahl-Werte eingeben!");
    try
    {
           System.out.println("Zahl eingeben: ");
           int i = Integer.parseInt(br.readLine());
    }
    catch(NumberFormatException nfEx2)
    {
           System.out.println("2x der gleiche Fehler! Programm wird beendet!");
           System.exit(0);
    }
}
finally
{
    System.out.println("Bitte den finally-Block nicht vergessen!");
}

Im obigen Beispiel wird eine ganze Zahl vom Benutzer erwartet, stimmt bei der Eingabe etwas nicht, kann entweder eine IOException geworfen (thrown) werden oder eine NumberFormatException, die hier exemplarisch behandelt wird, indem darauf hingewiesen wird, das nur ganze Zahlen verarbeitet werden können. Anschließend darf der Benutzer erneut eine Eingabe machen, schlägt diese wieder fehlt beendet sich das Programm mit System.exit(0);

Am Ende fällt noch der finally Block ins Auge, dieser spielt in diesem Beispiel noch keine Rolle, doch sollte man sich z.B. mit Netzwerkprogrammierung o.ä. Dingen beschäftigen, dann spielt er eine entscheidende Rolle, denn tritt eine Verbindungsexception auf, dann wird diese behandelt und kann vorzeitig zum Abbruch oder Verlassen des try-catch Blockes führen und das Programm beenden, doch die Verbindung zur Datenbank oder zum Server wäre nach wie vor geöffnet, um das zu vermeiden, schließt man die Verbindung innerhalb des finally Blocks, denn der wird immer ausgeführt, egal wie oder wo die Fehlerbehandlung beendet oder verlassen wird.

Somit haben wir ein Grundtemplate zur Fehlerbehandlung erstellt und es kann mit eigenen Versuchen mit Leben gefüllt werden.

Viel Spaß und einen schönen Sonntag!

Was passiert? Klar, das Programm wird beendet, mit jeder Menge Text auf der Konsole. Für den User / Kunden äußerst nervig.

Was könnten wir dagegen tun?
Den Fehler behandeln. Das klappt recht leicht und ist einfach zu implementieren.

Bleiben wir beim Scanner, dieser könnte uns eine InputMismatchException werfen, behandelt wird das Ganze so:

import java.util.*;

public class ScannerException
{
  public static void main(String[] args)
  {
     Scanner sc = new Scanner();
     try
     {
       double zahl = Doubler.parsDouble(sc.nextDouble());
     }
     catch(InputMismatchException imEx)
     {
       System.out.println(imEx.getMessage());
     }
  }
}

Somit sei gezeigt, wie der Fehler erst einmal gefangen und behandelt werden kann. Diese Lösung zeigt erst einmal das Grundprinzip, welches natürlich noch ausbaufähig ist.

package linearLists;

public class linearList {

	class Node {

		Object element;
		Node next;

		public Node() {
			element = null;
			next 	= null;
		}
		public Node(Object o, Node n){
			element = o;
			next	= n;
		}
		public Object getElement(){
			return element;
		}
		public void setElement(Object o){
			element = o;
		}
		public void setNext(Node n){
			next = n;
		}
		public Node getNext(){
			return next;
		}
	}

	private Node head;

	public linearList(){
		head = new Node();
	}

	public void addElement(Object o, Node n){
		Node p = new Node(o, n);
		p.setNext(head.getNext());
		head.setNext(p);
	}
	public void addFirst(Object o){
		Node p = new Node();
		p = head;
		while(p.getNext() != null)
			p = p.getNext();
		addElement(o, p);
	}
	public String toString(){
		String rc = "";
		Node p = head;
		while(p.getNext() != null){
			rc += "Object = " + p.getElement() + " next Node = " + p.getNext().getElement() + "\n";
			p = p.getNext();
		}
		return rc;
	}

	public static final void main(String[] args){

		linearList ll = new linearList();
		ll.addFirst("Ich bin das erste Element");
		ll.addFirst("Ich bin das zweite Element");
		ll.addFirst("Ich bin das dritte Element");
		ll.addFirst(4711);

		System.out.println(ll);
	}
}

Viel Spaß damit.
Kritik oder Verbesserungsvorschläge sehr gern per Kommentar oder Mail.

package TürmeVonHanoi;

public class ToH {

	static int counter = 0;
	public static void move(int n, String a, String b, String c){

		if ( n == 1){
			System.out.println("moved slice " + n + " from " + a + " to " + c);
		}
		else
		{
			move(n-1, a, c, b);
			System.out.println("moved slice " + n + " from " + a + " to " + c);
			move(n-1, b, c, a);
			++counter;
		}
	}

	public static final void main(String[] args){

		int slices = 128;
		String a = "Source", b = "Help", c = "Target";
		move(slices, a, b, c);
		System.out.println("After " + counter + " movements all slices are moved from " + a + " to " + c);
	}
}

package TürmeVonHanoi;

public class TürmeVonHanoi {

	static long zähler = 0;
	public static void move(int n, String a, String b, String c){

		if(n == 1){

			System.out.println("moved Part " + n + " from " + a + " to " + c);
		}
		else
		{
			move(n-1, a, c, b);
			System.out.println("moved Part " + n + " from " + a + " to " + c);
			move(n-1, b, a, c);
			++zähler;
		}

	}
	public static final void main(String[] args){

		int n = 7;
		String a = "Quelle", b = "Hilfsstab", c = "Ziel";
		move(n, a, b, c);

		System.out.println(zähler);
	}
}

Die vereinbarte Variable n in der Main-Methode gibt an, wie viele Scheiben zu Beginn auf dem ersten Stab liegen und im Laufe des Programms auf den Stab c verschoben werden müssen.
Ziel ist es, dass immer nur 1 Scheibe verschoben wird, niemals eine größere auf einer kleineren Scheibe liegen darf und am Ende der gesamte Turm, in der richtigen Reihenfolge, auf dem Stab c (Ziel) liegt. Der Stab b darf als Hilfe zum Ablegen von Scheiben genutzt werden. Zu jedem Zeitpunkt darf auf jedem Stab ein Turm aus Scheiben liegen, wichtig ist nur, das die oben genannte Regel eingehalten wird (keine größere auf einer kleineren Scheibe!)

Viel Spaß beim Ausprobieren.

public class Lotto {

	public static int zufallsZahl(){

		return (int) (1+(Math.random()*9));
	}
	public static int[] sechsAus49(){

		int[] lottoPool = new int[49];
		int[] ziehung = new int[7];

		for(int i = 1; i < lottoPool.length; ++i){
			lottoPool[i] = i;
		}

		for(int i = 0; i < 7; ++i){

			// 6 aus 49 ziehen
			for(int j = 0; j < ziehung.length-1; ++j){
				int los = (int) (1+(Math.random()*49));
				if (ziehung[j] != los){
					ziehung[i] = los;
				}
			}

		}
		return ziehung;
	}
	public static final void main(String[] args){

		int[] sechsAus49 = new int[7];
		sechsAus49 = sechsAus49();
		int n = 0;
		System.out.print("6 aus 49: ");
		for(int i: sechsAus49){
			if(++n < 7){
			System.out.print(i + ", ");
			}
			else
				System.out.print("Zusatzzahl: " + i);
		}
		System.out.println();
		System.out.println("Superzahl: " + zufallsZahl());
		System.out.print("Spiel 77: ");
                int[] spiel77 = new int[7];
		for(int i = 0; i < 7; ++i){
                        int zahl = zufallsZahl();
                        if(zahl != spiel77[i]{
                           spiel77[i] = zahl;
                        }
		}
                for(int i : spiel77)
                   System.out.print(i + ", ");
		System.out.println();
		System.out.print("Super 6: ");
                int[] super6 = new int[6];
		for(int i = 0; i < 6; ++i) {
                    int zahl = zufallsZahl();
                        if(zahl != super6[i]{
                           super6[i] = zahl;
                        }
		}
                for(int i : super6)
                   System.out.print(i + ", ");

}

Ich habe versucht einen Stackspeicher in Java abzubilden.
Aus dieser Aufgabenstellung sind folgende Klassen und Interface(s) entstanden:

Das Interface IStack, das dafür sorgt, dass eben nicht nur Daten eines Typs im Stack abgelegt werden können, sondern Objecte. Hinweis: Sollen primitive Datentypen, z.B. Integerwerte abgelegt werden, muss man sich der Wrapper Klasse Integer bedienen und ein Integer Objekt seiner abzulegenden Zahl erzeugen, damit das Interface und auch der Stack selbst damit umgehen können.

package Stack;

public interface IStack {

	void push(Object o) throws StackException;
	Object get() throws StackException;
	Object top() throws StackException;
	boolean isEmpty();
}

Die Klasse StackArray, die die Speicherdatenstruktur zur Verfügung stellt und mittels zweier Konstruktoren die Initialisierung eines Stacks ermöglicht.

package Stack;

public class StackArray implements IStack {

	Object[] stack = null;
	int zeiger = 0;
	int l = 0;

	// Konstruktoren
	public StackArray(int anzahl){
		this.stack = new Object[anzahl];
		this.l = stack.length;
	}

	public StackArray(){
		this.stack = new Object[100];
		this.l = stack.length;
	}

	@Override
	public void push(Object o) throws StackException {
		if(zeiger <= l){
			stack[zeiger] = o;
			++zeiger;
		}
		else
		{
			throw new StackException("Fehler! Stack ist voll");
		}
	}

	@Override
	public Object get() throws StackException {
		Object s = stack[zeiger];
		if(!isEmpty()){
			s = stack[zeiger-1];
			stack[zeiger-1] = null;
			zeiger--;
		}
		else
		{
			throw new StackException("Fehler! Element konnte nicht gefunden werden");
		}
			return s;
	}

	@Override
	public Object top() throws StackException {

		return stack[zeiger];
	}

	@Override
	public boolean isEmpty() {
		if(zeiger == 0)
			return true;
		else
			return false;
	}
}

und last but not least natürlich die Applikationsklasse Stack.
Es wird ein Object vom Typ IStack erzeugt und eine Referenz auf StackArray angelegt. Unser Stack soll in diesem Beispiel 50 Speicherplätze bereitstellen.
Anschließend werden ein paar Objekte auf den Stapel gelegt und später, in der while Schleife wieder in umgekehrter Reihenfolge abgerufen, was das LIFO (Last in First out) Prinzip verdeutlichen soll.

package Stack;

public class Stack {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		IStack stack = new StackArray(50);

		try{
			stack.push(new Integer(12));
			stack.push(new Integer(24));
			stack.push("Powerfuel");
			stack.push(new Integer(1));
			stack.push("sieben");
			stack.push(new Integer(54567));
			stack.push(new Integer(3567));
			stack.push(new Integer(66543567));
			stack.push(new Integer(56347));
			stack.push(new Integer(5467));
			stack.push(new Integer(564357));
			stack.push("anderes Object lässt sich sicher auch einfügen");

		}catch(StackException exc){
			System.out.println(exc);
		}

		while(!stack.isEmpty()){
			try{
				Object i =  stack.get();
				System.out.println(i);
			}catch(StackException exc){
				System.out.println(exc);
			}
		}

	}

}

Die Klasse Configuration, sie erstellt uns unsere Register, initialisiert sie am Anfang mit 0 und ist im späteren Programmverlauf dafür zuständig unter zu Hilfenahme des Interface Instruction, Daten in Form von Integerwerten aus den jeweiligen Registern zu lesen und zu speichern.

package Registermaschine;

public class Configuration {
	public final static int NUM_REGISTERS = 20;
	int ic;	// Befehlszähler
	int registers[] = new int[NUM_REGISTERS]; // Register
                                                  // registers[0] = Akkumulator

	public Configuration(){
		init();
	}

	public void init(){
		ic = 0;
		for(int i = 0; i < registers.length; i++){
			registers[i] = 0;
		}
	}

	public int getICounter() {
		return ic;
	}
	public void setICounter(int nic){
		ic = nic;
	}
	public void incICounter() {
		ic++;
	}

	public int getRegister(int i){
		return registers[i];
	}

	public void setRegister(int i, int value){
		registers[i] = value;
	}

	public String toString(){
		StringBuffer sb = new StringBuffer();
		sb.append("icounter = " + (ic + 1));
		for(int i = 0; i < registers.length; i++)
		sb.append(", c[" + i + "] = " + registers[i]);
		return sb.toString();
	}
}

Das Interface Instruction ist schnell erklärt, es stellt die Methode eval bereit, über die im Programmverlauf nachher die eigentliche Verarbeitung in den implementierenden Klassen ablaufen wird.

package Registermaschine;

public interface Instruction {

	void eval(Configuration config);
}

Als nächstes folgen die einzelnen Klassen Load, Mult, Sub, Div, Store und End, die die entsprechenden Operationen, wonach sich ihr Name so anhört, ausführen.
Ich habe mich dazu entschieden jeweils im Akkumulator zu arbeiten, d.h. als erstes wird ein Load Befehl aufgerufen, der aus einem Register einen Wert lädt und ihn in den Akkumulator schreibt, was auch die gängige Praxis auf von-Neumann Architekturen ist.
Rechenoperationen werden nun so ausgeführt, dass der Wert des Akkumulators eingelesen wird und dann z.B. der Wert aus Register 2 davon abgezogen wird und schließlich wird das Ergebnis wieder in den Akkumulator zurück geschrieben. (Der Akkumulator ist ein sehr schnelles Register im L1 Cache, der Prozessor kann mit voller Geschwindigkeit darauf lesen und schreiben)
Folgt im Programmablauf ein Store Befehl, so wird der aktuell im Akkumulator befindliche Wert geladen und in das im Speichern-Befehl angegebene Register geschrieben.

package Registermaschine;

class Div implements Instruction {

	private int reg;

	public Div(int i){
		reg = i;
	}

	@Override
	public void eval(Configuration config) {
		config.setRegister(0, (config.getRegister(0)/config.getRegister(reg)));
		config.incICounter();
	}

	public String toString(){
		return "DIV " + reg;
	}

}

class Mult implements Instruction {

	private int reg;

	public Mult(int i){
		reg = i;
	}

	@Override
	public void eval(Configuration config) {

		config.setRegister(0, config.getRegister(0)*config.getRegister(reg));
		config.incICounter();
	}

	public String toString(){
		return "Mult " + reg;
	}
}

class Sub implements Instruction {

	private int reg;

	public Sub(int i){
		reg = i;
	}

	@Override
	public void eval(Configuration config) {
		config.setRegister(0, config.getRegister(0)-config.getRegister(reg));
		config.incICounter();
	}

	public String toString(){
		return "SUB " + reg;
	}
}

class Store implements Instruction {
	private int reg;

	public Store(int i){
		reg = i;
	}

	@Override
	public void eval(Configuration config) {
		config.setRegister(reg, config.getRegister(0));
		config.incICounter();
	}

	public String toString(){
		return "Store " + reg;
	}
}

class End implements Instruction {

	@Override
	public void eval(Configuration config) {
		// TODO Auto-generated method stub

	}
	public String toString(){
		return "END";
	}
}
class Load implements Instruction {

	private int reg; // Register

	public Load(int i){
		reg = i;
	}
	@Override
	public void eval(Configuration config) {
		// Wert in den Akkumulator laden
		config.setRegister(0, config.getRegister(reg));
		config.incICounter();
	}

	public String toString(){
		return "LOAD " + reg;
	}

}

Last but not least brauchen wir noch die Maschinenimplementierung:

package Registermaschine;

public class Machine {

	private Configuration config 	= null;
	private Instruction[] programm	= null;

	public Machine() {
		config = new Configuration();
	}

	public void setProgram(Instruction[] prog){
		programm = new Instruction[prog.length];
		System.arraycopy(prog, 0, programm, 0, prog.length);
	}

	public void run(){
		while( !programm[config.getICounter()].toString().equals ("END"))
		{
			programm[config.getICounter()].eval(config);
		}
	}

	public void printConfiguration(){
		System.out.println(config);
	}

	public Configuration getConfiguration(){
		return config;
	}

	public static void main(String[] args) {

		Instruction[] prog = {
				new Load (1), new Div (2), new Mult (2),
				new Store (3), new Load (1), new Sub (3),
				new Store (3), new End()
		};

		Machine machine = new Machine();
		machine.setProgram(prog);
		machine.getConfiguration().init();
		machine.getConfiguration().setRegister(1, 32);
		machine.getConfiguration().setRegister(2, 5);

		machine.run();
		machine.printConfiguration();

	}

}

Register 1 und 2 wurden mit Werten vorbelegt, die Methode run() startet die Maschine und arbeitet das Programm ab. Zum Schluss wird die aktuelle Konfiguration ausgegeben und die berechneten Werte auf der Konsole ausgegeben.

Für Verbesserungsvorschläge und/oder Kritiken bin ich offen.

Originalquelle: Algorithmen und Datenstrukturen, Gunter Saake und Kai-Uwe Sattler

Das kostenlos angebotene Tool zur Prozessmodellierung, Business Studio, schaue ich mir gerade etwas genauer an und werde in Kürze über meine Erfahrungen im Umgang damit berichten.

Wer sich über TIBCO näher informieren möchte, dem sei die Homepage ans Herz gelegt!