Index: /oop/DatumTest.java
===================================================================
--- /oop/DatumTest.java	(revision 245)
+++ /oop/DatumTest.java	(revision 245)
@@ -0,0 +1,11 @@
+package eu.hsrw.tr.prog.vl.oop;
+
+public class DatumTest {
+
+	public static void main(String[] args) {
+		Datum d = new Datum(21, 11, 2016);
+		
+		System.out.println(d);
+	}
+
+}
Index: /oop/PersonTest.java
===================================================================
--- /oop/PersonTest.java	(revision 245)
+++ /oop/PersonTest.java	(revision 245)
@@ -0,0 +1,15 @@
+package eu.hsrw.tr.prog.vl.oop;
+
+public class PersonTest {
+
+	public static void main(String[] args) {
+		Person p = new Person("Susi", "Sommer", 16, 7, 1997);
+		
+		Person t = p;
+		
+		t.gebdat.jahr--;
+		
+		System.out.println(p + " ist " + p.alter() + " Jahre alt.");
+	}
+
+}
Index: /rekursion/SudokuSolverRekursiv.java
===================================================================
--- /rekursion/SudokuSolverRekursiv.java	(revision 245)
+++ /rekursion/SudokuSolverRekursiv.java	(revision 245)
@@ -0,0 +1,155 @@
+package eu.hsrw.tr.prog.vl.rekursion;
+
+/**
+ * Löst 9x9 Sudokus mittels Brute Force und Backtracking: Durchprobieren von
+ * oben links nach unten rechts
+ * 
+ * @author Thomas Richter
+ * 
+ */
+public class SudokuSolverRekursiv {
+
+	/**
+	 * Testet, ob die Zahl an der Stelle ohne Verletzung der Sudokubedingung
+	 * eingefügt werden kann.
+	 * 
+	 * @param a
+	 *            9x9 Array mit dem Sudoku
+	 * @param zeile
+	 *            Zeile der zu prüfenden Zelle
+	 * @param spalte
+	 *            Spalte der zu prüfenden Zelle
+	 * @param kandidat
+	 *            Kandidat für die Einfügung
+	 * @return false, falls die Kandidatenzahl die Sudkobedingung verletzt,
+	 *         sonst true
+	 */
+	public static boolean kandidatOK(int[][] a, int zeile, int spalte, int kandidat) {
+		// Feststellen in welchem Block wir eigentlich sind -> wir benötigen die
+		// kleinste Zeile und die kleinste Spalte dieses Blocks als Offset
+		int offsetZ = (zeile / 3) * 3;
+		int offsetS = (spalte / 3) * 3;
+		
+		for (int i = 0; i < a.length; i++) {
+			
+			// teste Zeile, Spalte, Block, in dieser Reihenfolge
+			if (Math.abs(a[zeile][i]) == kandidat
+				|| Math.abs(a[i][spalte]) == kandidat
+				|| Math.abs(a[offsetZ + i / 3][offsetS + i % 3]) == kandidat) {
+				
+				return false;
+			}
+		}
+		return true;		
+	}
+
+	/**
+	 * Löst das übergebene 9x9 Sudoku mittels Brute Force und Backtracking: Es
+	 * wird mit dem Feld oben links begonnen und dann spalten- und zeilenweise
+	 * nach rechts unten gearbeitet. Als erster Wert wird die 1 versucht. Falls
+	 * der Versuch einen Konflikt auslöst, wird die Zahl immer weiter erhöht,
+	 * bis entweder kein Konflikt mehr auftritt oder die Zahl 10 erreicht wurde.
+	 * Falls 10 erreicht wurde konnte kein passender Eintrag gefunden werden,
+	 * das Problem muss also schon weiter vorn liegen. Es wird um ein Feld
+	 * zurückgegangen und dort die nächsthöhere Zahl versucht. Ggf. sind sehr
+	 * viele Rücksprünge erforderlich, da viele Kombinationen durchprobiert
+	 * werden müssen.
+	 * 
+	 * @param a
+	 *            zu lösendes Sudoku als 9x9 Array
+	 */
+	public static boolean solve(int[][] a, int feld) {
+		// sind wir fertig?
+		if (feld == 81) {
+			return true;
+		}
+		
+		int zeile = feld / 9;
+		int spalte = feld % 9;
+		
+		// ist das Feld vorbelegt?
+		if (a[zeile][spalte] != 0) {
+			return solve(a, feld + 1);
+		}
+		
+		// Zahl testen
+		for (int kandidat = 1; kandidat <= 9; kandidat++) {
+			if (kandidatOK(a, zeile, spalte, kandidat)) {
+				a[zeile][spalte] = kandidat;
+				if (solve(a, feld + 1)) {
+					return true;
+				}
+			}	
+		}
+		
+		// keine Zahl hat gepasst
+		// aktuelle Zelle nullen und zurückspringen
+		a[zeile][spalte] = 0;
+		return false;
+	}
+
+	/**
+	 * Gibt ein Sudoku auf der Konsole aus
+	 * 
+	 * @param a
+	 *            zweidimensionales Array mit dem Sudoku
+	 */
+	public static void printSudoku(int[][] a) {
+		System.out.println("\n----------------------");
+
+		for (int i = 0; i < a.length; i++) {
+			System.out.print("|");
+			for (int j = 0; j < a[i].length; j++) {
+				System.out.print(Math.abs(a[i][j]) + " ");
+				if (j % 3 == 2) {
+					System.out.print("|");
+				}
+			}
+			if (i % 3 == 2) {
+				System.out.print("\n----------------------");
+			}
+			System.out.println();
+		}
+	}
+
+	public static void main(String[] args) {
+
+		// Beispiele für schnell und langsam zu lösende Sudokus
+		int[][] sudokuLeer = new int[9][9];
+
+		int[][] sudokuSchnell = {
+				{ 0, 0, 5, 0, 0, 0, 0, 6, 0},
+				{ 0, 0, 8, 7, 0, 0, 0, 0, 0},
+				{ 0, 0, 0, 0, 3, 0, 0, 0, 9},
+				{ 0, 0, 0, 0, 0, 6, 0, 0, 0},
+				{ 0, 0, 3, 0, 0, 0, 0, 0, 7},
+				{ 0, 0, 0, 5, 0, 0, 0, 4, 0},
+				{ 0, 9, 0, 0, 0, 1, 0, 0, 0},
+				{ 0, 6, 0, 0, 0, 0, 7, 0, 0},
+				{ 0, 0, 0, 0, 0, 5, 0, 0, 8}
+		};
+
+		int[][] sudokuLangsam = {
+				{ 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{ 0, 0, 0, 0, 0, 0, 9, 6, 0},
+				{ 5, 8, 0, 0, 3, 0, 0, 0, 0},
+				{ 0, 7, 0, 0, 0, 5, 0, 0, 0},
+				{ 0, 0, 3, 0, 0, 0, 0, 0, 0},
+				{ 0, 0, 0, 6, 0, 0, 1, 0, 5},
+				{ 0, 0, 0, 0, 0, 0, 0, 7, 0},
+				{ 6, 0, 0, 0, 0, 4, 0, 0, 0},
+				{ 0, 0, 9, 0, 7, 0, 0, 0, 8}
+		};
+
+		int[][] sudoku;
+		sudoku = sudokuLangsam;
+		// sudoku = sudokuLangsam;
+		// sudoku = sudokuLeer;
+
+		printSudoku(sudoku);
+
+		solve(sudoku, 0);
+
+		printSudoku(sudoku);
+	}
+}
