Initial commit of the source files.

src/Anwendung.java

@@ -0,0 +1,3 @@
+public class Anwendung {
+
+}

src/Befehl.java

@@ -0,0 +1,58 @@
+/**
+ * Objekte dieser Klasse halten Informationen ueber Befehle, die der Benutzer
+ * eingegeben hat. Ein Befehl besteht momentan aus zwei Zeichenketten: einem
+ * Befehlswort und einem zweiten Wort. Beim Befehl "nimm karte" beispielsweise
+ * sind die beiden Zeichenketten "nimm" und "karte".
+ * 
+ * Wenn der Befehl nur aus einem Wort bestand, dann ist das zweite Wort <null>.
+ * 
+ * @author tebe
+ * @version 20.10.2013
+ */
+
+class Befehl {
+	private String befehlswort;
+	private String zweitesWort;
+
+	/**
+	 * Erzeuge ein Befehlsobjekt. Beide Woerter muessen angegeben werden, aber
+	 * jedes oder beide duerfen 'null' sein. Ist das erste Wort 'null', wird der
+	 * Befehl als nicht verstanden betrachtet. Ist das zweite Wort 'null' wurde
+	 * kein zweites Wort angegeben. 
+	 * 
+	 * @param befehlswort
+	 *            Das erste Wort des Befehls. 
+	 * @param zweitesWort
+	 *            Das zweite Wort des Befehls.
+	 */
+	public Befehl(String befehlswort, String zweitesWort) {
+		this.befehlswort = befehlswort;
+		this.zweitesWort = zweitesWort;
+	}
+
+	/**
+	 * Liefere das Befehlswort (das erste Wort) dieses Befehls. 
+	 * 
+	 * @return Das Befehlswort.
+	 */
+	public String gibBefehlswort() {
+		return befehlswort;
+	}
+
+	/**
+     * Liefere das zweite Wort dieses Befehls. 
+     * Liefere 'null', wenn es kein zweites Wort gab.
+	 * @return Das zweite Wort dieses Befehls. 
+	 */
+	public String gibZweitesWort() {
+		return zweitesWort;
+	}
+
+	/**
+	 * Testet, ob dieser Befehl ein zweites Wort hat.
+	 * @return 'true', wenn dieser Befehl ein zweites Wort hat.
+	 */
+	public boolean hatZweitesWort() {
+		return (zweitesWort != null);
+	}
+}

src/Befehlswort.java

@@ -0,0 +1,53 @@
+import java.util.ArrayList;
+import java.util.HashSet;
+
+/**
+ * Diese Klasse haelt eine Aufzaehlung der akzeptierten Befehlswoerter.
+ * Mit ihrer Hilfe werden eingetippte Befehle erkannt.
+ *
+ * @author  tebe
+ * @version 1.0
+ */
+public class Befehlswort {
+
+	// Ein HashSet mit den gueltigen Befehlswoertern als Klassenvariable
+	private static final HashSet<String> gueltigeBefehle = new HashSet<String>();
+	static {
+		gueltigeBefehle.add("gehe");
+		gueltigeBefehle.add("beenden");
+		gueltigeBefehle.add("hilfe");
+	}
+
+	/**
+	 * Konstruktor - initialisiere die Befehlswörter.
+	 */
+	public Befehlswort()
+	{
+		// tut momentan nichts
+	}
+
+	/**
+	 * Pruefe, ob eine gegebene Zeichenkette ein gueltiger
+	 * Befehl ist.
+	 * 
+	 * @return 'true', wenn die gegebene Zeichenkette ein gueltiger
+	 *         Befehl ist, 'false' sonst.
+	 */
+	public static boolean istBefehl(String eingabe)
+	{
+		return gueltigeBefehle.contains(eingabe);
+	}
+
+	/**
+	 * Gibt die akzeptierten Befehlsworte als Text zurueck.
+	 * 
+	 * @return Die akzeptierten Befehlsworte als Text
+	 */
+	public static String gibBefehlsworteAlsText() {
+		String text = "";
+		for (String befehl : gueltigeBefehle) {
+			text = text + befehl + " ";
+		}
+		return text;
+	}
+}

src/Kontroller.java

@@ -0,0 +1,39 @@
+/**
+ * Diese Klasse verarbeitet Befehle vom Typ
+ * {@link Befehl Befehl} und lösst die dazu 
+ * passenden Aktionen aus.
+ * 
+ * @author tebe
+ *
+ */
+public class Kontroller {
+	/**
+	 * Verarbeite einen gegebenen Befehl
+	 * 
+	 * @param befehl
+	 *            Der zu verarbeitende Befehl.
+	 * @return 'false', wenn ein Abbruchbefehl verarbeitet wurde
+	 */
+	public boolean verarbeiteBefehl(Befehl befehl) {
+		boolean macheWeiter = true;
+		String befehlswort = befehl.gibBefehlswort();
+		if (Befehlswort.istBefehl(befehlswort)) {
+
+			if (befehlswort.equals("gehe")) {
+				System.out.println("Befehl GEHE " + befehl.gibZweitesWort() + " wird ausgefuehrt");
+			} else if (befehlswort.equals("hilfe")) {
+				System.out.println("Gueltige Befehle: "
+						+ Befehlswort.gibBefehlsworteAlsText());
+			} else if (befehlswort.equals("beenden")) {
+				System.out.println("Befehl BEENDEN wird ausgefuehrt.");
+				macheWeiter = false;
+			} else {
+				System.out.println("Befehlswort ohne zugehoerige Aktion: Abbruch.");
+				macheWeiter = false;
+			}
+		} else {
+			System.out.println("Ich weiss nicht, was Sie meinen...");
+		}
+		return macheWeiter;
+	}
+}

src/Parser.java

@@ -0,0 +1,40 @@
+import java.util.Scanner;
+
+/**
+ * Dieser Parser liest Benutzereingaben und wandelt sie in Befehle um. Bei jedem
+ * Aufruf liest er eine Zeile von der Konsole und versucht, diese als einen
+ * Befehl aus bis zu zwei Woertern zu interpretieren. Er liefert den Befehl als
+ * ein Objekt der Klasse Befehl zurueck.
+ * 
+ * Der Parser verfuegt ueber einen Satz an bekannten Befehlen. Er
+ * vergleicht die Eingabe mit diesen Befehlen. Wenn die Eingabe
+ * keinen bekannten Befehl enthaelt, dann liefert der Parser ein als 
+ * unbekannter Befehl gekennzeichnetes Objekt zurueck.
+ * 
+ * @author tebe
+ * @version 18.10.2013
+ */
+class Parser {
+    // Lieferant fuer eingegebene Befehle
+    private Scanner leser = new Scanner(System.in);
+
+    /**
+     * @return Der naechste Befehl des Benutzers.
+     */
+    public Befehl liefereBefehl() {
+        Befehl befehl;
+        String eingabezeile; // fuer die gesamte Eingabezeile
+
+        System.out.print("> "); // Eingabeaufforderung
+        eingabezeile = leser.nextLine();
+        String[] woerter = eingabezeile.split(" ");
+
+        if (woerter.length >= 2) {
+            befehl = new Befehl(woerter[0], woerter[1]);
+        } else {
+            befehl = new Befehl(woerter[0], null);
+        }
+        return befehl;
+    }
+
+}