diff --git a/Besitzer.java b/Besitzer.java
new file mode 100755
index 0000000..6fa5a27
--- /dev/null
+++ b/Besitzer.java
@@ -0,0 +1,112 @@
+
+/**
+ * Klasse für einen Besitzer
+ *
+ * Ein Besitzer hat immer einen Namen und genau einen Motorroller.
+ * Er kann Geld bekommen und weiß, ob er einen Führerschein hat.
+ *
+ * @author J. Neugebauer
+ * @version 1.1
+ */
+public class Besitzer {
+
+	// Objektvariablen deklarieren
+	private String name;
+
+	private double geld;
+
+	private boolean fuehrerschein;
+
+	private Motorroller meinRoller;
+
+	/**
+	 * Konstruktor für Objekte der Klasse Besitzer
+	 */
+	public Besitzer(String pName, double pGeld, boolean pFuehrerschein, Motorroller pMeinRoller) {
+		// Objektvariablen initialisieren
+		name = pName;
+		geld = pGeld;
+		fuehrerschein = pFuehrerschein;
+		meinRoller = pMeinRoller;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public double getGeld() {
+		return geld;
+	}
+
+	public boolean hatFuehrerschein() {
+		return fuehrerschein;
+	}
+
+	/**
+	 * Gibt die Referenz auf das Objekt vom Typ "Motorroller" zurück.
+	 */
+	public Motorroller getMeinenRoller() {
+		return meinRoller;
+	}
+
+	/**
+	 * Ändert die Motorroller-Referenz auf ein neues Objekt vom Typ
+	 * "Motorroller".
+	 */
+	public void setMeinenRoller( Motorroller pNeuerRoller ) {
+		meinRoller = pNeuerRoller;
+	}
+
+	public void taschengeldBekommen( double pBetrag ) {
+		if( pBetrag > 0 ) {
+			geld = geld + pBetrag;
+		}
+	}
+
+	/**
+	 * Tankt den zugeordneten Roller um die angegebene Menge (in Litern) auf.
+	 * Dabei wird zunächst geprüft wie viel Platz noch im Tank ist
+	 * und nur die Menge getankt, die auch noch in den Tank passt.
+	 * Für die getankte Menge müssen pro Liter 1.5 Euro gezahlt werden, die
+	 * vom vorhandenen Geld abgezogen werden.
+	 */
+	public void tankeRoller( double pMenge ) {
+		meinRoller.tanke(pMenge);
+		geld = geld - 1.5*pMenge;
+
+		// TODO:
+		// - Teste die Methode mit verschiedenen Eingaben. Probier
+		//      auch Werte aus, die eigentlich nicht logisch sind (z.B.
+		//      negative Mengen).
+		// - Diese Methode wurde nicht korrekt nach der
+		//      Spezifikation (im Kommentar oben) implementiert.
+		//      Welche Fehler können auftreten?
+		// - Korrigiere so viele Fehler wie möglich.
+		// - Bei dieser Methode ist auch die Spezifikation fehlerhaft.
+		//      Welche möglichen Objektzustände werden dort nicht
+		//      beachtet?
+		// - Ergänze den Kommentar zu einer möglichst exakten Beschreibung.
+	}
+
+	/**
+	 * Fährt den Roller um die angegeben Strecke (in km). Der Besitzer
+	 * prüft zunächst, ob genug Benzin im Tank ist für die Strecke, und fährt
+	 * nur dann los. Er prüft dies, indem er ungefähr den Verbrauch des Rollers
+	 * abschätzt.
+	 */
+	public void fahreRoller( int pStrecke ) {
+		if( meinRoller.getTankinhalt() >= pStrecke ) {
+			meinRoller.fahre(pStrecke);
+		}
+
+
+
+
+		// TODO:
+		// - Der Besitzer schätzt nur grob den Verbrauch seines Rollers ab.
+		//      Wie macht er das?
+		// - Wie könnten die Klassn sinnvoll ergänzt werden, um eine genauere
+		//      Rechnung pro Roller zu ermöglichen?
+		// - Implementiere eure Idee.
+	}
+}
diff --git a/Motorroller.java b/Motorroller.java
new file mode 100755
index 0000000..cda1d12
--- /dev/null
+++ b/Motorroller.java
@@ -0,0 +1,80 @@
+
+/**
+ * Klasse für einen Motorroller
+ *
+ * Ein Motorroller wird von einem Besitzer "besessen" und ist
+ * diesem per Referenz zugeordnet.
+ *
+ * @author J. Neugebauer
+ * @version 1.0
+ */
+public class Motorroller
+{
+    // Attribute deklarieren
+    private int kilometerstand;
+
+    private double tankgroesse;
+
+    private double tankinhalt;
+
+    /**
+     * Konstruktor für Objekte der Klasse Motorroller
+     */
+    public Motorroller( int pKilometerstand, double pTankgroesse, double pTankinhalt )
+    {
+        // Attribute initialisieren
+        kilometerstand = Math.max(0,pKilometerstand);
+        tankgroesse = pTankgroesse;
+        tankinhalt = pTankinhalt;
+
+        // TODO:
+        // - Erstellt ein Objekt mit negativem Kilometerstand und Tankgroesse.
+        // - Warum ist dieses Objekt nicht sinnvoll?
+        // - Verhinder bei der Initialisierung der Attribute die Speicherung
+        //      unsinniger Werte.
+    }
+
+    public int getKilometerstand()
+    {
+        return kilometerstand;
+    }
+
+    public double getTankgroesse()
+    {
+        return tankgroesse;
+    }
+
+    public double getTankinhalt()
+    {
+        return tankinhalt;
+    }
+
+    /**
+     * Tankt den Roller um die übergebene Menge (in Litern) auf. Dabei kann
+     * der Tank nicht voller werden, als durch die Tankgroesse
+     * festgelegt ist. Das zuviel getankte Benzin verfällt einfach.
+     */
+    public void tanke( double pMenge )
+    {
+        tankinhalt += pMenge; // += rechnet "tankinhalt + pMenge" und weist das Ergebnis "tankinhalt" zu
+
+        // TODO:
+        // - Diese Methode wurde nicht korrekt nach der
+        //      Spezifikation (im Kommentar oben) implementiert.
+        //      Was ist fehlerhaft?
+        // - Korrigiere die fehlerhafte Implementierung.
+    }
+
+    /**
+     * Fährt den Roller eine angegebene Strecke (in km). Der Roller verbraucht
+     * pro Kilometer 0.625 Liter Benzin. Ist im Tank nicht genug Benzin für die
+     * volle Strecke, dann fährt der Roller nur so weit, wie er mit dem verbleibenden
+     * Benzin kommt. Der Kilometerstand wird um die gefahrene Strecke hochgezählt.
+     */
+    public void fahre( int pStrecke )
+    {
+        // TODO:
+        // - Diese Methode muss noch nach den Spezifikationen
+        //      oben implementiert werden.
+    }
+}
diff --git a/MotorrollerTest.java b/MotorrollerTest.java
new file mode 100644
index 0000000..e4ebfa0
--- /dev/null
+++ b/MotorrollerTest.java
@@ -0,0 +1,53 @@
+
+
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Die Test-Klasse MotorrollerTest.
+ */
+public class MotorrollerTest
+{
+ 
+    @Test
+    public void testeTanke() {
+        Motorroller m = new Motorroller(1000, 25, 10);
+        
+        assertEquals("Der Tank sollte 10 Liter enthalten", 10, m.getTankinhalt(), 0.0);
+        m.tanke(10);
+        assertEquals("Der Tank sollte 20 Liter enthalten", 20, m.getTankinhalt(), 0.0);
+        m.tanke(10);
+        assertEquals("Der Tank sollte 25 Liter enthalten", 25, m.getTankinhalt(), 0.0);
+        
+        
+        m = new Motorroller(1000, 25, 10);
+        assertEquals("Der Tank sollte 10 Liter enthalten", 10, m.getTankinhalt(), 0.0);
+        m.tanke(-10);
+        assertEquals("Der Tank sollte 0 Liter enthalten", 0, m.getTankinhalt(), 0.0);
+        m.tanke(-10);
+        assertEquals("Der Tank sollte 0 Liter enthalten", 0, m.getTankinhalt(), 0.0);
+    }
+    
+    
+    @Test
+    public void testeFahre() {
+        float verbrauch = 0.625f;
+        
+        Motorroller m = new Motorroller(1000, 25, 10);
+        
+        assertEquals("Der Stand sollte 1000 km betragen", 1000, m.getKilometerstand());
+        m.fahre(6);
+        assertEquals("Der Stand sollte 1006 km betragen", 1006, m.getKilometerstand());
+        m.tanke(1);
+        assertEquals("Der Stand sollte 1006 km betragen", 1006, m.getKilometerstand());
+        
+        
+        m = new Motorroller(1000, 25, 10);
+        
+        assertEquals("Der Stand sollte 1000 km betragen", 1000, m.getKilometerstand());
+        m.fahre(7);
+        assertEquals("Der Stand sollte 1006 km betragen", 1006, m.getKilometerstand());
+    }
+}
diff --git a/Todo.java b/Todo.java
new file mode 100755
index 0000000..2e3a26b
--- /dev/null
+++ b/Todo.java
@@ -0,0 +1,16 @@
+
+public class Todo
+{
+    // TODO:
+    // Schon mit allen anderen TODOs fertig?
+    // - Überlege dir neue Erweiterungen für das Projekt und implementiere sie.
+    //      Hier sind einige Ideen:
+    //      - Ein Polizist, der beim Fahren (mit einer gewissen W'keit)
+    //             die Führerscheine der Fahrer prüft.
+    //      - Eine Tankstelle, an der getankt wird und die variierende
+    //              Benzinpreise hat.
+    //      - Eine Werkstatt, in der die Motorroller "getuned" werden können.
+    //      - Weitere Attribute wie Gewicht, Geschwindigkeit, etc, die
+    //              das Fahren und den Verbrauch beeinflussen.
+
+}
diff --git a/package.bluej b/package.bluej
new file mode 100755
index 0000000..ce14fcb
--- /dev/null
+++ b/package.bluej
@@ -0,0 +1,59 @@
+#BlueJ package file
+dependency1.from=Besitzer
+dependency1.to=Motorroller
+dependency1.type=UsesDependency
+dependency2.from=MotorrollerTest
+dependency2.to=Motorroller
+dependency2.type=UsesDependency
+editor.fx.0.height=777
+editor.fx.0.width=1244
+editor.fx.0.x=-124
+editor.fx.0.y=-895
+objectbench.height=101
+objectbench.width=1002
+package.divider.horizontal=0.6
+package.divider.vertical=0.8497913769123783
+package.editor.height=604
+package.editor.width=888
+package.editor.x=39
+package.editor.y=23
+package.frame.height=777
+package.frame.width=1026
+package.numDependencies=2
+package.numTargets=4
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+readme.height=58
+readme.name=@README
+readme.width=47
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=Todo
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=80
+target1.x=220
+target1.y=450
+target2.height=50
+target2.name=Besitzer
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=80
+target2.x=130
+target2.y=50
+target3.height=50
+target3.name=Motorroller
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=80
+target3.x=220
+target3.y=340
+target4.height=50
+target4.name=MotorrollerTest
+target4.showInterface=false
+target4.type=UnitTestTargetJunit4
+target4.width=110
+target4.x=569
+target4.y=170