OOP cannot find symbol

[Tonxxx]

hallo, ich habe ein programm geschrieben, welches ich jetzt ewas will in Objekte fassen.
ich habe nun eine klasse namens Punkte. nun habe ich bei zeile 344 gesagt das es punkte.getBreite() soll öffen um die breite abzufragen. doch er sagt mir nun das er :
can not find symbol
Symbol : variable punkte
location: class snake

dabei habe ich doch bei zeile 129 es instanziert, oder etwa nicht?

vielen dank für die Hilfe...

//Snake
import java.applet.*;
import java.awt.*;
import java.util.*;


public class Snake extends Applet implements Runnable
{
	// Initialisierung der Variablen
	int x_pos = 100;		// x - Position des Balles
	int y_pos = 100;		// y - Position des Balles

	int x_speed = 0;		// Geschwindigkeit des Balles in x - Richtung
	int y_speed = 0;		// Geschwindigkeit des Balles in y - Richtung

	int speed = 2;

	int radius = 10;		// Radius des Balles
//
	public int appletsize_x = 600; 	// Größe des Applets in x - Richtung
	public int appletsize_y = 600;		// Größe des Applets in y - Richtung
//
	int x_futter;			// Futter
	int y_futter;

	int b_futter = 20;		// Breite des Futters
	int h_futter = 20;		// Höhe des Futters
//
	int x_beweg;
	int y_beweg;	

	int x_be_speed = 0;
	int y_be_speed = 0;

	int be_speed = 1;

	int b_beweg = 20;
	int h_beweg = 20;

	int[] x_be;
	int[] y_be;

	int anzahl_be_punkte = 10;
//


	// Variablen für die Doppelpufferung
	private Image dbImage;
	private Graphics dbg;

	public void init()
	{
		setBackground (Color.blue);


	}

	public void start ()
	{
		// Schaffen eines neuen Threads, in dem das Spiel läuft
		Thread th = new Thread (this);
		// Starten des Threads
		th.start ();
	}

	public void stop()
	{

	}

	public void destroy()
	{

	}

	/* Diese Methode fängt das Ereigniss auf, das beim Drücken einer Keyboardtaste entsteht.
	Die Tasten Cursor links, rechts und die Space Taste haben dabei eine bestimmte Bedeutung.
	Wird eine andere Taste gedrückt, so wird ihr Integerwert in die Standardausgabe geschrieben. */
	public boolean keyDown (Event e, int key)
	{
		// linke Cursortaste
		if (key == Event.LEFT)
		{
			// Ball bewegt sich dann nach links
			x_speed = -speed;
			y_speed = 0;
		}
		// rechte Cursortaste
		else if (key == Event.RIGHT)
		{
			// Ball bewegt sich dann nach rechts
			x_speed = speed;
			y_speed = 0;
		}
		// hoch
		else if (key == 1004)//1004 = hoch
		{
			// Ball bewegt sich dann nach links
			y_speed = -speed;
			x_speed = 0;
		}
		// runter
		else if (key == 1005)//1005 = runter
		{
			// Ball bewegt sich dann nach rechts
			y_speed = speed;
			x_speed = 0;
		}
		// SpaceBar hat Wert 32
		else if (key == 32)
		{
			x_speed = 0;
			y_speed = 0;
		}
		else
		{
			// Ausgabe von gedrüktem Key und Zahlenwert an die Standardausgabe
			System.out.println ("Charakter: " + (char)key + " Integer Value: " + key);
		}

		return true;
	}

	public void run ()
	{
		// Erniedrigen der ThreadPriority um zeichnen zu erleichtern
		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
		
		Punkte punkte = new Punkte();


		//Zufallszahl
		Random zufallspos = new Random();

	// Zufallsort des Futters		
		x_futter = zufallspos.nextInt(appletsize_x - breite);
		y_futter = zufallspos.nextInt(appletsize_y - höhe);

		System.out.println("Futter x: " + x_futter);
		System.out.println("Futter y: " + y_futter);



	// Zufallsort der beweglichen Punkte
		x_be = new int[anzahl_be_punkte];
		for(int i=0; i<=anzahl_be_punkte -1; i++)
		{
			x_be[i] = zufallspos.nextInt(appletsize_x - breite);
			System.out.println("bewegliche Punkte x: " + x_be[i]);
	
		}

		y_be = new int[anzahl_be_punkte];
		for(int i=0; i<=anzahl_be_punkte -1; i++)
		{
			y_be[i] = zufallspos.nextInt(appletsize_x - höhe);	
			System.out.println("bewegliche Punkte y: " + y_be[i]);
	
		}
	// Zufallsrichtung der beweglichen Punkte

		final int N = 0;
		final int NO = 1;
		final int O = 2;
		final int SO = 3;
		final int S = 4;
		final int SW = 5;
		final int W = 6;
		final int NW = 7;
		

		for(int i=0; i<=anzahl_be_punkte -1; i++)
		{
			//x_futter = zufallspos.nextInt(7);	
		}

		x_be_speed = be_speed;

		// Solange true ist läuft der Thread weiter
		while (true)
		{
			// Wenn der Ball den rechten Rand berührt, dann prallt er ab
			if (x_pos > appletsize_x - radius)
			{
				// Ändern der Richtung des Balles
				x_speed = -speed;
			}
			// Ball brührt linken Rand und prallt ab
			else if (x_pos < radius)
			{
				// Ändern der Richtung des Balles
				x_speed = +speed;
			}

			// Verändern der x- Koordinate
			x_pos += x_speed;

			// Wenn der Ball den unteren Rand berührt, dann prallt er ab
			if (y_pos > appletsize_y - radius)
			{
				// Ändern der Richtung des Balles
				y_speed = -speed;
			}
			// Ball brührt oberen Rand und prallt ab
			else if (y_pos < radius)
			{
				// Ändern der Richtung des Balles
				y_speed = +speed;
			}

			// Verändern der y- Koordinate
			y_pos += y_speed;


			punkte.Punkte_erkennen(x_pos, y_pos, radius, x_speed, x_speed);

			// Futter erkennen

			if (   (x_futter + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius || 
			      	(x_futter + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius || 
			       	(x_futter + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius ||
			       	(x_futter  + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius ||
				x_pos + radius >= x_futter && x_pos + radius <= x_futter + b_futter && y_pos >= y_futter && y_pos <= y_futter + b_futter ||
				x_pos >= x_futter && x_pos <= x_futter + b_futter && y_pos - radius >= y_futter && y_pos - radius <= y_futter + b_futter ||
				x_pos - radius >= x_futter && x_pos - radius <= x_futter + b_futter && y_pos >= y_futter && y_pos <= y_futter + b_futter ||
				x_pos >= x_futter && x_pos <= x_futter + b_futter && y_pos + radius >= y_futter && y_pos + radius <= y_futter + b_futter   )
			{
	
				System.out.println("Fressen");

				// Fresszeit
				try
				{
					// Stoppen des Threads für in Klammern angegebene Millisekunden
					Thread.sleep (300);
				}
				catch (InterruptedException ex)
				{
					// do nothing
				}

				x_futter = zufallspos.nextInt(appletsize_x - b_futter);
				y_futter = zufallspos.nextInt(appletsize_y - h_futter);				
			
			}
			
		//	x_be_speed = be_speed;

			for(int i=0;i <= anzahl_be_punkte -1; i++)
			{
			
				// Wenn der bewegliche Punkt den rechten Rand berührt, dann prallt er ab
				if (x_be[i] > appletsize_x - b_beweg)
				{
					// Ändern der Richtung des Balles
					x_be_speed = -be_speed;
				}
				// bewegliche Punkt brührt linken Rand und prallt ab
				else if (x_be[i] < 0)
				{
					// Ändern der Richtung des Balles
					x_be_speed = +be_speed;
				}

				// Verändern der x- Koordinate
				//for(int i=0;i <= anzahl_be_punkte -1; i++)
				//{

					x_be[i] += x_be_speed;
				//}

				// Wenn der Ball den unteren Rand berührt, dann prallt er ab
				if (y_be[i] > appletsize_y - h_beweg)
				{
					// Ändern der Richtung des Balles
					y_be_speed = -be_speed;
				}

				// Ball brührt oberen Rand und prallt ab
				else if (y_be[i] < 0)
				{
					// Ändern der Richtung des Balles
					y_be_speed = +be_speed;
				}

				// Verändern der y- Koordinate
				//for(int i=0;i <= anzahl_be_punkte -1; i++)
				//{
					y_beweg += y_be_speed;
				//}
			}

			// Neuzeichnen des Applets
			repaint();

			try
			{
				// Stoppen des Threads für in Klammern angegebene Millisekunden
				Thread.sleep (0);
			}
			catch (InterruptedException ex)
			{
				// do nothing
			}

			// Zurücksetzen der ThreadPriority auf Maximalwert
			Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
		}
	}

	/** Update - Methode, Realisierung der Doppelpufferung zur Reduzierung des Bildschirmflackerns */
	public void update (Graphics g)
	{
		// Initialisierung des DoubleBuffers
		if (dbImage == null)
		{
			dbImage = createImage (this.getSize().width, this.getSize().height);
			dbg = dbImage.getGraphics ();
		}

		// Bildschirm im Hintergrund löschen
		dbg.setColor (getBackground ());
		dbg.fillRect (0, 0, this.getSize().width, this.getSize().height);

		// Auf gelöschten Hintergrund Vordergrund zeichnen
		dbg.setColor (getForeground());
		paint (dbg);

		// Nun fertig gezeichnetes Bild Offscreen auf dem richtigen Bildschirm anzeigen
		g.drawImage (dbImage, 0, 0, this);
	}

	public void paint (Graphics g)
	{
		// Kugel
		g.setColor  (Color.red);

		g.fillOval (x_pos - radius, y_pos - radius, 2 * radius, 2 * radius);

		// Punkte
		for(int i=0; i<=anzahl_punkte -1; i++)
		{
			g.setColor  (Color.black);
			g.fillRect (x_p[i], y_p[i],punkte.getBreite(),punkte.getHöhe());	
		}

		// Beweglichen Punkte
		for(int i=0; i<=anzahl_be_punkte -1; i++)
		{
			g.setColor  (Color.pink);
			g.fillRect (x_be[i], y_be[i],b_beweg,h_beweg);	
		}
		
		//Futter
		g.setColor  (Color.yellow);
		g.fillRect (x_futter, y_futter,b_futter,h_futter);


	}
}

class Punkte
{
	private int x_punkt;		// Punkte
	private int y_punkt;

	private int breite;		// breite der Punkte
	private int höhe;			// Höhe der Punkte

	private int[] x_p;
	private int[] y_p;

	private int anzahl_punkte = 20;	

	//Konstruktor
	public Punkte()
	{
		x_punkt = 0;		// Punkte
		y_punkt = 0;

		breite = 20;		// breite der Punkte
		höhe = 20;		// Höhe der Punkte

		anzahl_punkte = 20;	
	}

	//get_set methoden
	public int getX_punkt()
	{
		return x_punkt;
	}
		
	public void setX_punkt(int x_punkt)
	{
		this.x_punkt 	= x_punkt;
	}
	
	public int getY_punkt()
	{
		return y_punkt;
	}

	public void setY_punkt(int y_punkt)
	{
		this.y_punkt 	= y_punkt;
	}

	public int getBreite()
	{
		return breite;
	}		
	public void setBreite(int breite)
	{
		this.breite	= breite;
	}
	public int getHöhe()
	{
		return höhe;
	}
	public void setHöhe(int höhe)
	{
		this.höhe	= höhe;
	}

	public int getAnzahl_punkte()
	{
		return anzahl_punkte;
	}
	public void setAnzahl_punkte(int anzahl_punkte)
	{
		this.anzahl_punkte= anzahl_punkte;
	}

	public void Zufallspos(int appletsize_x, int appletsize_y)
	{
		Random zufallsort = new Random();

		x_p = new int[anzahl_punkte];
		for(int i=0; i<=anzahl_punkte -1; i++)
		{
			x_p[i] = zufallsort.nextInt(appletsize_x - breite);
			System.out.println("Punkte x: " + x_p[i]);
	
		}

		y_p = new int[anzahl_punkte];
		for(int i=0; i<=anzahl_punkte -1; i++)
		{
			y_p[i] = zufallsort.nextInt(appletsize_x - höhe);	
			System.out.println("Punkte y: " + y_p[i]);
	
		}

	}
	
	public int Punkte_erkennen(int x_pos, int y_pos, int radius, int x_speed, int y_speed)
	{
			// Punkte erkennen
			for (int i=0; i<=anzahl_punkte -1; i++)
			{
				x_punkt = x_p[i];
				y_punkt = y_p[i];

				if (   (x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
			      		(x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
			       		(x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
			       		(x_punkt  + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
					x_pos + radius >= x_punkt && x_pos + radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
					x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos - radius >= y_punkt && y_pos - radius <= y_punkt + breite ||
					x_pos - radius >= x_punkt && x_pos - radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
					x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos + radius >= y_punkt && y_pos + radius <= y_punkt + breite   )
				{

				
					//Abprallen von den Punkten
					if (x_speed != 0)
					{
						x_speed = -x_speed;
					}

					if (y_speed != 0)
					{
						y_speed = -y_speed;
					}

					System.out.println("Dead!");				
			
				}

			}

		return x_speed;
		return y_speed;
	}

}

 

[Landei]

In Zeile 129 hast zwar punkte definiert, aber innerhalb einer anderen Methode - also als lokale Variable, nicht als Objekt-Variable.

Schreibe oben zu deinen anderen Member-Variablen einfach Punkte punkte = new Punkte();
und lösche diese Zeile aus run.

Dein Code könnte etwas Optimierung vertragen. Schon von der if-Anweisung in Zeile 219 bekomme ich Kopfschmerzen...

 

[Tonxxx]

ja ich obtimiere es gerade, doch für die if anweisung, habe ich noch keine lösung gefunden..

 

[Tonxxx]

hallo, kaum hat man das letzte problem gelöst, kommt das nächste!!!
da ich den quellcode angepasst habe, lade ich ihn noch einmal:

//Snake
import java.applet.*;
import java.awt.*;
import java.util.*;


public class Snake extends Applet implements Runnable
{
	// Initialisierung der Variablen
	int x_pos = 100;		// x - Position des Balles
	int y_pos = 100;		// y - Position des Balles

	int x_speed = 0;		// Geschwindigkeit des Balles in x - Richtung
	int y_speed = 0;		// Geschwindigkeit des Balles in y - Richtung

	int speed = 2;

	int radius = 10;		// Radius des Balles
//
	int appletsize_x = 600; 	// Größe des Applets in x - Richtung
	int appletsize_y = 600;		// Größe des Applets in y - Richtung
//
	int x_futter;			// Futter
	int y_futter;

	int b_futter = 20;		// Breite des Futters
	int h_futter = 20;		// Höhe des Futters
//
	int x_beweg;
	int y_beweg;	

	int x_be_speed = 0;
	int y_be_speed = 0;

	int be_speed = 1;

	int b_beweg = 20;
	int h_beweg = 20;

	int[] x_be;
	int[] y_be;

	int anzahl_be_punkte = 10;
//
	Punkte punkte = new Punkte();

	// Variablen für die Doppelpufferung
	private Image dbImage;
	private Graphics dbg;

	public void init()
	{
		setBackground (Color.blue);


	}

	public void start ()
	{
		// Schaffen eines neuen Threads, in dem das Spiel läuft
		Thread th = new Thread (this);
		// Starten des Threads
		th.start ();

		System.out.println("start : Start");
	}

	public void stop()
	{

	}

	public void destroy()
	{

	}

	/* Diese Methode fängt das Ereigniss auf, das beim Drücken einer Keyboardtaste entsteht.
	Die Tasten Cursor links, rechts und die Space Taste haben dabei eine bestimmte Bedeutung.
	Wird eine andere Taste gedrückt, so wird ihr Integerwert in die Standardausgabe geschrieben. */
	public boolean keyDown (Event e, int key)
	{
		System.out.println("start : keyDown");
		// linke Cursortaste
		if (key == Event.LEFT)
		{
			// Ball bewegt sich dann nach links
			x_speed = -speed;
			y_speed = 0;
		System.out.println("x_speed =" + x_speed);
		System.out.println("y_speed =" + y_speed);
		System.out.println("speed =" + speed);
		}
		// rechte Cursortaste
		else if (key == Event.RIGHT)
		{
			// Ball bewegt sich dann nach rechts
			x_speed = speed;
			y_speed = 0;
		}
		// hoch
		else if (key == 1004)//1004 = hoch
		{
			// Ball bewegt sich dann nach links
			y_speed = -speed;
			x_speed = 0;
		}
		// runter
		else if (key == 1005)//1005 = runter
		{
			// Ball bewegt sich dann nach rechts
			y_speed = speed;
			x_speed = 0;
		}
		// SpaceBar hat Wert 32
		else if (key == 32)
		{
			x_speed = 0;
			y_speed = 0;
		}
		else
		{
			// Ausgabe von gedrüktem Key und Zahlenwert an die Standardausgabe
			System.out.println ("Charakter: " + (char)key + " Integer Value: " + key);
		}
		System.out.println("finish : keyDown");
		return true;

	}

	public void run ()
	{
		System.out.println("start : run");
		// Erniedrigen der ThreadPriority um zeichnen zu erleichtern
		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);


		//Zufallszahl
		Random zufallspos = new Random();

	// Zufallsort des Futters		
		x_futter = zufallspos.nextInt(appletsize_x - punkte.getBreite());
		y_futter = zufallspos.nextInt(appletsize_y - punkte.getHöhe());

		System.out.println("Futter x: " + x_futter);
		System.out.println("Futter y: " + y_futter);

	// Zufallsort der Punkte

		punkte.Zufallspos_X(appletsize_x, appletsize_y);

		punkte.Zufallspos_X(appletsize_x, appletsize_y);

	// Zufallsort der beweglichen Punkte
		x_be = new int[anzahl_be_punkte];
		for(int i=0; i<=anzahl_be_punkte -1; i++)
		{
			x_be[i] = zufallspos.nextInt(appletsize_x - punkte.getBreite());
			System.out.println("bewegliche Punkte x: " + x_be[i]);
	
		}

		y_be = new int[anzahl_be_punkte];
		for(int i=0; i<=anzahl_be_punkte -1; i++)
		{
			y_be[i] = zufallspos.nextInt(appletsize_x - punkte.getHöhe());	
			System.out.println("bewegliche Punkte y: " + y_be[i]);
	
		}
	// Zufallsrichtung der beweglichen Punkte

		final int N = 0;
		final int NO = 1;
		final int O = 2;
		final int SO = 3;
		final int S = 4;
		final int SW = 5;
		final int W = 6;
		final int NW = 7;
		

		for(int i=0; i<=anzahl_be_punkte -1; i++)
		{
			//x_futter = zufallspos.nextInt(7);	
		}

		x_be_speed = be_speed;

		// Solange true ist läuft der Thread weiter
		while (true)
		{
		int loop =0;
		loop++;
		System.out.println("while start " + loop);
			// Wenn der Ball den rechten Rand berührt, dann prallt er ab
			if (x_pos > appletsize_x - radius)
			{
				// Ändern der Richtung des Balles
				x_speed = -speed;
			}
			// Ball brührt linken Rand und prallt ab
			else if (x_pos < radius)
			{
				// Ändern der Richtung des Balles
				x_speed = +speed;
			}
		System.out.println("while verändern der X koordinate " + loop);
			// Verändern der x- Koordinate
			x_pos += x_speed;
		System.out.println("while verändert der X koordinate " + loop);

			// Wenn der Ball den unteren Rand berührt, dann prallt er ab
			if (y_pos > appletsize_y - radius)
			{
				// Ändern der Richtung des Balles
				y_speed = -speed;
			}
			// Ball brührt oberen Rand und prallt ab
			else if (y_pos < radius)
			{
				// Ändern der Richtung des Balles
				y_speed = +speed;
			}
		System.out.println("while verändern der Y koordinate " + loop);
			// Verändern der y- Koordinate
			y_pos += y_speed;
		System.out.println("while verändert der Y koordinate " + loop);

			punkte.Punkte_erkennen1(x_pos, y_pos, radius, x_speed, x_speed);
			punkte.Punkte_erkennen2(x_pos, y_pos, radius, x_speed, x_speed);

			// Futter erkennen

			if (   (x_futter + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius || 
			      	(x_futter + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius || 
			       	(x_futter + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius ||
			       	(x_futter  + b_futter -(x_pos + radius)) * (x_futter + b_futter -(x_pos + radius)) + (y_futter + h_futter -(y_pos + radius)) * (y_futter + h_futter -(y_pos + radius)) <= radius * radius ||
				x_pos + radius >= x_futter && x_pos + radius <= x_futter + b_futter && y_pos >= y_futter && y_pos <= y_futter + b_futter ||
				x_pos >= x_futter && x_pos <= x_futter + b_futter && y_pos - radius >= y_futter && y_pos - radius <= y_futter + b_futter ||
				x_pos - radius >= x_futter && x_pos - radius <= x_futter + b_futter && y_pos >= y_futter && y_pos <= y_futter + b_futter ||
				x_pos >= x_futter && x_pos <= x_futter + b_futter && y_pos + radius >= y_futter && y_pos + radius <= y_futter + b_futter   )
			{
	
				System.out.println("Fressen");

				// Fresszeit
				try
				{
					// Stoppen des Threads für in Klammern angegebene Millisekunden
					Thread.sleep (300);
				}
				catch (InterruptedException ex)
				{
					// do nothing
				}

				x_futter = zufallspos.nextInt(appletsize_x - b_futter);
				y_futter = zufallspos.nextInt(appletsize_y - h_futter);				
			
			}
			
		//	x_be_speed = be_speed;

			for(int i=0;i <= anzahl_be_punkte -1; i++)
			{
			
				// Wenn der bewegliche Punkt den rechten Rand berührt, dann prallt er ab
				if (x_be[i] > appletsize_x - b_beweg)
				{
					// Ändern der Richtung des Balles
					x_be_speed = -be_speed;
				}
				// bewegliche Punkt brührt linken Rand und prallt ab
				else if (x_be[i] < 0)
				{
					// Ändern der Richtung des Balles
					x_be_speed = +be_speed;
				}

				// Verändern der x- Koordinate
				//for(int i=0;i <= anzahl_be_punkte -1; i++)
				//{

					x_be[i] += x_be_speed;
				//}

				// Wenn der Ball den unteren Rand berührt, dann prallt er ab
				if (y_be[i] > appletsize_y - h_beweg)
				{
					// Ändern der Richtung des Balles
					y_be_speed = -be_speed;
				}

				// Ball brührt oberen Rand und prallt ab
				else if (y_be[i] < 0)
				{
					// Ändern der Richtung des Balles
					y_be_speed = +be_speed;
				}

				// Verändern der y- Koordinate
				//for(int i=0;i <= anzahl_be_punkte -1; i++)
				//{
					y_beweg += y_be_speed;
				//}
			}

			// Neuzeichnen des Applets
			repaint();

			try
			{
				// Stoppen des Threads für in Klammern angegebene Millisekunden
				Thread.sleep (0);
			}
			catch (InterruptedException ex)
			{
				// do nothing
			}
		System.out.println("while end " + loop);
			// Zurücksetzen der ThreadPriority auf Maximalwert
			Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
		}

	}

	/** Update - Methode, Realisierung der Doppelpufferung zur Reduzierung des Bildschirmflackerns */
	public void update (Graphics g)
	{
		System.out.println("start : update");
		// Initialisierung des DoubleBuffers
		if (dbImage == null)
		{
			dbImage = createImage (this.getSize().width, this.getSize().height);
			dbg = dbImage.getGraphics ();
		}

		// Bildschirm im Hintergrund löschen
		dbg.setColor (getBackground ());
		dbg.fillRect (0, 0, this.getSize().width, this.getSize().height);

		// Auf gelöschten Hintergrund Vordergrund zeichnen
		dbg.setColor (getForeground());
		paint (dbg);

		// Nun fertig gezeichnetes Bild Offscreen auf dem richtigen Bildschirm anzeigen
		g.drawImage (dbImage, 0, 0, this);
		System.out.println("finish : update");
	}

	public void paint (Graphics g)
	{
		System.out.println("start : paint");
		// Kugel
		g.setColor  (Color.red);

		g.fillOval (x_pos - radius, y_pos - radius, 2 * radius, 2 * radius);

		// Punkte
		for(int i=0; i<= punkte.getAnzahl_punkte() -1; i++)
		{
			g.setColor  (Color.black);
			g.fillRect (punkte.getX_p(i),punkte.getY_p(i),punkte.getBreite(),punkte.getHöhe());	
		}

		// Beweglichen Punkte
		for(int i=0; i<=anzahl_be_punkte -1; i++)
		{
			g.setColor  (Color.pink);
			g.fillRect (x_be[i], y_be[i],b_beweg,h_beweg);	
		}
		
		//Futter
		g.setColor  (Color.yellow);
		g.fillRect (x_futter, y_futter,b_futter,h_futter);
		System.out.println("finish : paint");

	}
}

class Punkte
{
	private int x_punkt;		// Punkte
	private int y_punkt;

	private int breite;		// breite der Punkte
	private int höhe;			// Höhe der Punkte

	private int[] x_p;
	private int[] y_p;

	private int anzahl_punkte = 20;	

	//Konstruktor
	public Punkte()
	{
		System.out.println("start : Punkte.konstruktor");
		x_punkt = 0;		// Punkte
		y_punkt = 0;

		breite = 20;		// breite der Punkte
		höhe = 20;		// Höhe der Punkte

		anzahl_punkte = 20;
		System.out.println("finish : Punkte.konstruktor");	
	}

	//get_set methoden
	public int getX_punkt()
	{
		return x_punkt;
	}
		
	public void setX_punkt(int x_punkt)
	{
		this.x_punkt 	= x_punkt;
	}
	
	public int getY_punkt()
	{
		return y_punkt;
	}

	public void setY_punkt(int y_punkt)
	{
		this.y_punkt 	= y_punkt;
	}

	public int getBreite()
	{
		return breite;
	}		
	public void setBreite(int breite)
	{
		this.breite	= breite;
	}
	public int getHöhe()
	{
		return höhe;
	}
	public void setHöhe(int höhe)
	{
		this.höhe	= höhe;
	}

	public int getX_p(int i)
	{
		return x_p[i];
	}
	public void setX_p(int[] x_p)
	{
		this.x_p	= x_p;
	}
	public int getY_p(int i)
	{
		return y_p[i];
	}
	public void setY_p(int[] y_p)
	{
		this.y_p	= y_p;
	}

	public int getAnzahl_punkte()
	{
		return anzahl_punkte;
	}
	public void setAnzahl_punkte(int anzahl_punkte)
	{
		this.anzahl_punkte= anzahl_punkte;
	}

	public int[] Zufallspos_X(int appletsize_x, int appletsize_y)
	{
		System.out.println("start : zufallspos_X");
		Random zufallsort = new Random();

		x_p = new int[anzahl_punkte];
		for(int i=0; i<=anzahl_punkte -1; i++)
		{
			x_p[i] = zufallsort.nextInt(appletsize_x - breite);
			System.out.println("Punkte x: " + x_p[i]);
	
		}
			System.out.println("finish : Zufallspos_X");
			return x_p;

	}
	public int[] Zufallspos_Y(int appletsize_x, int appletsize_y)
	{
		System.out.println("start : zufallspos_Y");

		Random zufallsort = new Random();

		y_p = new int[anzahl_punkte];
		for(int i=0; i<=anzahl_punkte -1; i++)
		{
			y_p[i] = zufallsort.nextInt(appletsize_x - höhe);	
			System.out.println("Punkte y: " + y_p[i]);
	
		}
		System.out.println("finish : Zufallspos_Y");
		return y_p;
	}
	
	public int Punkte_erkennen1(int x_pos, int y_pos, int radius, int x_speed, int y_speed)
	{
		System.out.println("start : punkteerkennen1");
			// Punkte erkennen
			for (int i=0; i<=anzahl_punkte -1; i++)
			{
			System.out.println("start : punkteerkennen1 for schleife");
				x_punkt = getX_p(i);
			System.out.println("start : punkteerkennen1 for schleifenur x");
				y_punkt = getY_p(i);
			System.out.println("start : punkteerkennen1 for schleife x und y");
			System.out.println("finish : punkteerkennen1 for schleife x-punkte = x_p[i]");

				if (   (x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
			      		(x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
			       		(x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
			       		(x_punkt  + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
					x_pos + radius >= x_punkt && x_pos + radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
					x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos - radius >= y_punkt && y_pos - radius <= y_punkt + breite ||
					x_pos - radius >= x_punkt && x_pos - radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
					x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos + radius >= y_punkt && y_pos + radius <= y_punkt + breite   )
				{

					System.out.println("start : punkteerkennen1 if anweisung");
					//Abprallen von den Punkten
					if (x_speed != 0)
					{
						x_speed = -x_speed;
					}

					if (y_speed != 0)
					{
						y_speed = -y_speed;
					}

					System.out.println("Dead!");				
			
				}

			}
		System.out.println("finish : punkteerkennen1");
		return x_speed;
	}
	public int Punkte_erkennen2(int x_pos, int y_pos, int radius, int x_speed, int y_speed)
	{
		System.out.println("start : punkteerkennen2");
			// Punkte erkennen
			for (int i=0; i<=anzahl_punkte -1; i++)
			{
				x_punkt = x_p[i];
				y_punkt = y_p[i];

				if (   (x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
			      		(x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius || 
			       		(x_punkt + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
			       		(x_punkt  + breite -(x_pos + radius)) * (x_punkt + breite -(x_pos + radius)) + (y_punkt + höhe -(y_pos + radius)) * (y_punkt + höhe -(y_pos + radius)) <= radius * radius ||
					x_pos + radius >= x_punkt && x_pos + radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
					x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos - radius >= y_punkt && y_pos - radius <= y_punkt + breite ||
					x_pos - radius >= x_punkt && x_pos - radius <= x_punkt + breite && y_pos >= y_punkt && y_pos <= y_punkt + breite ||
					x_pos >= x_punkt && x_pos <= x_punkt + breite && y_pos + radius >= y_punkt && y_pos + radius <= y_punkt + breite   )
				{

				
					//Abprallen von den Punkten
					if (x_speed != 0)
					{
						x_speed = -x_speed;
					}

					if (y_speed != 0)
					{
						y_speed = -y_speed;
					}

					System.out.println("Dead!");				
			
				}

			}
		System.out.println("finish : punkteerkennen21");
		return y_speed;
	}

}

nun hat er noch zeile 513 ausgefürt doch dann ist fertig!
danach spuckt er nur noch diese fehlermeldung aus:

Exception in thread "Thread-3" java.lang.NullPointerException
at Punkte.getY_p(Snake.java:456)
at Punkte.Punkte_erkennen1(Snake.java:514)
at Snake.run(Snake.java:229)
at java.lang.Thread.run(Thread.java:595)

was mache ich jetzt anders, oder falsch?

 

[bygones]

zu viel code ;-)

du greifst auf einen array zu, der wahr. nicht initialisiert wurde...