From 444859323c037387651fb7d3755bbef2570e9ebb Mon Sep 17 00:00:00 2001 From: Jonas Neugebauer Date: Sun, 30 Aug 2020 15:43:53 +0200 Subject: [PATCH] Initial commit --- .gitignore | 26 +++++++ Arrays.java | 175 ++++++++++++++++++++++++++++++++++++++++++++ ArraysTest.java | 187 ++++++++++++++++++++++++++++++++++++++++++++++++ Wuerfel.java | 44 ++++++++++++ package.bluej | 55 ++++++++++++++ 5 files changed, 487 insertions(+) create mode 100644 .gitignore create mode 100644 Arrays.java create mode 100644 ArraysTest.java create mode 100644 Wuerfel.java create mode 100755 package.bluej diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9fe8940 --- /dev/null +++ b/.gitignore @@ -0,0 +1,26 @@ +# ---> Java +# Compiled class file +*.class + +# Log file +*.log + +# BlueJ files +*.ctxt +Dokumente* + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files # +*.jar +*.war +*.nar +*.ear +*.zip +*.tar.gz +*.rar + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* + diff --git a/Arrays.java b/Arrays.java new file mode 100644 index 0000000..b9fc303 --- /dev/null +++ b/Arrays.java @@ -0,0 +1,175 @@ +import java.util.Random; + +public class Arrays { + + /** + * Ein Beispiel zu Objekt-Arrays. + */ + public void objectArrayExample() { + // Array mit Objektreferenzen erstellen + Wuerfel[] wuerfel = new Wuerfel[6]; + wuerfel[4] = new Wuerfel("W4"); + wuerfel[0] = new Wuerfel("W0"); + wuerfel[1] = new Wuerfel("W1"); + wuerfel[2] = wuerfel[4]; + wuerfel[3] = wuerfel[1]; + + // Ausgabe der Elemente im Array + printArray(wuerfel); + + // wuerfel[2] und wuerfel[4] zeigen auf dasselbe Objekt + wuerfel[2].werfen(); + System.out.printf("Index %s: %s\n", 4, wuerfel[4].toString()); + if( wuerfel[2] == wuerfel[4] ) { + System.out.println("Index 2 und Index 4 sind gleich"); + } + System.out.println(); + + // Die Referenz in wuerfel[2] kann auf ein neues Objekt gesetzt werden + wuerfel[2] = new Wuerfel("W2"); + + // Eine Objektreferenz im Array kann auch gelöscht werden + // Das zugehörige Objekt bleibt erhalten, solange noch eine andere + // Referenz vorhanden ist (hier wuerfel[1]). + wuerfel[3] = null; + + // Referenzen können beliebig neu gesetzt werden + Wuerfel w5 = new Wuerfel("W5"); + wuerfel[5] = w5; + wuerfel[0] = w5; + + // Ausgabe der Elemente im Array + printArray(wuerfel); + } + + /** + * Wirft alle Würfel im Array neu. + *

+ * Indizes ohne Referenz auf einen Würfel (also mit Inhalt null) + * werden übersprungen. + * + * @see Wuerfel#werfen() + */ + public void rollAll( Wuerfel[] pArray ) { + // TODO: implementieren + } + + /** + * Berechnet die Summe aller Augenzahlen, die die Würfel + * im Array gerade anzeigen. + *

+ * Indizes ohne Referenz auf einen Würfel (also mit Inhalt null) + * werden übersprungen. + * + * @see Wuerfel#getAugenzahl() + */ + public int diceSum( Wuerfel[] pArray ) { + // TODO: implementieren + return 0; + } + + /** + * Wirft alle Würfel im zweidimensionalen Array neu. + *

+ * Indizes ohne Referenz auf einen Würfel (also mit Inhalt null) + * werden übersprungen. + * + * @see Wuerfel#werfen() + */ + public void twoDimRoll( Wuerfel[][] pArray ) { + // TODO: implementieren + } + + /** + * Berechnet die Summe aller Augenzahlen, die die Würfel + * im zweidimensionalen Array gerade anzeigen. + *

+ * Indizes ohne Referenz auf einen Würfel (also mit Inhalt null) + * werden übersprungen. + * + * @see Wuerfel#getAugenzahl() + */ + public int twoDimSum( Wuerfel[][] pArray ) { + // TODO: implementieren + return 0; + } + + /** + * Berechnet in einem zweidimensionalen Array die Zeilensummen. + * Das bedeutet für jeden Index i in pArray wird die Summe der Elemente + * im Array pArray[i] berechnet. Die Summe wird im Ergebnisarray + * wieder im Index i gespeichert. + * + * @param pArray + * @return Ein eindimensionales Array mit den Zeilensummen + */ + public int[] rowSum( Wuerfel[][] pArray ) { + // TODO: implementieren + return null; + } + + /** + * Gibt die Augenzahlen der Würfel im Array auf + * der Kommandozeile aus. + * @param pArray Ein Array mit Wuerfel-Referenzen + */ + public void printArray( Wuerfel[] pArray ) { + for( int i = 0; i < pArray.length; i++ ) { + if( pArray[i] != null ) { // prüfen, ob es ein Objekt gibt + System.out.printf("Index %s: %s\n", i, pArray[i].toString()); + } else { + System.out.printf("Index %s: null\n", i); + } + } + System.out.println(); + } + + + /** + * Gibt die Augenzahlen der Würfel im zweidimensionalen Array auf + * der Kommandozeile aus. + * @param pArray Ein zweidimensionales Array mit Wuerfel-Referenzen + */ + public void printArray( Wuerfel[][] pArray ) { + for( int i = 0; i < pArray.length; i++ ) { + if( pArray[i] != null ) { // prüfen, ob es ein Objekt gibt + Wuerfel[] innerArray = pArray[i]; + for( int j = 0; j < innerArray.length; j++ ) { + if( innerArray[j] != null ) { + System.out.printf("Index %s,%s: %s\n", i, j, pArray[i].toString()); + } else { + System.out.printf("Index %s,%s: null\n", i, j); + } + } + } else { + System.out.printf("Index %s: null\n", i); + } + } + System.out.println(); + } + + /** + * Erstellt ein Array mit pNumberOfElements + * {@link Wuerfel}n. + */ + public Wuerfel[] generateArray( int pNumberOfElements ) { + Wuerfel[] dice = new Wuerfel[pNumberOfElements]; + for( int i = 0; i < dice.length; i++ ) { + dice[i] = new Wuerfel("W" + i); + } + return dice; + } + + /** + * Erstellt ein Array das wiederum pNumberOfRows Arrays enthält, die + * jeweils pNumberOfCols {@link Wuerfel} enthalten. + */ + public Wuerfel[][] generateArray( int pNumberOfRows, int pNumberOfCols ) { + Wuerfel[][] dice = new Wuerfel[pNumberOfRows][pNumberOfCols]; + for( int i = 0; i < dice.length; i++ ) { + dice[i] = generateArray(pNumberOfCols); + } + return dice; + } + +} diff --git a/ArraysTest.java b/ArraysTest.java new file mode 100644 index 0000000..d4ce98e --- /dev/null +++ b/ArraysTest.java @@ -0,0 +1,187 @@ +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +import java.util.Random; + +public class ArraysTest { + + private static int n = 0; + + private class MockupWuerfel extends Wuerfel { + + public int mockupValue; + + public int rolls = 0; + + public MockupWuerfel(int pValue) { + super("W" + (n++)); + mockupValue = pValue; + rolls = 0; + } + + @Override + public int getAugenzahl() { + return mockupValue; + } + + @Override + public void werfen() { + rolls = rolls + 1; + } + } + + private Arrays arrays; + + /** + * Setzt das Testgerüst fuer den Test. + * + * Wird vor jeder Testfall-Methode aufgerufen. + */ + @Before + public void setUp() { + arrays = new Arrays(); + } + + @Test + public void testDiceSum() { + Random rand = new Random(); + + Wuerfel[] dice; + + dice = new Wuerfel[]{ + new MockupWuerfel(1), + new MockupWuerfel(6), + new MockupWuerfel(4), + }; + assertEquals("Falsche Summe berechnet.", 11, arrays.diceSum(dice)); + + for( int i = 0; i < 10; i++ ) { + int sum = 0; + dice = new Wuerfel[rand.nextInt(18)+2]; + for( int j = 0; j < dice.length; j++ ) { + int w = rand.nextInt(6)+1; + dice[j] = new MockupWuerfel(w); + sum += w; + } + + assertEquals("Falsche Summe berechnet.", sum, arrays.diceSum(dice)); + } + } + + @Test + public void testRollAll() { + Wuerfel[] dice = new Wuerfel[50]; + for( int i = 0; i < dice.length; i++ ) { + dice[i] = new MockupWuerfel(0); + } + + arrays.rollAll(dice); + + for( int i = 0; i < dice.length; i++ ) { + MockupWuerfel die = (MockupWuerfel)dice[i]; + assertTrue( "Der Würfel "+die.getName()+" wurde nicht geworfen.", die.rolls == 1); + } + } + + @Test + public void testTwoDimSum() { + Random rand = new Random(); + + Wuerfel[][] dice; + + dice = new Wuerfel[][]{ + new Wuerfel[]{ + new MockupWuerfel(1), + new MockupWuerfel(6), + new MockupWuerfel(4) + }, + new Wuerfel[]{ + new MockupWuerfel(5), + new MockupWuerfel(5), + new MockupWuerfel(5) + }, + new Wuerfel[]{ + new MockupWuerfel(1), + new MockupWuerfel(1), + new MockupWuerfel(0) + }, + new Wuerfel[]{ + new MockupWuerfel(-3), + new MockupWuerfel(-2), + new MockupWuerfel(-4) + } + }; + assertEquals("Falsche Summe berechnet.", 19, arrays.twoDimSum(dice)); + + for( int i = 0; i < 10; i++ ) { + int sum = 0; + dice = new Wuerfel[rand.nextInt(18)+2][rand.nextInt(18)+2]; + for( int j = 0; j < dice.length; j++ ) { + for( int k = 0; k < dice[j].length; k++ ) { + int w = rand.nextInt(6)+1; + dice[j][k] = new MockupWuerfel(w); + sum += w; + } + } + + assertEquals("Falsche Summe berechnet.", sum, arrays.twoDimSum(dice)); + } + } + + @Test + public void testTwoDimRoll() { + Wuerfel[][] dice = new Wuerfel[50][45]; + for( int i = 0; i < dice.length; i++ ) { + for( int j = 0; j < dice[i].length; j++ ) { + dice[i][j] = new MockupWuerfel(0); + } + } + + arrays.twoDimRoll(dice); + + for( int i = 0; i < dice.length; i++ ) { + for( int j = 0; j < dice[i].length; j++ ) { + MockupWuerfel die = (MockupWuerfel)dice[i][j]; + assertTrue( "Der Würfel "+die.getName()+" wurde nicht geworfen.", die.rolls == 1); + } + } + } + + @Test + public void testRowSum() { + Wuerfel[][] dice; + + dice = new Wuerfel[][]{ + new Wuerfel[]{ + new MockupWuerfel(1), + new MockupWuerfel(6), + new MockupWuerfel(4) + }, + new Wuerfel[]{ + new MockupWuerfel(5), + new MockupWuerfel(5), + new MockupWuerfel(5) + }, + new Wuerfel[]{ + new MockupWuerfel(1), + new MockupWuerfel(1), + new MockupWuerfel(0) + }, + new Wuerfel[]{ + new MockupWuerfel(-3), + new MockupWuerfel(-2), + new MockupWuerfel(-4) + } + }; + + int[] sums = arrays.rowSum(dice); + assertEquals("Ergebnisarray hat die falsche Größe", 4, sums.length); + assertEquals("Erste Zeilensumme nicht korrekt", 11, sums[0]); + assertEquals("Zweite Zeilensumme nicht korrekt", 15, sums[1]); + assertEquals("Dritte Zeilensumme nicht korrekt", 2, sums[2]); + assertEquals("Vierte Zeilensumme nicht korrekt", -9, sums[3]); + } + +} diff --git a/Wuerfel.java b/Wuerfel.java new file mode 100644 index 0000000..926749b --- /dev/null +++ b/Wuerfel.java @@ -0,0 +1,44 @@ +import java.util.Random; + +/** + * Ein normaler, sechsseitiger Würfel. + */ +public class Wuerfel { + + private String name; + + private Random rand; + + private int value; + + /** + * Erstellt einen Würfel mit einem Namen zur Identifikation. + * @param pName + */ + public Wuerfel( String pName ) { + name = pName; + rand = new Random(); + werfen(); + } + + /** + * Wirft den Würfel. Die geworfene Augenzahl + * kann dann mit {@link #getAugenzahl()} abgerufen + * werden. + */ + public void werfen() { + value = rand.nextInt(6)+1; + } + + public int getAugenzahl() { + return value; + } + + public String getName() { + return name; + } + + public String toString() { + return name + "<" + value + ">"; + } +} diff --git a/package.bluej b/package.bluej new file mode 100755 index 0000000..aae7f46 --- /dev/null +++ b/package.bluej @@ -0,0 +1,55 @@ +#BlueJ package file +dependency1.from=ArraysTest +dependency1.to=Wuerfel +dependency1.type=UsesDependency +dependency2.from=ArraysTest +dependency2.to=Arrays +dependency2.type=UsesDependency +dependency3.from=Arrays +dependency3.to=Wuerfel +dependency3.type=UsesDependency +editor.fx.0.height=0 +editor.fx.0.width=0 +editor.fx.0.x=0 +editor.fx.0.y=0 +objectbench.height=66 +objectbench.width=1219 +package.divider.horizontal=0.6 +package.divider.vertical=0.8983286908077994 +package.editor.height=638 +package.editor.width=1105 +package.editor.x=37 +package.editor.y=23 +package.frame.height=776 +package.frame.width=1243 +package.numDependencies=3 +package.numTargets=3 +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=170 +target1.name=ArraysTest +target1.showInterface=false +target1.type=UnitTestTargetJunit4 +target1.width=140 +target1.x=580 +target1.y=70 +target2.height=50 +target2.name=Wuerfel +target2.showInterface=false +target2.type=ClassTarget +target2.width=80 +target2.x=240 +target2.y=490 +target3.height=160 +target3.name=Arrays +target3.showInterface=false +target3.type=ClassTarget +target3.width=180 +target3.x=120 +target3.y=110