Hey,
ich sitze die letzten Tage an einer Aufgabe, die wir heute noch abgeben müssen.
Ich komme nicht voran, weil der Text einfach nur unverständlich ist und somit finde ich keinen Ansatz für die Aufgaben.
Meine Gruppenmitglieder tun auch nichts weiter, also hängt alles an mir..
Wenn sich jemand das anschauen könnte und mir Tipps gibt oder einen kleinen Ansatz, würde er/sie mir aus der Patsche helfen.
Hier einmal mein Code:
Der vorgegebene Code:
ich sitze die letzten Tage an einer Aufgabe, die wir heute noch abgeben müssen.
Ich komme nicht voran, weil der Text einfach nur unverständlich ist und somit finde ich keinen Ansatz für die Aufgaben.
Meine Gruppenmitglieder tun auch nichts weiter, also hängt alles an mir..
Wenn sich jemand das anschauen könnte und mir Tipps gibt oder einen kleinen Ansatz, würde er/sie mir aus der Patsche helfen.
Hier einmal mein Code:
Java:
import java.util.Random;
/**
* Beschreiben Sie hier die Klasse Actor.
*
* @author (Ihr Name)
* @version (eine Versionsnummer oder ein Datum)
*/
import java.util.Scanner;
public class Actor extends Field {
private int zeile;
private int spalte;
private final char spielfeld[][];
public Actor(int zeile, int spalte, final String[] pRows, final char pOutsideSymbol) {
super(pRows, pOutsideSymbol);
this.zeile = zeile;
this.spalte = spalte;
this.spielfeld = new char[3][3];
spielfeld[0][0] = 'a';
spielfeld[0][1] = 'b';
spielfeld[0][2] = 'c';
spielfeld[1][0] = 'd';
spielfeld[1][1] = 'e';
spielfeld[1][2] = 'f';
spielfeld[2][0] = 'g';
spielfeld[2][1] = 'h';
spielfeld[2][2] = 'i';
char positionActor = spielfeld[0][0];
System.out.println(positionActor += peek(zeile, spalte));
char positionZeichen = peek(zeile, spalte);
System.out.println("Auf der Position befindet sich das Zeichen: " + positionZeichen);
}
public char peek(int zeile, int spalte) {
return this.spielfeld[zeile][spalte];
}
}Der vorgegebene Code:
Java:
/**
* Eine Klasse zur Verwaltung des Spielfelds. Das Spielfeld ist eine zweidimensionale
* Anordnung von einzelnen Zeichen. Diese können über die Angabe von Zeile und Spalte
* adressiert werden. Dabei gehen, bezogen auf die Darstellung, die Nummern der Zeilen
* von oben nach unten und die Nummern der Spalten von links nach rechts (jeweils
* Null-basiert). Es wird nicht erwartet, dass alle Zeilen gleich lang sind.
*
*/
public class Field {
/**
* Die Zellen des Spielfeldes in der oben genannten Ordnung.
*/
private final char[][] cells;
/**
* Ein Zeichen, das zurückgeliefert wird, wenn nach Feldern außerhalb des Spielfelds
* gefragt wird.
*/
private final char outsideSymbol;
/**
* Erzeugt ein neues Spielfeld. Dabei wird die übergebene Repräsentation als Array
* von Zeichenketten in die interne Repräsentation eines zweidimensionalen Arrays
* von Zeichen überführt.
* @param pRows Die Zeilen des Spielfeldes in der oben genannten Ordnung. Die
* Übergabe von null oder von Zeilen, die {@code null} sind, wird nicht
* unterstützt.
* @param pOutsideSymbol Ein Zeichen, das zurückgeliefert wird, wenn nach Feldern
* außerhalb des Spielfelds gefragt wird.
*/
public Field(final String[] pRows, final char pOutsideSymbol) {
cells = new char[pRows.length][];
for (int row = 0; row < pRows.length; ++row) {
cells[row] = new char[pRows[row].length()];
for (int column = 0; column < pRows[row].length(); ++column) {
cells[row][column] = pRows[row].charAt(column);
}
}
outsideSymbol = pOutsideSymbol;
}
/**
* Liefert das Spielfeld als Zeichenkette.
* @return Das Spielfeld als Zeichenkette. Die Zeilen sind durch Zeilenumbrüche
* ({@code '\n'}) getrennt.
*/
public String toString() {
String result = "";
String rowPrefix = "";
for (final char[] row : cells) {
result += rowPrefix + new String(row);
rowPrefix = "\n";
}
return result;
}
/**
* Liefert das Zeichen an einer Spielfeldposition zurück.
* @param pRow Die Zeile der Spielfeldposition.
* @param pColumn Die Spalte der Spielfeldposition.
* @return Das Zeichen an der angebenen Position, wenn diese innerhalb des
* Spielfelds liegt. Ansonsten das dem Konstruktor übergebene Zeichen für
* Positionen außerhalb des Spielfelds.
*/
public char getSymbol(final int pRow, final int pColumn) {
if (isInside(pRow, pColumn)) {
return cells[pRow][pColumn];
} else {
return outsideSymbol;
}
}
/**
* Ändert das Zeichen an einer Spielfeldposition. Das dort bisher gespeicherte
* Zeichen wird überschrieben.
* @param pRow Die Zeile der Spielfeldposition.
* @param pColumn Die Spalte der Spielfeldposition.
* @param pSymbol Das Zeichen, das an die Position geschieben wird.
* @return {@code true}: Das Zeichen wurde an die Position geschrieben.
* {@code false}: Das Zeichen konnte nicht geschrieben werden, da sich die
* Position außerhalb des Spielfelds befindet.
*/
public boolean setSymbol(final int pRow, final int pColumn, final char pSymbol) {
if (isInside(pRow, pColumn)) {
cells[pRow][pColumn] = pSymbol;
return true;
} else {
return false;
}
}
/**
* Testet, ob sich eine Position innerhalb des Spielfelds befindet.
* @param pRow Die Nummer der Zeile.
* @param pColumn Die Nummer der Spalte.
* @return {@code true}: Die Position adressiert einen realen Eintrag des Spielfelds.
* {@code false}: Es gibt kein Zeichen dieser Position, d.h. sie befindet sich
* außerhalb des Spielfelds.
*/
private boolean isInside(final int pRow, final int pColumn) {
return pRow >= 0 && pRow < cells.length && pColumn >= 0 && pColumn < cells[pRow].length;
}
}
