# NullPointerException



## darkangel (11. Jul 2009)

Servus,
Ich habe noch nicht sehr viel erfahrung was Java angeht (, habe erst vor Kurzem angefangen mich wirklich in die Sprache einzuarbeiten).
Momentan bin ich dabei ein kleines Spiel zu programmieren.
Hierbei soll ein Array von 3 x 3 Felder (alle samt Zufallszahlen) ausgewertet werden.
Diese werden als farbige Kreise dargestellt.
Falls sich 3 gleichfarbige Felder in einer Reihe befinden, wird dies als Gewinn verbucht und das "Guthaben" des Spielers wird anhand der Anzahl dieser "Reihen" erhört.

Allerdings wird die Applikation nach ca 14 Durchläufen immer langsamer und hängt sich schließlich auf.
Ich benutze Bluej und Ubuntu Linux
und außerdem das OpenJDK.

Wenn ich den Debugger von Bluej starte auf 'Step' klicke (,Ich gehe einmal davon aus, dass man den Debugger so startet^^,) erscheint die Fehlermeldung:

```
java.lang.NullPointerException
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:287)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:316)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:268)
	at bluej.runtime.ExecServer$3.run(ExecServer.java:814)
```

Wenn ich das Programm an sich starte erscheinen folgende Fehlermeldungen
(In der main-Funktion gebe einen lehren String aus um mir die Fehlermeldungen in der Konsole anzeigen zu lassen.
:

```
Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException
	at Spiel2.paint(Spiel2.java:134)
	at javax.swing.RepaintManager.paintDirtyRegions(RepaintManager.java:751)
	at javax.swing.RepaintManager.paintDirtyRegions(RepaintManager.java:696)
	at javax.swing.RepaintManager.prePaintDirtyRegions(RepaintManager.java:676)
	at javax.swing.RepaintManager.access$700(RepaintManager.java:57)
	at javax.swing.RepaintManager$ProcessingRunnable.run(RepaintManager.java:1550)
	at java.awt.event.InvocationEvent.dispatch(InvocationEvent.java:226)
	at java.awt.EventQueue.dispatchEvent(EventQueue.java:602)
	at java.awt.EventDispatchThread.pumpOneEventForFilters(EventDispatchThread.java:275)
	at java.awt.EventDispatchThread.pumpEventsForFilter(EventDispatchThread.java:200)
	at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:190)
	at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:185)
	at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:177)
	at java.awt.EventDispatchThread.run(EventDispatchThread.java:138)
```

Da ich keine Ahnung habe, wo genau der Fehler liegt, poste ich einfach einmal den kompletten Quelltext.

-----------------------------------------------------------------------------------------------------------------

```
/*Code der Klasse 'Luck'*/

import java.awt.Graphics;

public class Luck
{
    Konstanten konstanten   =   new Konstanten();

    static int cons = 3;
    private int[][] luckbox = new int[cons][cons];

    public Luck()
    {
        getluck();
    }

    
    public void getluck()
    {
        for(int a=0; a<cons; ++a)
        {
            for(int b=0; b<cons; ++b)
            {
                luckbox[a][b] = (int) Math.round( Math.random()*konstanten.farben);
            }
        }
    }
    
    public void seeluck()
    {
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        for(int a=0; a<cons; ++a)
        {
            for(int b=0; b<cons; ++b)
            {
                System.out.println("luckbox["+a+"]["+b+"] = "+luckbox[a][b]);
            }
        }
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
    }

    public int[][] getluckbox()
    {
        
        return luckbox;
    }

}
```


```
/*Code der Klasse 'LuckInterpreter'*/
import java.awt.*;
import java.util.*;
import java.lang.Thread;
import javax.swing.*;

public class LuckInterpreter
{
    Luck l					= new Luck();
	Konstanten konstanten	= new Konstanten();
    int r					= (int) (0.1*konstanten.width);
    Thread thread			= new Thread();

    public LuckInterpreter()
    {
        
    }

    public void interpret( Graphics g, int[][] lb )
    {
        int[] pos = new int[2];
        
        for(int a=0; a<l.cons; ++a)
        {
            for(int b=0; b<l.cons; ++b)
            {
                pos[0] = getPos(g,a,'x');
                pos[1] = getPos(g,b,'y');
                if(lb[a][b]==(0))
                {
                    g.setColor(Color.blue);	//white
                }
                if(lb[a][b]==(1))
                {
                    g.setColor(Color.red);	//black
                }
                if(lb[a][b]==(2))
                {
                    g.setColor(Color.cyan);		//red
                }
                if(lb[a][b]==(3))
                {
                    g.setColor(Color.green);		//pink
                }
                if(lb[a][b]==(4))
                {
                    g.setColor(Color.orange);	//orange
                }
                if(lb[a][b]==(5))
                {
                    g.setColor(Color.yellow);	//yellow
                }
                if(lb[a][b]==(6))
                {
                    g.setColor(Color.pink);	//green
                }
                if(lb[a][b]==(7))
                {
                    g.setColor(Color.magenta);	//magenta
                }
                if(lb[a][b]==(8))
                {
                    g.setColor(Color.black);		//cyan
                }
                if(lb[a][b]==(9))
                {
                    g.setColor(Color.white);		//blue
                }
//System.out.println("lb["+a+"]["+b+"] = "+lb[a][b]);
                g.drawOval(pos[0],pos[1],r,r);
                g.fillOval(pos[0],pos[1],r,r); 
/*System.out.println("PosX["+a+"]["+b+"] = "+pos[0]);
System.out.println("PosY["+a+"]["+b+"] = "+pos[1]);*/
            }
        }
    }

    

    public int getPos( Graphics g, int ab, char xy)
    {
        int pos;
        int b = (int) (konstanten.width/3);
		int l = r;
        int abstand = (int) (2.2*r);
        
        pos = ab*abstand;
		if(xy=='x')
		{
			pos += b;
			return pos;
		}
		if(xy=='y')
		{
			pos += l;
			return pos;
		}
        else
		{
			pos += 400;
			return pos;
		}
		
    }
    
    public void setluck()
    {
        
    }



    public int luckAuswerten( Graphics g, int[][] lb )
    {
        int gewonnen = 0;
        for(int a=0; a<l.cons; ++a)
        {
            if(lb[a][0]==lb[a][1])
			{
				if(lb[a][0]==lb[a][2])
				{
					++gewonnen;
					/*System.out.println("**********************");
					System.out.println("gewonnen");
					System.out.println("**********************");*/
				}
			}
        }

		for(int b=0; b<l.cons; ++b)
        {
            if(lb[0][b]==lb[1][b])
			{
				if(lb[0][b]==lb[2][b])
				{
					++gewonnen;
					/*System.out.println("**********************");
					System.out.println("gewonnen");
					System.out.println("**********************");*/
				}
			}
        }

		if(lb[0][0]==lb[1][1])
		{
			if(lb[0][0]==lb[2][2])
			{
				++gewonnen;
					/*System.out.println("**********************");
					System.out.println("gewonnen");
					System.out.println("**********************");*/
			}
		}

		if(lb[0][2]==lb[1][1])
		{
			if(lb[0][2]==lb[2][0])
			{
				++gewonnen;
			}
		}
		
		return gewonnen;
    }

	public String gewonnen( int i )
	{
		if( i>0 )
		{
			return "ja";
		}
		else
		{
			return "nein";
		}
	}
}
```


```
/*Code der Klasse 'Konto'*/
import java.awt.*;

public class Konto
{
    private int guthaben;
    private int einsatz;
	private int gewinn;

    public Konto()
    {
        guthaben = 	50;
        einsatz  = 	5;
		gewinn	=	0;
    }

    public void drawGuthaben(Graphics g, int x, int y)
    {
        g.drawString( "Guthaben : "+guthaben, x, y );
    }
    
    public int incGuthaben(int gewonnen)
    {
		gewinn = (int) Math.pow( (double) gewonnen, (double) einsatz );
        guthaben += gewinn;
		return gewinn;
    }

    public int getGuthaben()
    {
        return guthaben;
    }

    public void bezahlen()
    {
        //System.out.println("Guthaben = "+guthaben);
        guthaben -= einsatz;
        //System.out.println("Guthaben = "+guthaben);
    }

	public int getEinsatz()
	{
		return einsatz;
	}
}
```


```
/*Code der Klasse 'Konstanten'*/

/*
Auslagerungsklasse fuer saemtliche benoetigte Konstanten, deren interne Lagerung zu Problemen oder Unangenehmheiten fuehren koennte,
siehe Wechselbeziehung: Spiel2 <-> LuckInterpreter

    ...wird ausgelagert..falls benoetigt..
*/

public class Konstanten
{
    /*Konstanten von 'Luck'*/
    int farben;
    /*Ende der Konstanten von 'Luck'*/


    
    /*Konstanten von 'LuckInterpreter'*/
    
    /*Ende der Konstanten von 'LuckInterpreter'*/



    /*Konstanten von 'Spiel'*/

    /*Ende der Konstanten von 'Spiel'*/



    /*Konstanten von 'Spiel2'*/
    int lSize;	//letterSize

	String waehrung;

	int width;
    int height;
    int a1Y;
    int a2Y;
    int a3X;
    
		/*JButtons*/
	int buttonAS;		//ButtonAbStand
    int buttonPos1X;
    int buttonPos1Y;
    int buttonWidth1;
    int buttonHeight1;
	int buttonPos2X;
	int buttonPos2Y;
	int buttonWidth2;
	int buttonHeight2;
	int buttonPos3X;
	int buttonPos3Y;
	int buttonWidth3;
	int buttonHeight3;

		/*Positionen der gezeichneten Strings*/
	int sAbstand;			//Abstand der Strings
	int alPosX;				//Pos fuer 'allgemein'
	int alPosY;				//Pos fuer 'allgemein'
    int ghPosX;             //Pos fuer drawGuthaben()
    int ghPosY;             //Pos fuer drawGuthaben()

	int drPosX;				//Pos fuer 'diese Runde'
	int drPosY;				//Pos fuer 'diese Runde'
	int gwPosX;				//Pos fuer 'gewonnen'
	int gwPosY;				//Pos fuer 'gewonnen'
	int vfPosX;				//Pos fuer 'Vielfachheit'
	int vfPosY;				//Pos fuer 'Vielfachheit'
	int gsPosX;				//Pos fuer 'Gewinnsumme'
	int gsPosY;				//Pos fuer 'Gewinnsumme'
		/*Ende der Positionen der gezeichneten Strings*/

    int umoPosX1;        	//was uebermalt werden soll -> orange
    int umoPosY1;        	//was uebermalt werden soll -> orange
    int umoPosX2;       	//was uebermalt werden soll -> orange
    int umoPosY2;       	//was uebermalt werden soll -> orange
	int umgPosX1;       	//was uebermalt werden soll -> grau
	int umgPosY1;       	//was uebermalt werden soll -> grau
	int umgPosX2;       	//was uebermalt werden soll -> grau
	int umgPosY2;       	//was uebermalt werden soll -> grau
    /*Ende der Konstanten von 'Spiel2'*/



    /*Konstanten von 'Spiel3'*/

    /*Ende der Konstanten von 'Spiel3'*/



    /*Konstanten von 'Konto'*/

    /*Ende der Konstanten von 'Konto'*/



    public Konstanten()
    {
		lSize			=	14;

        farben          =   3;

		waehrung		=	"Euro";

        width           =   600;
        height          =   600;
        a1Y             =   (int) (0.25 *height);
        a2Y             =   (int) (0.75 *height);
        a3X             =   (int) (0.3  *width);
			/*Definitionen fuer JButtons*/
        buttonAS	=   (int) (0.0625*width);
		buttonPos1X   =   (int) (0.0625*width);
        buttonPos1Y   =   (int) (0.75 *height);
        buttonWidth1   =   125;
        buttonHeight1  =   40;
		buttonPos2X	=	buttonPos1X+buttonWidth1+buttonAS;
		buttonPos2Y	=	buttonPos1Y;
		buttonWidth2	=	100;
		buttonHeight2	=	40;
		buttonPos3X	=	buttonPos2X+buttonWidth2+buttonAS;
		buttonPos3Y	=	buttonPos1Y;
		buttonWidth3	=	100;
		buttonHeight3	=	40;

		/*Definition der Positionen*/
		sAbstand		=	15;

        alPosX			=	10;
		alPosY			=	40;
		ghPosX          =   alPosX;
        ghPosY          =   alPosY+2+sAbstand;
        
		drPosX			=	alPosX;
		drPosY			=	ghPosY+2*sAbstand;
		gwPosX			=	alPosX;
		gwPosY			=	drPosY+sAbstand;
		vfPosX			=	alPosX;
		vfPosY			=	gwPosY+sAbstand;
		gsPosX			=	alPosX;
		gsPosY			=	vfPosY+sAbstand;

        umoPosX1       	=   0;
        umoPosY1       	=   0;
        umoPosX2       	=   a3X;
        umoPosY2       	=   a2Y;
        umgPosX1		=	a3X;
		umgPosY1		=	0;
		umgPosX2		=	width;
		umgPosY2		=	a2Y;
    }

    
    
}
```


```
*/Code der Klasse 'Spiel2'*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;


public class Spiel2 extends JFrame implements ActionListener
{
    Konstanten konstanten   =   new Konstanten();
    Konto           konto   =   new Konto();
    Luck            l       =   new Luck();
    LuckInterpreter li      =   new LuckInterpreter();

	boolean proofS;
    String s;
    int gh;

	JButton jstart;
    JButton jbre;
    JButton jexit;
    boolean bbre;



	public Spiel2()
    {
		//setFont( new Font(Font.SERIF, Font.PLAIN, konstanten.lSize) );

        bbre = false;
		getContentPane().setLayout(null);
        setSize(konstanten.width,konstanten.height);
        setVisible(true);       
        addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                System.exit(0);
            }
        });
		
		/*Definition der JButtons*/
			/*JButton1*/
		jstart = new JButton( "(Neu)Start" );
		getContentPane().add( jstart );
		jstart.setBounds( konstanten.buttonPos1X, konstanten.buttonPos1Y, konstanten.buttonWidth1, konstanten.buttonHeight2 );
		jstart.addActionListener
		(
			new ActionListener()
			{
				public void actionPerformed(ActionEvent ev)
				{
					l		=	new Luck();
					konto	=	new Konto();
					bbre	=	true;
					jbre.addActionListener( this );
					repaint();
				}
			}				
		);
			/*JButton2*/
        jbre = new JButton( "spielen" );
        jbre.addActionListener( this );
        getContentPane().add( jbre );
		jbre.setVisible( bbre );
        jbre.setBounds( konstanten.buttonPos2X, konstanten.buttonPos2Y, konstanten.buttonWidth2, konstanten.buttonHeight2 );
		jexit = new JButton("Exit");
		jexit.addActionListener
		(
			new ActionListener()
			{
				public void actionPerformed( ActionEvent ev )
				{
					System.exit( 0 );
				}
			}
		);
		getContentPane().add( jexit );
		jexit.setBounds( konstanten.buttonPos3X, konstanten.buttonPos3Y, konstanten.buttonWidth3, konstanten.buttonHeight3 );
		
    }





    public void actionPerformed(ActionEvent evt)
    {
		if( konto.getGuthaben() >= konto.getEinsatz() );
		{
		    getGraphics().setColor( Color.lightGray );
			getGraphics().fillRect( konstanten.umgPosX1, konstanten.umgPosY1, konstanten.umgPosX2, konstanten.umgPosY2 );
			konto.bezahlen();
		    getContentPane().setBackground(Color.blue);
		    //l.getluck();
		    
		    
		    li.interpret(getGraphics(),l.getluckbox());
		    konto.incGuthaben( li.luckAuswerten( getGraphics(), l.getluckbox() ) );
		    repaint();
		}
    }

    public void gl()
    {
        l.getluck();
        repaint();
    }





    public static void main(String[] args)
    {
        System.out.println("");
        Spiel2 spiel2 = new Spiel2();
        spiel2.gl();

    }





    public void abgrenzen(Graphics g)
    {
        //g.drawLine( 0, konstanten.a1Y, konstanten.width, konstanten.a1Y );
        g.drawLine( 0, konstanten.a2Y, konstanten.width, konstanten.a2Y);
        g.drawLine( konstanten.a3X, 0, konstanten.a3X, konstanten.a2Y );
    }

    public void paint(Graphics g)
    {
		
        jbre.setVisible( bbre );
		//g.setColor(Color.black);
        abgrenzen(g);
        
        //System.out.println("gewonnen : "+li.luckAuswerten(g,l.getluckbox()));
        //konto.drawGuthaben( g, konstanten.ghPosX, konstanten.ghPosY );
        gh  = konto.getGuthaben();
        //System.out.println("Guthaben = "+gh);
        s   = Integer.toString(gh);
        
        
        g.setColor(Color.orange);
        g.fillRect( konstanten.umoPosX1, konstanten.umoPosY1, konstanten.umoPosX2, konstanten.umoPosY2 );   //uebermalt den vorher gezeichneten String
        
        beschriften(g);
    }

    public void beschriften(Graphics g)
    {
        g.setColor(Color.black);
        g.drawString( "allgemein: ", konstanten.alPosX, konstanten.alPosY );
        g.drawLine( konstanten.alPosX, konstanten.alPosY+2, konstanten.alPosX+61, konstanten.alPosY+2);
        g.drawString( "Guthaben : "+s+" "+konstanten.waehrung, konstanten.ghPosX, konstanten.ghPosY );

        g.drawString( "diese Runde:", konstanten.drPosX, konstanten.drPosY );
        g.drawLine( konstanten.drPosX, konstanten.drPosY+2, konstanten.drPosX+79, konstanten.drPosY+2 );
        g.drawString( "gewonnen : "+li.gewonnen(li.luckAuswerten(g,l.getluckbox())), konstanten.gwPosX, konstanten.gwPosY );
        g.drawString( "Vielfachheit : "+li.luckAuswerten(g,l.getluckbox())+"x", konstanten.vfPosX, konstanten.vfPosY );
        g.drawString( "Gewinnsumme : "+konto.incGuthaben(li.luckAuswerten(g,l.getluckbox()))+" "+konstanten.waehrung, konstanten.gsPosX, konstanten.gsPosY );
    }

	public void checkgame()
	{
		
	}
}
```
-----------------------------------------------------------------------------------------------------------------


Außerdem wird das Rechteck, das ich mit den Zeilen

```
getGraphics().setColor( Color.lightGray );
			getGraphics().fillRect( konstanten.umgPosX1, konstanten.umgPosY1, konstanten.umgPosX2, konstanten.umgPosY2 );
```
versuche zu zeichnen, schwarz statt hellgrau dargestellt.
Ich bin offenbar irgendwie unfähig die Zeile zu finden, in der ich die Farbe falsch gesetzt habe.
Falls jemand also zufällig über diesen Fehler stolpert, wäre es nett wenn er/sie mir bescheid sagen könnte.


----------



## SlaterB (11. Jul 2009)

wie dein Debugger geht weiß ich auch nicht,

Fehler ist wahrscheinlich:
bei setVisible(true) wird das Fenster wirklich auch angezeigt und paint() ausgeführt,
in paint() greifst du aber auf JButtons zu, die im Konstruktor erst später, nach setVisible(true), gesetzt werden
-> NullPointerException, Zugriff auf leere Variable

setVisible(true) immer als letztes ausführen


----------



## darkangel (11. Jul 2009)

Danke sehr.
Ich werde es mir auf jedenfall merken!
Sowohl der Debugger als auch das Programm liefern nun keinerlei Fehlermeldungen mehr.
Allerdings hängt sich das Programm weiterhin auf.


----------



## darkangel (12. Jul 2009)

Ok..es funktioniert jetzt.
Ich habe den Teil rausgenommen, dass der re-Button dauernd auf 'visible' gesetzt wird.
z.B. die Zeile
[Java]
jbre.setVisible( bbre );
[/Java]
in 'paint()'.
Könnte mir irgendjemand erklären, wieso es das Programm zum abstürzen bringt, wenn man einen bereits sichtbaren Button beim Neuzeichnen auf 'sichtbar' setzt?


----------



## SlaterB (12. Jul 2009)

vielleicht führte es wieder zum paint, wieder setVisible, wieder paint -> Endlosschleife


----------



## darkangel (12. Jul 2009)

hm..das wäre eine Erklärung...
Danke sehr.


----------

