Erste Schritte Java.lang.NullPointer.Exception

Destify

Mitglied
Liebe Community,

mit der Exception im Titel schlage ich mich durchgehend rum.

Es geht um ein paar Rechtecke die ich als Spielfeld nutzen will dazu habe ich ein zweidimensionales Spielfeld Array in der Klasse Spielfeld deklariert und in der Klasse Main ein zweidimensionales RECT Array mit der selben Größe wie das erste Array. Nun habe ich in der Methode InitRectArray() jeweil dem RECT Array immer ein Rechteck pro Inhalt übergeben.
Aber sobald ich dann zu dem Punkt komme an dem ich die Größe, Position etc. der einzelnen Rechtecke bestimmen will bekomme ich die Exception.

Hoffe Ihr findet vielleicht meinen Fehler:

Caused by: java.lang.NullPointerException
at main.InitRectArray(main.java:45)
at main.start(main.java:24)

Code:
import com.sun.javafx.font.directwrite.RECT;
import javafx.application.Application;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;

public class main extends Application {

    private spielfeld spielfeld = new spielfeld(0);
    private Rectangle[][] RECT;

    private Pane pane = new Pane();

    public static void main(String[] args) {
        Application.launch(main.class);
    }

    @Override
    public void start(Stage primaryStage) throws Exception {
        InitRectArray();
        DrawGrid();
        Scene scene = new Scene(pane);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    private void InitRectArray() {
        int mx;
        int my = 0;
        int LÄNGE = 50;
        int DICKE = 50;
        RECT   = new Rectangle[spielfeld.getLengthY()][spielfeld.getLengthX(0)];
        for (int a = 0; a < spielfeld.getLengthY(); a++) {
            for (int b = 0; b < spielfeld.getLengthX(a); b++) {
                RECT[a][b] = new Rectangle();

                for (int y = 0; y < spielfeld.getLengthY(); y++) {
                    mx = 0;
                    for (int x = 0; x < spielfeld.getLengthX(y); x++) {
                      
                        if (spielfeld.getValue(x, y) == 1) {
                            RECT[y][x].setX(mx - LÄNGE);
                            RECT[y][x].setY(my + DICKE);
                            RECT[y][x].setHeight(LÄNGE);
                            RECT[y][x].setWidth(LÄNGE);

                        }
                    }
                }
            }
        }

    }

    public void DrawGrid(){
        for(int y = 0; y<RECT.length; y++){
            for(int x = 0; x<RECT[y].length; x++){
                pane.getChildren().add(RECT[y][x]);
            }
        }
    }
}

Code:
public class spielfeld {

    private int spielfeld[][] = new int[10][10];
    private int belegt[][] = new int[spielfeld.length][spielfeld[0].length];

    public spielfeld(int s) {
        InitSpielfeld(s);
    }

    // Klickbar & !Belegt = 0
    public int getLengthX(int Spalte) {
        return spielfeld[Spalte].length;
    } // Belegt = 1

    public int getLengthY() {
        return spielfeld.length;
    }

    public int getValue(int x, int y) {
        return spielfeld[y][x];
    }

    private void InitSpielfeld(int s) {
        int Spielfeld0[][] = {
                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},

        };

        if (s == 0) {
            for (int y = 0; y < Spielfeld0.length; y++) {
                for (int x = 0; x < Spielfeld0[y].length; x++) {
                    spielfeld[y][x] = 0;
                    spielfeld[y][x] = Spielfeld0[y][x];
                }
            }
        }
    }
}
 
for (int a = 0; a < spielfeld.getLengthY(); a++) {
for (int b = 0; b < spielfeld.getLengthX(a); b++) {
RECT[a] = new Rectangle();

for (int y = 0; y < spielfeld.getLengthY(); y++) {
mx = 0;
for (int x = 0; x < spielfeld.getLengthX(y); x++) {

if (spielfeld.getValue(x, y) == 1) {
RECT[y][x].setX(mx - LÄNGE);
RECT[y][x].setY(my + DICKE);
RECT[y][x].setHeight(LÄNGE);
RECT[y][x].setWidth(LÄNGE);

}
}
}
}
}
Mal / schreib dir am besten mal auf einem Blatt Papier auf, was hier passiert bzw wann hier was passiert.
Interessant wird hierbei sein, welche for-Schleife wann auf welche Indizes zugreift und ab welcher Stelle in der for-Schleife ein Eintrag im Array bereits initialisiert ist 😉
 
Oh sorry das ist mein erster Beitrag und ich dachte Zeilen stehen dabei.

Die Exception taucht bei dem ersten RECT[y][x].setX(mx-LÄNGE)

also in diesem Teil des Codes:

Code:
for (int y = 0; y < spielfeld.getLengthY(); y++) {
                    mx = 0;
                    for (int x = 0; x < spielfeld.getLengthX(y); x++) {
                    
                        if (spielfeld.getValue(x, y) == 1) {
                            RECT[y][x].setX(mx - LÄNGE);
                            RECT[y][x].setY(my + DICKE);
                            RECT[y][x].setHeight(LÄNGE);
                            RECT[y][x].setWidth(LÄNGE);

                        }
                    }
                }

Ich glaube das es irgendwie mit der initialisierung der Rectangle Objekte zu tun haben muss aber ich komm einfach nicht drauf 😵

Die Objekte initialisiere ich hier:

Code:
RECT   = new Rectangle[spielfeld.getLengthY()][spielfeld.getLengthX(0)];
        for (int a = 0; a < spielfeld.getLengthY(); a++) {
            for (int b = 0; b < spielfeld.getLengthX(a); b++) {
                RECT[a][b] = new Rectangle();


for (int y = 0; y < spielfeld.getLengthY(); y++) {
                    mx = 0;
                    for (int x = 0; x < spielfeld.getLengthX(y); x++) {
                    
                        if (spielfeld.getValue(x, y) == 1) {
                            RECT[y][x].setX(mx - LÄNGE);
                            RECT[y][x].setY(my + DICKE);
                            RECT[y][x].setHeight(LÄNGE);
                            RECT[y][x].setWidth(LÄNGE);

                        }
                    }
}
}
 
In Worte gefasst machst du momentan folgendes: du durchläufst das Array um alle Einträge zu initialisiert. Nach dem du ein Eintrag initialisiert hast durchläufst du das gesamte Array noch mal und greifst auf alle Elemente zu. Dort knallt es dann weil du ja noch nicht alle Elemente initialisiert hast.
 
Dann müsste aber diese Lösung hier doch eigentlich funktionieren?

Code:
RECT   = new Rectangle[spielfeld.getLengthY()][spielfeld.getLengthX(0)];
      
        for(int y = 0; y < spielfeld.getLengthY(); y++){
            for(int x = 0; x < spielfeld.getLengthX(y); x++){
                RECT[y][x] = new Rectangle(50,50);
            }
        }
        int my = 0;
        int mx; 
        for(int y = 0; y < spielfeld.getLengthY(); y++) {
            mx = 0;
            for (int x = 0; x < spielfeld.getLengthX(y); x++) {
                RECT[y][x].setX(mx - 50);
                RECT[y][x].setY(my + 50);
                RECT[y][x].setFill(Color.BLACK);
            }
        }

ich mein Hey ich bin immerhin die Exceptions losgeworden aber funktionieren tut es trotzdem nicht
 
Es hat sich mitlerweile erledigt; Ich hab mein mx nach jedem Durchlauf nicht erhört und deswegen hat meine DrawGrid Methode auch nichts gezeichnet.

Danke für die Hilfe; Beim nächsten mal gibts mehr Auskunft über mein Problem 😀
 

Zurück
Oben