# NullPointerException



## r00t (23. Apr 2011)

Nabend und frohe Ostern!
Ich habe ein Programm zur Simulation der Drehspiegelmethode in Python 3.1 geschrieben, aufgrund massiver Performance-Probleme habe ich mich an die "Übersetzung" in Java gemacht. Allerdings bin ich Java-Anfänger und scheitere im Moment an folgendem Problem:

Neben der Applet-Klasse habe ich eine Klasse zum Zeichnen einer gedrehten Ellipse geschrieben. Beim Compilieren erscheint folgende Fehlermeldung:

```
Exception in thread "AWT-EventQueue-1" java.lang.NullPointerException
	at applet.Ellipse.draw(Ellipse.java:69)
	at applet.DSPS.paint(DSPS.java:37)
	at sun.awt.RepaintArea.paintComponent(Unknown Source)
	at sun.awt.RepaintArea.paint(Unknown Source)
	at sun.awt.windows.WComponentPeer.handleEvent(Unknown Source)
	at java.awt.Component.dispatchEventImpl(Unknown Source)
	at java.awt.Container.dispatchEventImpl(Unknown Source)
	at java.awt.Component.dispatchEvent(Unknown Source)
	at java.awt.EventQueue.dispatchEventImpl(Unknown Source)
	at java.awt.EventQueue.access$000(Unknown Source)
	at java.awt.EventQueue$1.run(Unknown Source)
	at java.awt.EventQueue$1.run(Unknown Source)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.security.AccessControlContext$1.doIntersectionPrivilege(Unknown Source)
	at java.security.AccessControlContext$1.doIntersectionPrivilege(Unknown Source)
	at java.awt.EventQueue$2.run(Unknown Source)
	at java.awt.EventQueue$2.run(Unknown Source)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.security.AccessControlContext$1.doIntersectionPrivilege(Unknown Source)
	at java.awt.EventQueue.dispatchEvent(Unknown Source)
	at java.awt.EventDispatchThread.pumpOneEventForFilters(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForFilter(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForHierarchy(Unknown Source)
	at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
	at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
	at java.awt.EventDispatchThread.run(Unknown Source)
```

Der Source-Code:

```
package applet;

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

public class DSPS extends Applet {

    Ellipse ellipse;
    Image buffer;
    Graphics gBuffer;

    public void init() {
        setBackground(new Color(255,255,255));
        ellipse = new Ellipse(72, 18, -100, 100, Math.PI, 100, this.gBuffer);        
    }
    
/*
    public boolean keyDown(Event ev, int key) {
        // Alles zurücksetzen
        if (key==Event.F12) {/*
            ...
            buffer = null;
            repaint();
        }
        return true;
    }*/

    public void paint (Graphics g) {
        if (buffer!=null) {
            g.drawImage (buffer, 0, 0, this);
            return;
        }
        buffer = createImage(this.getSize().width, this.getSize().height);
        gBuffer = buffer.getGraphics();
        ellipse.draw();
        g.drawImage(buffer, 0,0,this);
        repaint();
    }
}
```

und die Klasse Ellipse:

```
package applet;

import java.awt.Graphics;

public class Ellipse{
	public int h_width;
	public int h_height;
	public int x_shift;
	public int y_shift;
	public double angle;
	public int iterations;
	public Graphics reference;
	public double[][] matrix;
	public double[][] manipulated_matrix;
	
	public Ellipse(int px_Size, int py_Size, int px_shift, int py_shift,
			double pangle, int piterations, Graphics pBuffer)
	{
		h_width = px_Size;
		h_height = py_Size;
		x_shift = px_shift;
		y_shift = py_shift;
		angle = pangle;
		iterations = piterations;
		reference = pBuffer;
		matrix = new double[iterations * 2][2];
		double current_x, current_y;
		for (double x = 0; x < iterations; x++)
		{
			current_x = x * ((2 * h_width) / iterations ) - h_width;
			current_y = calculate(current_x);
			matrix[(int) (x * 2)    ][0] = current_x;
			matrix[(int) (x * 2)    ][1] = current_y;
			matrix[(int) (x * 2 + 1)][0] = current_x;
			matrix[(int) (x * 2 + 1)][1] = - current_y;
		}
		manipulated_matrix = new double[iterations * 2][2];
		double[] coordinates = new double[2];
		double[] manipulated_coordinates = new double[2];
		for (int cnt = 0; cnt < iterations * 2; cnt++)
		{
			coordinates = matrix[cnt];
			manipulated_coordinates = turn(coordinates, angle);
			manipulated_coordinates[0] += x_shift;
			manipulated_coordinates[1] += y_shift;
			manipulated_matrix[cnt] = manipulated_coordinates;
		}
	}
	private double calculate(double p_x)
	{
		return (h_height * Math.sqrt( (1 - ((p_x * p_x) / (h_width * h_width)))));
	}
	private double[] turn(double[] coordinates, double phi)
	{
		double x_old, y_old, x_new, y_new;
		double[] ret_M = new double[2];
		x_old = coordinates[0];
		y_old = coordinates[1];
		x_new = x_old * Math.cos( -phi ) - y_old * Math.sin( -phi );
		y_new = y_old * Math.cos( -phi ) + x_old * Math.sin( -phi );
		ret_M[0] = x_new;
		ret_M[1] = y_new;
		return ret_M;
	}
	public void draw()
	{
		for (int cnt = 0; cnt < iterations * 2; cnt++)
		{
			this.reference.drawLine((int)manipulated_matrix[cnt][0] + 400, //Zeile 69!!!
					(int)manipulated_matrix[cnt][1] + 300,
					(int)manipulated_matrix[cnt][0] + 400,
					(int)manipulated_matrix[cnt][1] + 300);
		}
	}
}
```

Das Grundgerüst des Applets habe ich einem Beispiel aus dem Net übernommen: Das fraktale Apfelmnnchen als Java-Applet mit Zoom-Funktion
Vor meiner "Modifikation" war es noch lauffähig...^^

Danke im Voraus!


----------



## Volvagia (23. Apr 2011)

Warum bereiten NPE eigendlich immer solche Probleme? Das sind wohl die simpelsten Exceptions überhaupt.
Geh mal sicher, dass der Ellipse beim erzeugen eine Graphics übergeben wird.


----------



## r00t (23. Apr 2011)

Vielen Dank, jetzt compilierts schon ma  Rest werd ich schon iwie hinkriegen. Hab mal n Programm in Python geschrieben, dass nicht das machte, was es sollte. Nach ner halben Stunde hab ich endlich gemerkt, dass in einer Variable n C klein statt groß war und so ne neue Variable erzeugt hat, anstatt den Wert der alten zu ändern^^ Gerade die simpelste Logik hats beim Menschen in sich


----------



## L-ectron-X (23. Apr 2011)

Deine paint()-Methode in deinem Applet wird dir in dieser Form mächtig Probleme bereiten.
Ich rate dir dazu, auf JApplet umzusteigen und nicht mehr die paint()-Methode zu überschreiben.
Statt dessen auf einem JPanel zeichnen. Dazu von JPanel erben und die paintComponent()-Methode überschreiben. Dieses Panel baust du dann als Inhaltselement in dein Applet ein.
Vorteil: Du brauchst dich nicht mehr mir dem DoubleBuffer-Zeugs rumquälen, das ist da alles schon eingebaut. Außerdem kannst du das Panel auch in einen JFrame einbauen.


----------



## r00t (23. Apr 2011)

Danke für den Tipp! Werd mich gleich mal reinarbeiten   Sry dass ich erst jetzt antworte, hab vergessen hier noch ma reinzuschauen.
Eine Frage noch:
Kann man bspw. eine Linie zeichnen und in einer Variable speichern, sodass man sie später wieder durch [variable].delete() o.ä. löschen kann?


----------



## Volvagia (23. Apr 2011)

Jein.
Du kannst eine Klasse "Line" anlegen, die das Interface "Paintable" implementieren. Dieses könnte z. B. die Methode paint(Graphics) besitzen.
Die Instanzen speicherst du an der Zeichenfläche in eine Collection.
In der eigendlichen paint(Component) rennst du die Collection durch und zeichnest dort alles. Wenn du es entfernen willst, löscht du sie einfach aus der Col. und rufst repaint auf. Dadurch wird auf ein neues Bild gezeichnet.


----------



## r00t (23. Apr 2011)

Hört sich kompliziert an, wenn ichs mir so überleg ist es glaub ich bei meiner Simulation einfacher, vor jeder neuen Frame das Bild zu plätten. Dürfte in meinem Fall sogar für mehr Performance sorgen  Danke für die Antworten und die Hilfe!


----------



## Volvagia (23. Apr 2011)

Ist garnicht kompliziert, vielleicht habe ich es schlecht erklärt.


```
import java.awt.Graphics;
import java.util.LinkedList;
import java.util.List;

import javax.swing.JPanel;

public class DrawArea extends JPanel
{
	private static final long serialVersionUID = 1L;

	private List<Paintable> paintableList;
	
	public DrawArea()
	{
		super();
		paintableList = new LinkedList<Paintable>();
	}
	public void addPaintable(Paintable paintable)
	{
		addPaintable(paintable, true);
	}
	public void addPaintable(Paintable paintable, boolean repaint)
	{
		synchronized (paintableList)
		{
			paintableList.add(paintable);
		}
		if(repaint)
			repaint();
	}
	public boolean removePaintable(Paintable paintable)
	{
		synchronized (paintableList)
		{
			return(paintableList.remove(paintable));
		}
	}
	public Paintable addPaintable(int index)
	{
		synchronized (paintableList)
		{
			return(paintableList.remove(index));
		}
	}
	protected void paintComponent(Graphics g)
	{
		super.paintComponent(g);
		
		synchronized (paintableList)
		{
			for(Paintable p:paintableList)
				p.paint(g);
		}
	}
}
```


```
import java.awt.Graphics;
import java.awt.Point;

public class Line implements Paintable
{
	private Point startPoint; 
	private Point endPoint;
	
	public Line()
	{
		this(0, 0, 0, 0);
	}
	public Line(int x0, int y0, int x1, int y2)
	{
		this(new Point(x0, y0), new Point(x1, y2));
	}
	public Line(Point p1, Point p2)
	{
		super();
		
		startPoint = p1;
		endPoint = p2;
	}
	public void setStartPoint(int x, int y)
	{
		startPoint.x = x;
		startPoint.x = y;
	}
	public void setStartPoint(Point startPoint)
	{
		this.startPoint = startPoint;
	}
	public void setEndPoint(int x, int y)
	{
		endPoint.x = x;
		endPoint.x = y;
	}
	public void setEndPoint(Point endPoint)
	{
		this.endPoint = endPoint;
	}
	public void setBounds(int x0, int y0, int x1, int y1)
	{
		startPoint.x = x0;
		startPoint.y = y0;
		
		endPoint.x = x1;
		endPoint.y = y1;
	}
	public void setBounds(Point startPoint, Point endPoint)
	{
		this.startPoint = startPoint;
		this.endPoint = endPoint;
	}
	
	public Point getStartPoint()
	{
		return startPoint;
	}
	public Point getEndPoint()
	{
		return endPoint;
	}
	
	public void paint(Graphics g)
	{
		if(startPoint != null && endPoint != null)
			g.drawLine(startPoint.x, startPoint.y, endPoint.x, endPoint.y);
	}
}
```


```
import java.awt.Graphics;

public interface Paintable
{
	public void paint(Graphics g);
}
```

(Ungetestet, aber ich denke es sollte gehen.)


----------



## r00t (23. Apr 2011)

omg nochmals vielen Dank! ich werds versuchen einzubauen, im Moment hänge ich aber noch beim Override fest:

Die Klasse zum "Bauen":

```
package applet;

import applet.Ellipse;
//import applet.Drehspiegel; kommt noch
import applet.Simulator;

import java.awt.*;
import javax.swing.*;

public class ROOT extends JApplet{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	public Simulator simulator;
	public Graphics g;
	
	public void init()
	{
		setBackground(Color.white);
		JPanel root = new JPanel();
		simulator = new Simulator();
		root.add(simulator);
		simulator.repaint();
	}
}
```

Die Steuerklasse:

```
package applet;

import java.awt.*;
import javax.swing.JPanel;

public class Simulator extends JPanel{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	public Ellipse linse;
	
	public Simulator()
	{
		linse = new Ellipse(72, 18, -100, -100, Math.PI/4, 5000);
	}
	@Override public void paintComponent(Graphics g)
	{
		super.paintComponent(g);
		g.setColor(Color.black);
		linse.draw(g);
	}
}
```

und die überarbeitete Ellipsen-Klasse:

```
package applet;

import java.awt.Graphics;

public class Ellipse{
	public double h_width;
	public double h_height;
	public double x_shift;
	public double y_shift;
	public double angle;
	public int iterations;
	public double[][] matrix;
	public double[][] manipulated_matrix;
	
	public Ellipse(double px_Size, double py_Size, double px_shift, double py_shift,
			double pangle, int piterations)
	{
		h_width = px_Size;
		h_height = py_Size;
		x_shift = px_shift;
		y_shift = py_shift;
		angle = pangle;
		iterations = piterations;
		matrix = new double[iterations * 2][2];
		double current_x, current_y;
		for (double x = 0; x < iterations; x++)
		{
			current_x = x * ((2 * h_width) / iterations ) - h_width;
			current_y = calculate(current_x);
			matrix[(int) (x * 2)    ][0] = current_x;
			matrix[(int) (x * 2)    ][1] = current_y;
			matrix[(int) (x * 2 + 1)][0] = current_x;
			matrix[(int) (x * 2 + 1)][1] = - current_y;
		}
		manipulated_matrix = new double[iterations * 2][2];
		double[] coordinates = new double[2];
		double[] manipulated_coordinates = new double[2];
		for (int cnt = 0; cnt < iterations * 2; cnt++)
		{
			coordinates = matrix[cnt];
			manipulated_coordinates = turn(coordinates, angle);
			manipulated_coordinates[0] += x_shift;
			manipulated_coordinates[1] += y_shift;
			manipulated_matrix[cnt] = manipulated_coordinates;
		}
	}
	private double calculate(double p_x)
	{
		return (h_height * Math.sqrt( (1 - ((p_x * p_x) / (h_width * h_width)))));
	}
	private double[] turn(double[] coordinates, double phi)
	{
		double x_old, y_old, x_new, y_new;
		double[] ret_M = new double[2];
		x_old = coordinates[0];
		y_old = coordinates[1];
		x_new = x_old * Math.cos( -phi ) - y_old * Math.sin( -phi );
		y_new = y_old * Math.cos( -phi ) + x_old * Math.sin( -phi );
		ret_M[0] = x_new;
		ret_M[1] = y_new;
		return ret_M;
	}
	public void draw(Graphics g)
	{
		for (int cnt = 0; cnt < iterations * 2; cnt++)
		{
			g.drawLine
			(
					(int)Math.round(manipulated_matrix[cnt][0] + 400),
					(int)Math.round(manipulated_matrix[cnt][1] + 300),
					(int)Math.round(manipulated_matrix[cnt][0] + 400),
					(int)Math.round(manipulated_matrix[cnt][1] + 300)
			);
		}
	}
}
```

Das Ganze kompiliert, aber die Ellipse wird nicht mehr angezeigt. Hättest du ne Idee worans liegen könnte? Wird die paintCom.. ignoriert und stattdessen die nicht vorhandene paint()-Methode bei repaint() aufgerufen?

edit: die Maße des Applets sollten vorher noch auf 800x600 gesetzt werden, vorher sah der Hintergrund auch weißer aus^^ Weißt du, wie das bei JApplet geht?


----------



## Volvagia (23. Apr 2011)

root zum Applet zu adden wäre keine schlechte Idee.
Die Hintergrundänderung musst du direkt aufs ContentPane per "getContentPane().setBackground(Color.WHITE);" setzen.
Keine Ahnung warum, vielleicht hat Sun/Oracle einfach drauf vergessen.


----------



## r00t (23. Apr 2011)

Danke, der Hintergrund ist jetzt weiß! Die Ellipse wird komischerweise immer noch nicht gezeichnet, habs zur Konrolle nochmal mit nem Rechteck versucht.
Die ROOT-Klasse sieht nun wie folgt aus:

```
package applet;

import applet.Simulator;

import java.awt.*;
import javax.swing.*;

public class ROOT extends JApplet{
	private static final long serialVersionUID = 1L;
	
	public Simulator simulator;
	public Graphics g;
	public JPanel root;
	
	public void init()
	{
		JPanel root = new JPanel();
		simulator = new Simulator();
		root.add(simulator);
		getContentPane().setBackground(Color.WHITE);
		simulator.repaint();
	}
}
```


----------



## Volvagia (23. Apr 2011)

Hast wohl die erste Zeile überlesen. root muss auch zum Applet hinzugefügt werden.


```
public void init()
{
	JPanel root = new JPanel(new CardLayout());
	root.setOpaque(false); //Nicht undurchsichtig. Im deutschen irgendwie eine blöde Methode. xD
	add(root);
    
	simulator = new Simulator();
	simulator.setOpaque(false);
	root.add(simulator, "Sim"); //Cardlayout streckt das darauf liegende Panel über den ganzen Bereich, benötigt aber einen String als Parameter.
    
	getContentPane().setBackground(Color.WHITE);
  	
	simulator.repaint();
}
```

"root" könntest du dir aber natürlich auch spaaren und Simulator direkt am Applet adden.


----------



## r00t (23. Apr 2011)

Nochmals vielen, vielen Dank!!!!!!! Ich hab deine erste Zeile nicht überlesen  aber falsch verstanden und root zu den Klassenattributen hinzugefügt xD, das zeigt aber wie lückenhaft mein Wissen um Java ist. Ich kann dir gar nicht genug für deine Hilfe danken!


----------



## Volvagia (24. Apr 2011)

Jetzt könntest du ja so umbauen, wie ich vorgeschlagen habe, damit du einfach neue Formen hinzufügen/entfernen kannst.


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

import javax.swing.*;
 
public class ROOT extends JApplet
{
	private static final long serialVersionUID = 1L;
    
	public void init()
	{
		setLayout(new CardLayout());
		
		final DrawArea area = new DrawArea();
		area.setOpaque(false);
		add(area, "Area");
		
		area.addPaintable(new Ellipse(72, 18, -100, -100, Math.PI/4, 5000));
		area.addPaintable(new Line(10, 10, 10, 50));
		
		final Line line = new Line(20, 20, 20, 50);
		area.addPaintable(line);
	    
		getContentPane().setBackground(Color.WHITE);
		
		new Thread() {
			public void run() {
				try
				{
					TimeUnit.SECONDS.sleep(2L);
				}
				catch (InterruptedException e)
				{
					e.printStackTrace();
				}
				area.removePaintable(line, true); //Nach 2 Sekunden verschwindet die 2. Linie, und es wird neu gezeichnet.
			};
		}.start();
	}
}
```


```
import java.awt.Graphics;
import java.util.LinkedList;
import java.util.List;

import javax.swing.JPanel;
 
public class DrawArea extends JPanel
{
    private static final long serialVersionUID = 1L;
 
    private List<Paintable> paintableList;
    
    public DrawArea()
    {
        super();
        paintableList = new LinkedList<Paintable>();
    }
    public void addPaintable(Paintable paintable)
    {
        addPaintable(paintable, true);
    }
    public void addPaintable(Paintable paintable, boolean repaint)
    {
        synchronized (paintableList)
        {
            paintableList.add(paintable);
        }
        if(repaint)
            repaint(paintable.getUsedBounds());
    }
    public boolean removePaintable(Paintable paintable, boolean repaint)
    {
        synchronized (paintableList)
        {
        	boolean b = paintableList.remove(paintable);
        	if(repaint)
            	repaint(paintable.getUsedBounds());
            return(b);
        }
    }
    public Paintable addPaintable(int index)
    {
        synchronized (paintableList)
        {
            return(paintableList.remove(index));
        }
    }
    protected void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        
        synchronized (paintableList)
        {
            for(Paintable p:paintableList)
                p.paint(g);
        }
    }
}
```


```
import java.awt.Graphics;
import java.awt.Rectangle;

public class Ellipse implements Paintable
{
    public double h_width;
    public double h_height;
    public double x_shift;
    public double y_shift;
    public double angle;
    public int iterations;
    public double[][] matrix;
    public double[][] manipulated_matrix;
    
    public Ellipse(double px_Size, double py_Size, double px_shift, double py_shift,
            double pangle, int piterations)
    {
        h_width = px_Size;
        h_height = py_Size;
        x_shift = px_shift;
        y_shift = py_shift;
        angle = pangle;
        iterations = piterations;
        matrix = new double[iterations * 2][2];
        double current_x, current_y;
        for (double x = 0; x < iterations; x++)
        {
            current_x = x * ((2 * h_width) / iterations ) - h_width;
            current_y = calculate(current_x);
            matrix[(int) (x * 2)    ][0] = current_x;
            matrix[(int) (x * 2)    ][1] = current_y;
            matrix[(int) (x * 2 + 1)][0] = current_x;
            matrix[(int) (x * 2 + 1)][1] = - current_y;
        }
        manipulated_matrix = new double[iterations * 2][2];
        double[] coordinates = new double[2];
        double[] manipulated_coordinates = new double[2];
        for (int cnt = 0; cnt < iterations * 2; cnt++)
        {
            coordinates = matrix[cnt];
            manipulated_coordinates = turn(coordinates, angle);
            manipulated_coordinates[0] += x_shift;
            manipulated_coordinates[1] += y_shift;
            manipulated_matrix[cnt] = manipulated_coordinates;
        }
    }
    private double calculate(double p_x)
    {
        return (h_height * Math.sqrt( (1 - ((p_x * p_x) / (h_width * h_width)))));
    }
    private double[] turn(double[] coordinates, double phi)
    {
        double x_old, y_old, x_new, y_new;
        double[] ret_M = new double[2];
        x_old = coordinates[0];
        y_old = coordinates[1];
        x_new = x_old * Math.cos( -phi ) - y_old * Math.sin( -phi );
        y_new = y_old * Math.cos( -phi ) + x_old * Math.sin( -phi );
        ret_M[0] = x_new;
        ret_M[1] = y_new;
        return ret_M;
    }
    public void paint(Graphics g)
    {
        for (int cnt = 0; cnt < iterations * 2; cnt++)
        {
            g.drawLine
            (
                    (int)Math.round(manipulated_matrix[cnt][0] + 400),
                    (int)Math.round(manipulated_matrix[cnt][1] + 300),
                    (int)Math.round(manipulated_matrix[cnt][0] + 400),
                    (int)Math.round(manipulated_matrix[cnt][1] + 300)
            );
        }
    }
	public Rectangle getUsedBounds()
	{
		return(new Rectangle(0, 0, Integer.MAX_VALUE, Integer.MAX_VALUE)); //Mathe ist keine meine besonderen Stärken. :( 
	}
}
```


```
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Rectangle;
 
public class Line implements Paintable
{
    private Point startPoint; 
    private Point endPoint;
    
    public Line()
    {
        this(0, 0, 0, 0);
    }
    public Line(int x0, int y0, int x1, int y1)
    {
        this(new Point(x0, y0), new Point(x1, y1));
    }
    public Line(Point p1, Point p2)
    {
        super();
        
        startPoint = p1;
        endPoint = p2;
    }
    public void setStartPoint(int x, int y)
    {
        startPoint.x = x;
        startPoint.x = y;
    }
    public void setStartPoint(Point startPoint)
    {
        this.startPoint = startPoint;
    }
    public void setEndPoint(int x, int y)
    {
        endPoint.x = x;
        endPoint.x = y;
    }
    public void setEndPoint(Point endPoint)
    {
        this.endPoint = endPoint;
    }
    public void setBounds(int x0, int y0, int x1, int y1)
    {
        startPoint.x = x0;
        startPoint.y = y0;
        
        endPoint.x = x1;
        endPoint.y = y1;
    }
    public void setBounds(Point startPoint, Point endPoint)
    {
        this.startPoint = startPoint;
        this.endPoint = endPoint;
    }
    
    public Point getStartPoint()
    {
        return startPoint;
    }
    public Point getEndPoint()
    {
        return endPoint;
    }
    
    public void paint(Graphics g)
    {
        if(startPoint != null && endPoint != null)
            g.drawLine(startPoint.x, startPoint.y, endPoint.x, endPoint.y);
    }
	public Rectangle getUsedBounds()
	{
		int width = (endPoint.x - startPoint.x) + 1;
		int height = (endPoint.y - startPoint.y) + 1;
		
		return(new Rectangle(startPoint.x, startPoint.y, width,
				height));
	}
}
```


----------



## r00t (25. Apr 2011)

Tausend Dank nochmal! Hab jetzt schon wieder ein Problem: Hab das JApplet mit Eclipse in eine *.jar gepackt, aber folgende HTML-Datei failed beim Aufruf mit der "ClassNotFoundException":

```
<html>
  <body>
  <div align="center">
  <h1>Drehspiegel-Simulation</h1>
  <applet code="ROOT.class" applet="DrehspiegelSim.jar" width="1280" height="720">
  </applet>
  </div>
</body>
</html>
```
Laden: Klasse ROOT.class nicht gefunden
java.lang.ClassNotFoundException: ROOT.class
	at sun.plugin2.applet.Applet2ClassLoader.findClass(Unknown Source)
	at sun.plugin2.applet.Plugin2ClassLoader.loadClass0(Unknown Source)
	at sun.plugin2.applet.Plugin2ClassLoader.loadClass(Unknown Source)
	at sun.plugin2.applet.Plugin2ClassLoader.loadClass(Unknown Source)
	at java.lang.ClassLoader.loadClass(Unknown Source)
	at sun.plugin2.applet.Plugin2ClassLoader.loadCode(Unknown Source)
	at sun.plugin2.applet.Plugin2Manager.createApplet(Unknown Source)
	at sun.plugin2.applet.Plugin2Manager$AppletExecutionRunnable.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)
Ausnahme: java.lang.ClassNotFoundException: ROOT.class

Hab schon ein paar Variationen durchprobiert mit ähnlichen Ergebnissen, in Eclipse läuft es immer rund.
Wüsstest du worans liegt?


----------



## Volvagia (25. Apr 2011)

Mit Applets streite ich mich auch dauernd.
Ein Beispiel von mir:


```
<applet code="kai.applet.GameApplet.class" archive="inlogged/game.jar" width="640" height="496">
	<PARAM name="session" value="<?php echo $_SESSION['gamesession']; ?>">
</applet>
```

Wichtig, diese Datei und das Archiv liegen beide unter htdocs/inlogged, d. h. Pfadangaben sind immer vom HTTP-Ausgangspunkt (bei Apache im default htdocs) aus.

Ich weiß aber nicht, ob es ohne Package überhaupt funktioniert, das sollte man auch niemals tun.


----------



## r00t (25. Apr 2011)

Danke für die schnelle Antwort! Mit

```
<applet code="applet.ROOT.class" archive="DrehspiegelSim.jar" width="1280" height="720">
  </applet>
```
läufts!


----------

