NullPointerException

[MaximusMeridius]

Hi,

bei meinem Programm bekomme ich eine NullPointerException, wenn ich die Länge eines ObjektArrays abfrage(In der Funktion update() bei for(int i=0;i<ungeheuer.length;i++) ):

import java.lang.String;

public class BoulderDash {
int o,u;
public Stein[] stein;   
public Ungeheuer[] ungeheuer;
public Spieler spieler;

public String[] scene ={"MMMMMMM",
                        "A U O M",
                        "M   O M",
                        "M   O M",
                        "MMMMOMM",
                        "M   E M",
                        "M S   M",
                        "MMMMMMM"};//Spielfeld

public char[][] feld = new char[scene.length][scene[0].length()]; 

public class Stein{
    int[] pos;
    int bewegung;       //Anzahl der schon gefallen Momente
    public Stein(int i,int j){
        int[] pos=new int[2];        
        bewegung=0;
        pos[0]=i;
        pos[1]=j;
    }}

public class Spieler{
    int[] pos; 
    public Spieler(int i, int j){
        pos=new int[2];
        pos[0]=i;
        pos[1]=j;
    }}

public class Ungeheuer{
    int[] pos;
    int richtung;
    public Ungeheuer(int i, int j){
        pos=new int[2];
        richtung=1;
        pos[0]=i;
        pos[1]=j;
    }
}

public void update(){
int x,y;
for(int i=0;i<ungeheuer.length;i++)
{
    x=ungeheuer[i].pos[0];
    y=ungeheuer[i].pos[1];
        if(ungeheuer[i].richtung==0)//Richtung des Ungeheuers nach oben
            if(x>0)//Damit das Ungeheuer nicht außerhalb des Feldes kommt
                if(feld[x-1][y]==' '){  //Wenn das nächste Feld frei ist
                    feld[x][y]=' ';                         //Alte Spieler position löschen            
                    x=x-1;                                  //Horizontal verringern
                    feld[x][y]='U';                         //Neue Spieler position zuordnen
                    spieler.pos[0]=x;                       //Schritt dem Spieler zuweisen
                }  //Sonst gegen den Uhrzeigersinn drehen
                else {
                    ungeheuer[i].richtung=(ungeheuer[i].richtung+1)%3;
                    //Damit sich das Ungeheuer gegen dem Uhrzeigersinn 
                    //dreht. mod 3 damit es keine Richtung gibt, die das Ungeheuer nicht kennt
                }
        if(ungeheuer[i].richtung==1)//Richtung des Ungeheuers nach links
            if(y>0)//Damit das Ungeheuer nicht außerhalb des Feldes kommt
                if(feld[x][y-1]==' '){  //Wenn das nächste Feld frei ist
                    feld[x][y]=' ';                         //Alte Spieler position löschen            
                    y=y-1;                                  //Horizontal verringern
                    feld[x][y]='U';                         //Neue Spieler position zuordnen
                    spieler.pos[1]=y;                       //Schritt dem Spieler zuweisen
                }  //Sonst gegen den Uhrzeigersinn drehen
                else {
                    ungeheuer[i].richtung=(ungeheuer[i].richtung+1)%3;
                    //Damit sich das Ungeheuer gegen dem Uhrzeigersinn 
                    //dreht. mod 3 damit es keine Richtung gibt, die das Ungeheuer nicht kennt
                }
        if(ungeheuer[i].richtung==2)//Richtung des Ungeheuers nach unten
            if(x<feld.length-1)//Damit das Ungeheuer nicht außerhalb des Feldes kommt
                if(feld[x+1][y]==' '){  //Wenn das nächste Feld frei ist
                    feld[x][y]=' ';                         //Alte Spieler position löschen            
                    x=x+1;                                  //Horizontal verringern
                    feld[x][y]='U';                         //Neue Spieler position zuordnen
                    spieler.pos[0]=x;                       //Schritt dem Spieler zuweisen
                }  //Sonst gegen den Uhrzeigersinn drehen
                else {
                    ungeheuer[i].richtung=(ungeheuer[i].richtung+1)%3;
                    //Damit sich das Ungeheuer gegen dem Uhrzeigersinn 
                    //dreht. mod 3 damit es keine Richtung gibt, die das Ungeheuer nicht kennt
                }
        if(ungeheuer[i].richtung==3)//Richtung des Ungeheuers nach rechts
            if(y<feld[0].length-1)//Damit das Ungeheuer nicht außerhalb des Feldes kommt
                if(feld[x][y+1]==' '){  //Wenn das nächste Feld frei ist
                    feld[x][y]=' ';                         //Alte Spieler position löschen            
                    y=y+1;                                  //Horizontal verringern
                    feld[x][y]='U';                         //Neue Spieler position zuordnen
                    spieler.pos[1]=y;                       //Schritt dem Spieler zuweisen
                }  //Sonst gegen den Uhrzeigersinn drehen
                else {
                    ungeheuer[i].richtung=(ungeheuer[i].richtung+1)%3;
                    //Damit sich das Ungeheuer gegen dem Uhrzeigersinn 
                    //dreht. mod 3 damit es keine Richtung gibt, die das Ungeheuer nicht kennt
                }                
}

//Spielfeld ausgeben                
System.out.print("\f");  //Konsole löschen
    for(int i=0;i<scene[i].length();i++)
    {
        for(int j=0;j<feld[i].length;j++){
            System.out.print(feld[i][j]);
            }
        System.out.println("");
}}

public void step(int dir){
int i,j;
i=spieler.pos[0];
j=spieler.pos[1];
if(dir==0){ //Schritt nach oben
    if(i>0)//Damit der Spieler nicht außerhalb des Feldes kommt
        if(feld[i-1][j]=='E' || feld[i-1][j]==' '){  //Wenn das nächste Feld frei ist
             feld[i][j]=' ';                         //Alte Spieler position löschen            
             i=i-1;                                  //Horizontal verringern
             feld[i][j]='S';                         //Neue Spieler position zuordnen
             spieler.pos[0]=i;                       //Schritt dem Spieler zuweisen
            } //Sonst mache keinen Schritt    
}
if(dir==1){//links
    if(j>0)//Damit der Spieler nicht außerhalb des Feldes kommt
        if(feld[i][j-1]=='E' || feld[i][j-1]==' '){  //Wenn das nächste Feld frei ist
             feld[i][j]=' ';                         //Alte Spieler position löschen            
             j=j-1;                                  //Horizontal verringern
             feld[i][j]='S';                         //Neue Spieler position zuordnen             
             spieler.pos[1]=j;                       //Schritt dem Spieler zuweisen
            }//Sonst mache keinen Schritt
}
if(dir==2){//unten
    if(j<feld[i].length-1)//Damit der Spieler nicht außerhalb des Feldes kommt
        if(feld[i+1][j]=='E' || feld[i+1][j]==' '){  //Wenn das nächste Feld frei ist
             feld[i][j]=' ';                         //Alte Spieler position löschen            
             i=i+1;                                  //Horizontal verringern
             feld[i][j]='S';                         //Neue Spieler position zuordnen             
             spieler.pos[0]=i;                       //Schritt dem Spieler zuweisen
            }//Sonst mache keinen Schritt
}
if(dir==3){//rechts
    if(j<scene[i].length()-1)//Damit der Spieler nicht außerhalb des Feldes kommt
        if(feld[i][j+1]=='E' || feld[i][j+1]==' '){  //Wenn das nächste Feld frei ist
             feld[i][j]=' ';                         //Alte Spieler position löschen            
             j=j+1;                                  //Horizontal verringern
             feld[i][j]='S';                         //Neue Spieler position zuordnen             
             spieler.pos[1]=j;                       //Schritt dem Spieler zuweisen
            }//Sonst mache keinen Schritt
}
}

public void game(int[] dirs){
int u=0;        //Anzahl der Ungeheuer
int o=0;        //Anzahl der Stein

//Spielfeld in ein Char Array legen                 
for (int i = 0; i < scene.length; i++) 
    for(int j=0; j <scene[i].length();j++)
        feld[i][j]=scene[i].charAt(j);

//Anzahl der Steine und Ungeheuer zählen
for(int i=0; i<feld.length;i++)
    for(int j=0; j<feld[i].length;j++){
        if(feld[i][j]=='U')//Ungeheuer zählen
            u++;
        if(feld[i][j]=='O')//Steine zählen
            o++;
    }

Stein[] stein=new Stein[o];      //Speicherplatz für die Arrays reservieren
Ungeheuer[] ungeheuer=new Ungeheuer[u];
    
u=0;
o=0;
for(int i=0; i<feld.length;i++) //Arrays erzeugen und mit Inhalten füllen
    for(int j=0; j<feld[i].length;j++){
        if(feld[i][j]=='O'){//Stein Objekte erzeugen
            stein[o]=new Stein(i,j);
            o++;}        
        if(feld[i][j]=='U'){//Ungeheuer Objekte erzeugen
            ungeheuer[u]=new Ungeheuer(i,j);
            u++;}
        if(feld[i][j]=='S'){//Spieler Objekt erzeugen
            spieler=new Spieler(i,j);}
    }

    for(int i=0;i<dirs.length;i++){
        step(dirs[i]);  //Schritte der Objekte machen
        update();       //Neue Spielsituation auf der Konsole ausgeben    
        try {Thread.sleep(500);}    //Spiel langsamer machen
        catch (InterruptedException e){}
    }
}}

 

[Der Müde Joe]

>bei meinem Programm bekomme ich eine NullPointerException, wenn ich die Länge eines ObjektArrays abfrage

na dann wird wohl ungeheuer nicht nicht initialisiert sein (ohne den Code zu lesen)

Breakpoint auch die Schleife dann siehst du es

 

[JavaFred]

In Zeile 181 deklarierst Du eine neue Variable ungeheuer, die die Exemplarvariable ungeheuer aus Zeile 7 überschattet.

 

[MaximusMeridius]

Was muss ich denn da ändern, damit ich die Objekte Global benutzen, aber auch lokal erzeugen kann? Sprich auf die Objekte Ungeheuer und Stein muss ich später noch zugreifen können.

 

[thE_29]

181!
Ungeheuer[] ungeheuer=new Ungeheuer;

gehört
ungeheuer=new Ungeheuer;