# Applet besitzt keinen öffentlichen Konstruktor



## Reality (12. Sep 2004)

Hi,
ich habe gerade ein Spiele-Tutorial kompiliert und da wollte ich auch mal ein paar Sterne hinzufügen.
Wenn die Anzahl der Sterne bei x<=125 bleibt, kommt diese Fehlermeldung nicht und die Sterne werden auch gezeichnet, aber wenn ich die Anzahl auf 130 erhöhe, kommt die oben genannte Fehlermeldung.



> Applet Main besitzt keinen öffentlichen Konstruktor Main()



Hier der Code:

```
import java.awt.*;
import java.util.*;

public class Stars {
  int posX[] = new int[130];
  int posY[] = new int[130];
  
  Stars(){
    Random r = new Random();
    for(byte i = 0; i<posX.length; i++){
      posX[i] = r.nextInt(400);
      posY[i] = r.nextInt(300);
    }
  }
  
  public void drawStars(Graphics g){
    g.setColor(Color.white);
    
    for(byte i = 0; i<posX.length; i++)
    g.fillOval(posX[i], posY[i], 1, 1);
  }
}
```


```
import java.applet.*;
import java.awt.*;

public class Main extends Applet implements Runnable
{
        // variables
        private Thread th;
        private Player player;
        private Shot [] shots;

        // speed constants
        private final int shotSpeed = -2;
        private final int playerLeftSpeed = -2;
        private final int playerRightSpeed = 2;

        // move flags
        private boolean playerMoveLeft;
        private boolean playerMoveRight;
        private Stars stars = new Stars();
        
        // double buffering
        private Image dbImage;
        private Graphics dbg;

        public void init()
        {
                setBackground (Color.black);
                player = new Player(150, 280);
                shots = new Shot[5];
                
        }

        public void start ()
        {
                th = new Thread(this);
                th.start ();
        }

        public void stop()
        {
                th.stop();
        }

        public void destroy()
        {
                th.stop();
        }

        public void run ()
        {
                Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

                while (true)
                {
                        // do operations on shots in shots array
                        for(int i=0; i<shots.length; i++)
                        {
                                if(shots[i] != null)
                                {
                                        // move shot
                                        shots[i].moveShot(shotSpeed);

                                        // test if shot is out
                                        if(shots[i].getYPos() < 0)
                                        {
                                                // remove shot from array
                                                shots[i] = null;
                                        }

                                        // other operations
                                        // ...
                                        // test for collisions with enemies
                                        // ...
                                }
                        }


                        // move player
                        if(playerMoveLeft)
                        {
                                player.moveX(playerLeftSpeed);
                        }
                        else if(playerMoveRight)
                        {
                                player.moveX(playerRightSpeed);
                        }

                        // repaint applet
                        repaint();

                        try
                        {
                                Thread.sleep(10);
                        }
                        catch (InterruptedException ex)
                        {
                                // do nothing
                        }

                        Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
                }
        }

        public boolean keyDown(Event e, int key)
        {
                if(key == Event.LEFT)
                {
                        playerMoveLeft = true;
                }
                else if(key == Event.RIGHT)
                {
                        playerMoveRight = true;
                }
                else if(key == 32)
                {
                        // generate new shot and add it to shots array
                        for(int i=0; i<shots.length; i++)
                        {
                                if(shots[i] == null)
                                {
                                        shots[i] = player.generateShot();
                                        break;
                                }
                        }
                }

                return true;
        }

        public boolean keyUp(Event e, int key)
        {
                if(key == Event.LEFT)
                {
                        playerMoveLeft = false;
                }
                else if(key == Event.RIGHT)
                {
                        playerMoveRight = false;
                }

                return true;
        }


        public void update (Graphics g)
        {
                if (dbImage == null)
                {
                        dbImage = createImage (this.getSize().width, this.getSize().height);
                        dbg = dbImage.getGraphics ();
                }

                dbg.setColor (getBackground ());
                dbg.fillRect (0, 0, this.getSize().width, this.getSize().height);

                dbg.setColor (getForeground());
                paint (dbg);

                g.drawImage (dbImage, 0, 0, this);
        }

        public void paint (Graphics g)
        {
                // draw player
                player.drawPlayer(g);
                stars.drawStars(g);
                
                // draw shots
                for(int i=0; i<shots.length; i++)
                {
                        if(shots[i] != null)
                        {
                                shots[i].drawShot(g);
                        }
                }
        }
}
```

Liebe Grüße
Reality


----------



## Illuvatar (12. Sep 2004)

Mein Compiler gibt 4 Fehler und 5 Warnungen aus. Die Fehler stammen aber daher, dass ich die Klassen Shot und Player nicht habe (je 2 Fehler). Ich kann das Problem also nicht ganz nachvollziehen. ???:L 

Außerdem:
Thread#stop ist deprecated
Component#keyUp ist deprecated
Component#keyDown ist deprecated
Serializable Class Main has no definition of serialVersionUID.


----------



## Reality (12. Sep 2004)

Hi,
ich weiss, dass die von dir genannten Methoden deprecated sind, aber ich hatte keine Lust nach dem copy und paste die Methoden umzuschreiben. Es erfüllt schließlich seinen Zweck.
Das du es kompilieren wolltest, wusste ich nicht.
Hier der restliche Code:


```
import java.awt.Graphics;
import java.awt.Color;

public class Shot
{
	private int x_pos;
	private int y_pos;

	private final int radius = 3;

	public Shot(int x, int y)
	{
		x_pos = x;
		y_pos = y;
	}

	public int getYPos()
	{
		return y_pos;
	}

	public void moveShot(int speed)
	{
		y_pos += speed;
	}

	public void drawShot(Graphics g)
	{
		g.setColor(Color.yellow);
		g.fillOval(x_pos, y_pos, radius, radius);
	}
}
```


```
import java.awt.Graphics;
import java.awt.Color;

public class Player
{
	// Variables
	private int x_pos;
	private int y_pos;

	public Player(int x, int y)
	{
		x_pos = x;
		y_pos = y;
	}

	public void moveX(int speed)
	{
		x_pos += speed;
	}

	public Shot generateShot()
	{
		Shot shot = new Shot(x_pos, y_pos);

		return shot;
	}

	public void drawPlayer(Graphics g)
	{
		g.setColor(Color.red);
		int [] x_poly = {x_pos, x_pos - 10, x_pos, x_pos + 10};
		int [] y_poly = {y_pos, y_pos + 15, y_pos + 10, y_pos + 15};
		g.fillPolygon(x_poly, y_poly, 4);
	}
}
```

Liebe Grüße
Reality


----------



## Illuvatar (12. Sep 2004)

Also kompilieren tuts bei mir bestens (JDK5 RC).
Es gibt nur einen Laufzeitfehler, der allerdings auch genau dadurch verursacht wird.


> ```
> int posX[] = new int[130];
> int posY[] = new int[130];
> 
> ...


Wem fällt was auf? Byte i wird bis 130 gezählt, das gibt nen Überlauf, das gibt ne ArrayIndexOutOfBoundsException (-128).
Verändert man byte in beiden Schleifen in short/int/long, lässt sich das Programm bei mir problemlos starten und ich kann gelbe Kügelchen verschießen.


----------



## Reality (12. Sep 2004)

Oh man! :x Dass mir so ein Furz nicht auffält!
Danke!


----------



## P3AC3MAK3R (13. Sep 2004)

Verschoben: Java-Applets


----------

