Objektorientierung, Array Index

K

Knuspakeks

Grünschnabel
Erweitert nun den Konstruktor so, dass er in Zweierschritten durch die Spielfeldbeschreibung
läuft, jeweils die Nachbarschafts-Signatur ausrechnet und diese Signatur als Index in das bereitgestellte
Array NEIGHBORHOOD_TO_FILENAME verwendet und damit GameObject -Objekte
konstruiert. Beachtet, dass deren Koordinaten halbiert werden müssen.

Kann mir jemand helfen mir zu erklären wie ich das anstelle?

Java: 
/**
 * Diese Klasse repräsentiert ein Spielfeld. Ihr Konstruktur bekommt dieses als
 * String-Array übergeben.
 */
class Field
{
    /**
     * Die Dateinamen der Bodengitterelemente, die direkt mit einer
     * Rotation 0 verwendet werden können. Der Index ergibt sich
     * aus der Summe der folgenden Zahlen:
     * 1: In Richtung 0 (+1, 0) gibt es eine Verbindung.
     * 2: In Richtung 1 (0, +1) gibt es eine Verbindung.
     * 4: In Richtung 2 (-1, 0) gibt es eine Verbindung.
     * 8: In Richtung 3 (0, -1) gibt es eine Verbindung.
     */
    private static final String[] NEIGHBORHOOD_TO_FILENAME = {
        "floor",
        "floor-e-0",
        "floor-e-1",
        "floor-l-0",
        "floor-e-2",
        "floor-i-0",
        "floor-l-1",
        "floor-t-1",
        "floor-e-3",
        "floor-l-3",
        "floor-i-1",
        "floor-t-0",
        "floor-l-2",
        "floor-t-3",
        "floor-t-2",
        "floor-x"
    };
    char dieter[][];
    /** Ein Testfall, der alle Nachbarschaften enthält. */
    static void test()
    {
        // Auskommentieren, sobald Konstruktor vorhanden
        new Field(new String[] {
            "O-O-O-O  ",
            "|   |    ",
            "O O-O-O O",
            "| | | | |",
            "O-O-O-O-O",
            "| | | | |",
            "O O-O-O O",
            "    |   |",
            "  O-O-O-O"
        });
    }
    public Field(String[]field){
    dieter=new char[field.length][];
    for(int x=0;x<field.length;x++){
        dieter[x]=new char[field[x].length()];
        for(int y=0; y<field[x].length();y++){
            dieter[x][y]=field[x].charAt(y);
        }
    }
    }
    private int getNeighborhood(int x, int y){
    int counter=0;   
        if(getCell(x+1,y)!= ' '){
        return counter=1;
        }
        else if(getCell(x,y+1)!= ' '){
        return counter=2;
        }
        else if(getCell(x-1,y)!= ' '){
        return counter=4;
        }
        else if(getCell(x,y-1)!= ' '){
        return counter=8;
        }
        else{
        return counter;
        }
        
    }
    private char getCell(int x, int y){
    if(x>=0 && y>=0 && dieter[y].length-1>x && dieter.length-1>y){
        return dieter[x][y];
    }
    else{
        return ' ';
    }
    }
}

Ersten beiden aufgaben:
Ergänzt die Klasse Field um einen Konstruktor, der eine solche Beschreibung entgegen nimmt,
und ein Attribut, das die Beschreibung speichert. Um den Zugriff darauf zu erleichtern, schreibt
ihr eine Methode char getCell(int, int), die eine x-Koordinate (horizontal) und eine y-Koordinate
(vertikal) übergeben bekommt und das im Feld gespeicherte Zeichen zurückliefert. Liegt das Koordinatenpaar
außerhalb des Feldes, soll ein Leerzeichen (’ ’) zurückgegeben werden. Beachtet,
dass nicht alle Zeilen gleich lang sein müssen.

Schreibt nun eine Methode int getNeighborhood(int, int), die eine x-Koordinate (horizontal)
und eine y-Koordinate (vertikal) ¨ubergeben bekommt und f¨ur die entsprechende Zelle eine
Nachbarschafts-Signatur zurückliefert. Die Signatur wird berechnet, indem für jeden belegten
Nachbarn (also eine Zelle ungleich einem Leerzeichen) eine Zahl addiert wird. Und zwar sind
dies die Zahlen 1 für den Nachbarn bei (x + 1, y), 2 f¨ur (x, y + 1), 4 f¨ur (x − 1, y) und 8 f¨ur
(x, y − 1). Das Ergebnis wird also immer eine Zahl zwischen 0 und 15 sein.
 
GameObject Objekte sind sicherliche Objekte einer anderen gegebenen Klasse. Vermutlich brauchst du für den Konstruktor den String aus dem Array. Die entsprechenden Methoden dafür hast du doch schon, nur nicht richtig.

z.B. würde ich diese Methode wie folgt ändern:
Java: 
    private char getCell(int x, int y) {
        try {
            return dieter[x][y];
        } catch(IndexOutOfBoundsException ex) {
            return ' ';
        }
    }

Du hättest sonst ein Problem, wenn dieter z.B. so aussehen würde:
"O-O-O"
"|"
"O-O-O"

Und es ist im Text ja mehr oder weniger erwähnt, dass das sein kann.
 
Kannst du mir erklären wie du darauf gekommen bist?
Ich hab das mal ausprobiert allerdings darf dieses if nicht weg da ansonsten kompletter bullshit erstellt wird.
Fertiger Code:
Ich hab mal dein beispiel genommen, dann ja kommt ein fehler
Java: 
/**
 * Diese Klasse repräsentiert ein Spielfeld. Ihr Konstruktur bekommt dieses als
 * String-Array übergeben.
 */
class Field
{
    /**
     * Die Dateinamen der Bodengitterelemente, die direkt mit einer
     * Rotation 0 verwendet werden können. Der Index ergibt sich
     * aus der Summe der folgenden Zahlen:
     * 1: In Richtung 0 (+1, 0) gibt es eine Verbindung.
     * 2: In Richtung 1 (0, +1) gibt es eine Verbindung.
     * 4: In Richtung 2 (-1, 0) gibt es eine Verbindung.
     * 8: In Richtung 3 (0, -1) gibt es eine Verbindung.
     */
    private static final String[] NEIGHBORHOOD_TO_FILENAME = {
        "floor",
        "floor-e-0",
        "floor-e-1",
        "floor-l-0",
        "floor-e-2",
        "floor-i-0",
        "floor-l-1",
        "floor-t-1",
        "floor-e-3",
        "floor-l-3",
        "floor-i-1",
        "floor-t-0",
        "floor-l-2",
        "floor-t-3",
        "floor-t-2",
        "floor-x"
    };
    char dieter[][];
    /** Ein Testfall, der alle Nachbarschaften enthält. */
    static void test()
    {
        // Auskommentieren, sobald Konstruktor vorhanden
        new Field(new String[] {
            "O-O-O  ",
            "|"       ,
            "O-O-O"
        });
    }
    public Field(String[]field){
    dieter=new char[field.length][];
    for(int x=0;x<field.length;x++){
        dieter[x]=new char[field[x].length()];
        for(int y=0; y<field[x].length();y++){
            dieter[x][y]=field[x].charAt(y);
        }
    
    
    }
    for(int y=0;y<dieter.length;y+=2){
        for(int x=0;x<dieter[y].length;x+=2){
            
            GameObject gamo = new GameObject(x/2,y/2,0,NEIGHBORHOOD_TO_FILENAME[getNeighborhood(x,y)]);
        }
    
    }
    }
    
    private char getCell(int x, int y){
    if(x>=0 && y>=0 && y<dieter.length && x<dieter[y].length  ){
        
        return dieter[x][y];
    
    
        
    }
    return ' ';
}
    private int getNeighborhood(int x, int y) {
        int counter = 0;

        if (getCell(x + 1, y) != ' ') counter += 1;
        if (getCell(x, y + 1) != ' ') counter += 2;
        if (getCell(x - 1, y) != ' ') counter += 4;
        if (getCell(x, y - 1) != ' ') counter += 8;
      
        return counter;
}
}
 
"O-O-O"
"|"
"O-O-O"
Wie hast du herausgefunden das er nen indexoutofboundsexception ausspuckt?
und wie kann ich das beheben? Deine Idee klappt leider nicht
 
Zuletzt bearbeitet:
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück