First develop commit. Adding all existing files.

srcDE/diesunddas/Rekursiv.java

@@ -0,0 +1,36 @@
+package diesunddas;
+
+import java.util.Arrays;
+
+public class Rekursiv {
+	double array[];
+	
+	public Rekursiv(double[] arra){
+		array = arra;
+	}
+	
+	public int länge(){
+		return länge(0);
+	}
+	
+	public int länge(int z){
+		z++;
+		try{
+			@SuppressWarnings("unused")
+			double test = array[z];
+			return länge(z);
+		} catch(Exception e){
+			return z;
+		}
+	}
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		Rekursiv arr = new Rekursiv(new double[]{0,1,2,3});
+		System.out.println(Arrays.toString(arr.array));
+		System.out.println(arr.länge());
+	}
+
+}

srcDE/diesunddas/Strecke.java

@@ -0,0 +1,52 @@
+package diesunddas;
+
+public class Strecke{
+	
+	enum Einheit{
+		m(1),
+		km(1e3),
+		cm(0.01),
+		mm(0.001);
+		
+		private double faktor;
+		
+		Einheit(){}
+		Einheit(double faktor){ this.faktor = faktor; }
+		
+		double faktor(){ return faktor; }
+	}
+	
+	double länge;
+	Einheit einheit = Einheit.m;
+
+	public Strecke(double länge){
+		this.länge = länge;
+	}
+	
+	public Strecke(double länge, Einheit einheit){
+		this.länge = länge;
+		this.einheit = einheit;
+	}
+	
+	public Strecke plus(Strecke dazu){
+		return new Strecke(länge+dazu.länge*dazu.einheit.faktor()/einheit.faktor(), einheit);
+	}
+	
+	@Override
+	public String toString(){
+		return länge+" "+einheit;
+	}
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		Strecke heimweg = new Strecke(10, Einheit.km);
+		Strecke bäcker = new Strecke(420, Einheit.m);
+		System.out.println(heimweg);
+		System.out.println(bäcker);
+		System.out.println(heimweg.plus(bäcker));
+		System.out.println(bäcker.plus(heimweg));
+	}
+
+}

srcDE/diesunddas/Würfel.java

@@ -0,0 +1,52 @@
+package diesunddas;
+
+/**
+ * @author Daniel Weschke
+ *
+ */
+public class Würfel{
+	
+	/**
+	 * Würfelname
+	 */
+	private int würfel = 1;
+	
+	/**
+	 * Maximale Würfelaugen / Anzahl der Flächen
+	 */
+	private int augen = 6;
+	
+	public Würfel(int würfel){
+		this.würfel = würfel;
+	}
+	
+	public Würfel(int würfel, int augen){
+		this.würfel = würfel;
+		this.augen = augen;
+	}
+	
+	public int getWürfel(){
+		return würfel;
+	}
+	
+	// TODO
+	public int add(Würfel würfel){
+		return wurf() + würfel.wurf();
+	}
+	
+	public int wurf(){
+		return (int) (Math.random()*augen+1);
+	}
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		Würfel w = new Würfel(3);
+		for(int i=0;i<20; i++) System.out.println(w.wurf());
+		System.out.println();
+		Würfel w2 = new Würfel(5,9);
+		for(int i=0;i<20; i++) System.out.println(w2.wurf());
+	}
+
+}

srcDE/mathe/Bruch.java

@@ -0,0 +1,225 @@
+package mathe;
+
+/**
+ * Bearbeitung von Brüchen.
+ * 
+ * @author Daniel Weschke
+ *
+ */
+public class Bruch{
+	int zähler;
+	int nenner;
+	
+	/**
+	 * Bruch mit Nenner 1.
+	 */
+	public Bruch(){
+		nenner = 1;
+	}
+	
+	/**
+	 * Bruch mitübergebenen zähler und Nenner 1.
+	 * 
+	 * @param z zähler
+	 */
+	public Bruch(int z){
+		this();
+		zähler = z;
+	}
+	
+	/**
+	 * Bruch mitübergebenen zähler und Nenner.
+	 * 
+	 * @param z zähler
+	 * @param n Nenner
+	 */
+	public Bruch(int z, int n){
+		this(z);
+		if(n>0) nenner = n;
+	}
+
+	/**
+	 * Custom Constructor, der aus einer Gleitkommazahl einen Bruch ermittelt.
+	 * Um Rundungsfehler zu vermeiden wird der Bruch ueber die Stringdarstellung der Gleitkommazahl ermittelt.
+	 * @param gleitKommaZahl Zahl, die in einen Bruch umgewandelt werden soll.
+	 */
+	public Bruch(double gleitKommaZahl) {
+
+		// Damit keine Rundungsfehler auftreten die Zahl in einen String wandeln
+		String ds = "" + gleitKommaZahl;
+
+		// String am Punkt splitten
+		// Achtung: Beim Splitten ist der Punkt ein Sonderzeichen,
+		// daher der Umweg ueber ein "beliebiges" Zeichen (hier "p")
+		ds = ds.replace(".", "p");
+		String[] sa = ds.split("p");
+
+		// Zaehler und Nenner bestimmen
+		nenner = (int) Math.pow(10, sa[1].length());
+		zähler = (int) (gleitKommaZahl * nenner);
+
+		// Den Bruch kuerzen
+		int faktor = ggt_fast(zähler, nenner);
+		nenner /= faktor;
+		zähler /= faktor;
+		
+		// Die Assertion prueft, ob der Nenner != 0 ist.
+		// Falls die Auswertung true ergibt ist alles OK
+		assert nenner != 0 : "Division durch 0!";
+
+		// Testen, ob das Ergebnis stimmt oder ob Rundungsfehler vorhanden sind
+		assert 1.0 * zähler / nenner == gleitKommaZahl : "Rundungsfehler!!";
+	}
+
+	/**
+	 * Addition zweier Brüche.
+	 * 
+	 * @param a zu addierender Bruch
+	 * @return Summe
+	 */
+	public Bruch plus(Bruch a){
+		return new Bruch(zähler*a.nenner+a.zähler*nenner,nenner*a.nenner);
+	}
+
+	/**
+	 * Subtraktion zweier Brüche.
+	 * 
+	 * @param a zu subtrahierender Bruch
+	 * @return Differenz
+	 */
+	public Bruch minus(Bruch a){
+		Bruch b = new Bruch(-a.zähler,a.nenner);
+		return this.plus(b);
+	}
+
+	/**
+	 * Multikation zweier Brüche.
+	 * 
+	 * @param a zu multiplizierder Bruch
+	 * @return Produkt
+	 */
+	public Bruch mal(Bruch a){
+		return new Bruch(zähler*a.zähler,nenner*a.nenner);
+	}
+
+	/**
+	 * Division zweier Brüche.
+	 * 
+	 * @param a zu dividierender Bruch
+	 * @return Verhältnis
+	 */
+	public Bruch durch(Bruch a){
+		return this.mal(a.kehrwert());
+	}
+
+	/**
+	 * Kehrwert vom Bruch.
+	 * 
+	 * @return Reziprok
+	 */
+	public Bruch kehrwert(){
+		return new Bruch(nenner,zähler);
+	}
+	
+	/**
+	 * Gößten gemeinsamen Teiler vom Bruch.
+	 * Nach dem klassischen euklidischen Algorithmus.
+	 * 
+	 * @return größten gemeinsamen Teiler
+	 */
+	public int ggt(){
+		int a = zähler<0 ? -zähler : zähler;
+		int b = nenner<0 ? -nenner : nenner;
+		if(a>0 && b>0){
+			while(a!=b){
+				if(a>b){
+					a = a - b;
+				} else {
+					b = b - a;
+				}
+			}
+		}
+		return a;
+	}
+	
+	/**
+	 * Größter gemeinsamer Teiler vom Bruch.
+	 * Nach dem modernen euklidischen Algorithmus.
+	 * 
+	 * @return größten gemeinsamen Teiler
+	 */
+	public int ggt_fast(){
+		int a = zähler<0 ? -zähler : zähler;
+		int b = nenner<0 ? -nenner : nenner;
+		int c;
+		if(a>0 && b>0){
+			while(b!=0){
+				c = a%b;
+				a = b;
+				b = c;
+			}
+		}
+		return a;
+	}
+	
+	/**
+	 * Größter gemeinsamer Teiler vom Bruch.
+	 * Nach dem modernen euklidischen Algorithmus.
+	 * 
+	 * @return größten gemeinsamen Teiler
+	 */
+	public int ggt_fast(int zähler, int nenner){
+		int a = zähler<0 ? -zähler : zähler;
+		int b = nenner<0 ? -nenner : nenner;
+		int c;
+		if(a>0 && b>0){
+			while(b!=0){
+				c = a%b;
+				a = b;
+				b = c;
+			}
+		}
+		return a;
+	}
+	
+	/**
+	 * Kürzen des Bruches.
+	 * 
+	 * @return gekürzter Bruch
+	 */
+	public Bruch kürzen(){
+		if(zähler!=0 && nenner!=0)
+			return new Bruch(zähler/ggt(),nenner/ggt());
+		else
+			return this;
+	}
+	
+	/**
+	 * Vergleich zweier Brüche.
+	 * 
+	 * @param q zu vergleichender Bruch
+	 * @return Bitcode:<br />
+	 * <code> 1</code> Bruch ist größer<br />
+	 * <code>-1</code> Bruch ist kleiner<br />
+	 * <code> 0</code> Bruch ist gleich groß<br />
+	 */
+	public int compareTo(Bruch q){
+		double a = (double) zähler/nenner;
+		double b = (double) q.zähler/q.nenner;
+		if(a > b) return 1;	else
+		if(a < b) return -1; else
+		return 0;
+	}
+
+	/**
+	 * Textumwandlung zur Ausgabe.
+	 */
+	@Override
+	public String toString(){
+		Bruch a = this.kürzen();
+		if(a.nenner!=1)
+			return new String(a.zähler + "/" + a.nenner);
+		else
+			return new String(""+a.zähler);
+	}
+}