NullPointerException bei Laden von Bilddatei

[Julupus]

Hallo zusammen,

ich versuche mit derzeit an Hand des Buches "Java will nur spielen" ein bisschen in Java einzuarbeiten. Abgesehen davon dass mir vor lauter Klassen und dazugehörigen Methoden (wie soll man das jemals alles wissen?) ganz schön der Kopf raucht habe ich ein Problem beim Darstellen einer Bilddatei. Um genau zu sein nicht einer Bilddatei - sondern jeglicher Bilddatei. Dabei geht es mir nicht ums Zeichnen, das funktioniert, sondern um wirkliche Bilddateien aus dem Dateisystem.

Ich verwende Linux (openSUSE 12.1 (x86_64)) und folgende java Version:

java version "1.6.0_24"
OpenJDK Runtime Environment (IcedTea6 1.11.1) (suse-3.1-x86_64)
OpenJDK 64-Bit Server VM (build 20.0-b12, mixed mode)

Der Fehler den ich beim beim Ausführen von PaintableImage erhalte ist folgender:

-1
Uncaught error fetching image:
java.lang.NullPointerException
        at sun.awt.image.URLImageSource.getConnection(URLImageSource.java:115)
        at sun.awt.image.URLImageSource.getDecoder(URLImageSource.java:125)
        at sun.awt.image.InputStreamImageSource.doFetch(InputStreamImageSource.java:258)
        at sun.awt.image.ImageFetcher.fetchloop(ImageFetcher.java:189)
        at sun.awt.image.ImageFetcher.run(ImageFetcher.java:153)

Im Buch geht es anschließend damit weiter, dass der verwendet Weg nicht optimal ist, da unter Umständen das Bild noch nicht ganz geladen ist wenn die Größe abgefragt wird und deshalb als Größe -1 zurückgeliefert wird (was ja bei mir durchaus auch der Fall ist). Nach meinem Verständnis müsste das Bild aber trotzdem dargestellt werden. Bei mir öffnet sich jedoch ausschließlich ein leeres Fenster und aus der Konsole kommt wie gesagt oben gezeigte Exception.

Ich habe den Code jetzt wirklich gefühlte hundertmal durchgesehen und mit den Beispielen und dem Quellcode aus dem Buch abgeglichen, aber mir sind weder Fehler noch Unterschiede aufgefallen und so langsam gehen mir auch die Ideen aus (untertrieben gesagt).

Erfahrungsgemäß sieht jemand mit Ahnung immer relativ schnell woran es hakt, wenn mir also jemand einen Hinweis geben kann woran es liegt wäre ich wirklich dankbar. Die einzelnen Klassen folgen. Das Bild liegt an der selben Stelle wie auch der Quellcode (*.java) und die meisten Klassendateien im Verzeichnisbaum der der Paketstruktur entspricht. Lediglich die ShowInFrame-Klasse liegt in einem anderen Paket.

Nachdem ich definitiv Einsteiger bin und der Fehler vermutlich auch in diese Kategorie fällt habe ich dieses Subforum gewählt, wenn die Frage besser ins AWT/Swing Forum passt bitte entsprechend verschieben.

Vielen Dank schon mal fürs Anschauen!

package [somePackage];
import [someOtherPackage].ShowInFrame;
import javax.swing.JPanel;

public class PaintableImage extends JPanel implements Paintable{

        MyImage mi;

        public PaintableImage(MyImage mi){this.mi=mi;}
        public PaintableImage(String name){this.mi=new MyImage(name);}

        public void paintTo(java.awt.Graphics g){
                g.drawImage(mi.get(),0,0,this);
        }

        public static void main(String [] args){
                PaintableImage pi = new PaintableImage("test.png");
                //System.out.println(pi.mi);
                System.out.println(pi.mi.get().getHeight(pi));
                ShowInFrame.show(new PaintablePanel(pi));
        }
}

package [somePackage];
import java.awt.Image;
import java.awt.Toolkit;

public class MyImage{

        private String name;
        private Image img=null;

        public MyImage(String name){this.name=name;}

        public Image get(){
                if(img==null)
                        img=Toolkit.getDefaultToolkit().createImage
                                (getClass().getClassLoader().getResource(name));
                return img;
        }
}

package [somePackage];
interface Paintable{
        void paintTo(java.awt.Graphics g);
}

package [somePackage];
import [someOtherPackage].ShowInFrame;

public class PaintablePanel extends SizedPanel{
        Paintable pa;
        public PaintablePanel(Paintable pa){this.pa=pa;}
        public void paintComponent(java.awt.Graphics g){
                pa.paintTo(g);
        }
        public static void main(String[] args){
                ShowInFrame.show(new PaintablePanel(new PaintableOval(100,50,30,50)));
                ShowInFrame.show(new PaintablePanel(new PaintableOval(10,10,130,40)));
        }
}

package [someOtherPackage];
import javax.swing.*;
public class ShowInFrame{
        public static void show(String title,JComponent c){
                JFrame f = new JFrame(title);
                f.add(c);
                f.pack();
                f.setVisible(true);
        }
        public static void show(JComponent c){show("",c);}
}

 

[Landei]

[c]public void paintTo(java.awt.Graphics g){[/c] in der ersten Datei sollte eigentlich ein [c]paint[/c] sein, oder?

In der zweiten Datei würde ich mal Fehlerbehandlung einbauen:

public Image get(){
  try {
    if(img==null)
      img=Toolkit.getDefaultToolkit().createImage
      (getClass().getClassLoader().getResource(name));
    return img;
  } catch(Exception ex) {
     ex.printStackTrace();
     return null;
  }
}

 

[Julupus]

Ich denke das paintTo stimmt so, schließlich ist das als Schnittstelle implementiert (siehe dritte Datei).

Das mit der Fehlerbehandlung habe ich ausprobiert, ändert aber nichts an der Ausgabe wenn ich die PaintableImage-Klasse Aufrufe. Oder muss ich um da ein Ergebnis bekommen die Klasse im speziellen extra aufrufen?

 

[Landei]

Nö, eigentlich nicht.

Schonmal versucht, zu debuggen? Ohne mehr Informationen bleibt es ein Ratespiel.

 

[GUI-Programmer]

Anstatt Toolkit zu verwenden, lieber gleich mit ImageIO arbeiten:

public Image get(){
    if(img==null) {
        try {
            img = ImageIO.read(getClass().getResource(name));
        } catch(Exception ex) {
            ex.printStackTrace();
        }
    }
    return img;
}

 

[L-ectron-X]

...und in Swing auch nicht paint() sondern paintComponent() überschreiben!

 

[GUI-Programmer]

...und in Swing auch nicht paint() sondern paintComponent() überschreiben!

Ähm, das macht er doch. Hat lediglich den super-Aufruf vergessen also

super.paintComponent(g);

 

[L-ectron-X]

Entschuldige. Hab das Zitat vergessen, auf das ich mich bezog:

[c]public void paintTo(java.awt.Graphics g){[/c] in der ersten Datei sollte eigentlich ein [c]paint[/c] sein, oder?

 

[Julupus]

Ähm, das macht er doch. Hat lediglich den super-Aufruf vergessen also

super.paintComponent(g);

Kannst du mir erklären warum ich das machen muss?

Ich denke du beziehst dich auf diese Klasse:

package [somePackage];
import [someOtherPackage].ShowInFrame;
 
public class PaintablePanel extends SizedPanel{
        Paintable pa;
        public PaintablePanel(Paintable pa){this.pa=pa;}
        public void paintComponent(java.awt.Graphics g){
                pa.paintTo(g);
        }
        public static void main(String[] args){
                ShowInFrame.show(new PaintablePanel(new PaintableOval(100,50,30,50)));
                ShowInFrame.show(new PaintablePanel(new PaintableOval(10,10,130,40)));
        }
}

Für mich war es bisher immer nur so, dass ich "super" dann verwende, wenn ich den Konstruktor einer übergeordneten Klasse verwenden will anstelle mir einen neuen zu schreiben. An dieser Stelle hab ich aber ja nur eine Methode paintComponent, was passiert wenn ich ein super davor setze?

 

[Volvagia]

Das ruft die erstbeste Methode der Superklassen auf. So stellst du sicher, dass z. B. der Hintergrund gezeichnet wird. Die paintComponent (vorsicht, es gibt auch eine paintComponents) sollte überschrieben werden, da die paint unter anderem paintComponent und paintBorder usw. aufruft.

 

[Julupus]

So, ich habe mich jetzt noch etliche Male durch den Code gewühlt und habs irgendwie immer noch nicht gebacken bekommen, geschweige denn das Problem verstanden.

Das mit dem super.paintComponent erschließt sich mir immer noch nicht. Ich habe ja schließlich in PaintablePanel die paintComponent Methode so implementiert, dass immer die Methode paintTo des entsprechenden Objektes aufgerufen wird. Also wird doch paintTo aus der Klasse PaintableImage aufgerufen - und das wiederum implementiert die Methode drawImage. Damit ist paintComponent immer überschrieben.

Oder bin ich da grad total auf dem Holzweg?

Wie schaut denn normalerweise ein Objekt der Klasse Image aus? Kann das in etwa so aussehen?

sun.awt.image.ToolkitImage@67d225a7

Das ist die Ausgabe der get-Methode aus der Klasse MyImage (siehe weiter oben). Heißt das, dass das Bild erfolgreich geladen wurde? Sprich ist das die URL die Java zu dem Bild findet?

Entschuldigt, dass ich nicht gleich ImageIO verwende, aber ich muss erstmal hier das Problem verstehen bevor ich woanders weitermache.

Danke schon mal.

 

[Volvagia]

Nein, das heißt jediglich, dass darin eine Instanz der Klasse ToolkitImage mit dem Hex-Hash 67d225a7 steht.

super.paintComponent deshalb, damit du den Zeichenvorgang erweiterst, nicht veränderst. Sonst wird niemals mehr der Hintergrund gezeichnet und bei Animationen hast du bald ein sehr buntes Fenster. Falls getWidth/Height -1 zurückgibt ist das Bild noch nicht geladen. Vielleicht nicht die schönste Methode es zu testen, aber funktioniert.

Allerdings blicke ich bei den Code nicht durch. Das PaintableImage(Panel) bekommt ein Bild, welches ein Image in der (unsynchronisierten) get-Methode läd. PaintablePanel bekommt ein PaintableImage(Panel) von der Main, und die Klasse ShowInFrame (die den Namen nach lieber eine Methode werden wollte) zeigt das Fenster an.

Sei mir bitte nicht böse, aber das wirkt wie ein heilloses Durcheinander.
Wie wäre es damit?

package org.javaforum.julupus;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.io.IOException;
import java.io.InputStream;
import java.util.LinkedList;
import java.util.List;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class PaintDemo {
	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				try {
					buildGui();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		});
	}
	private static void buildGui() throws IOException {
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		PaintPanel panel = new PaintPanel();
		frame.setContentPane(panel);
		
		PaintableObject obj = new PaintableObject();
		obj.setX(50);
		obj.setY(50);
		obj.loadImageFromRessources("demoimg.png");
		panel.addPaintable(obj);
		
		frame.setSize(800, 600);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
	}
	
	private static class PaintPanel extends JPanel {
		private List<Paintable> paintables;
		
		public PaintPanel() {
			paintables = new LinkedList<PaintDemo.Paintable>();
		}		
		protected void paintComponent(Graphics g) {
			super.paintComponent(g);
			
			if(!(g instanceof Graphics2D)) {
				throw new IllegalStateException("g isn't a Graphics2D. O.o");
			}
			
			Graphics2D g2d = (Graphics2D) g;
			
			synchronized(paintables) {
				for(Paintable p:paintables) {
					p.paint(g2d);
				}
			}
		}
		public void addPaintable(Paintable paintable) {
			synchronized(paintables) {
				paintables.add(paintable);
			}
		}
	}
	public static interface Paintable {
		public void paint(Graphics2D g);
	}
	public static class PaintableObject implements Paintable {
		private int x;
		private int y;
		
		private Image image;
				
		public void paint(Graphics2D g) {
			if(image == null) {
				return;
			}
			g.drawImage(image, x, y, null);
		}
		public void setX(int x) {
			this.x = x;
		}
		public void setY(int y) {
			this.y = y;
		}
		public void loadImageFromRessources(String ressourcePath) throws IOException {
			InputStream is = getClass().getResourceAsStream(ressourcePath);
			image = ImageIO.read(is);
		}
		public void setImage(Image image) {
			this.image = image;
		}
	}
}

Bild muss sich im selben Verzeichnis wie die class-Dateien befinden. Geladen wird symetrisch, du brauchst also keinen MediaTracker o. ä.

 

[GUI-Programmer]

Ja, die Ausgabe sieht wie eine ganz normale aus. Allerdings gibt diese Ausgabe auch keine wichtigen Informationen über das aus. Denn bei der Verwendung von [JAPI]Toolkit[/JAPI] müsstest du anschließend selbst noch dafür sorgen, dass das Bild auch vollständig geladen wird, z.B. per [JAPI]MediaTracker[/JAPI]. Doch diese Vorgehensweise ist nunmal veraltet. Seit jdk 1.4 gibt es [JAPI]ImageIO[/JAPI], dass dies alles für dich erledigt, siehe meinen obigen Post.
Hier mal noch ein Link, der das gleiche Problem behandelt und erklärt.: http://www.java-forum.org/awt-swing-swt/135612-resize-label-bleibt-erst-schwarz.html

Zur paintComponent:
Volvagia hat eigentlich schon alles gesagt:

Das ruft die erstbeste Methode der Superklassen auf. So stellst du sicher, dass z. B. der Hintergrund gezeichnet wird. Die paintComponent (vorsicht, es gibt auch eine paintComponents) sollte überschrieben werden, da die paint unter anderem paintComponent und paintBorder usw. aufruft.

Also in jeder Klasse, die von [JAPI]JComponent[/JAPI] erbt, also auch wenn sie von [JAPI]JPanel[/JAPI] (oder von einer Klasse, die selbst von JPanel erbt) ervt, in der du die paintComponent() zum Zweck des Zeichnen überschreiben willst, dann ruf als allererstes die Methode der geerbten Klasse auf, die super.Methode, also in diesem Fall

super.paintComponent(g)

. Wobei g hier das Graphics Object von der Methode selbst ist.

 

[Julupus]

Volvagia, dein Beispiel funktioniert einwandfrei. Vielen Dank dafür.

Dann werde ich das Ganze mal "abhaken" und versuchen mit ImageIO & Co. weiterzukommen. Danke euch beiden!

 

[Julupus]

Ich konnte es nun doch nicht lassen, bin nochmal alles durch, hab ein bisschen ausprobiert und das Problem gefunden:

getClass().getClassLoader().getResource(fileName) hat in meinem Code immer "null" zurückgeliefert.

Das holen der Resource geht also anders:

Entweder so (fileName sei ein String mit Dateinamen):

getClassLoader().getResource("org/javaforum/julupus/"+fileName);

oder alternativ (und anscheinend besser, da nicht auf das Package verwiesen wird):

getClass().getResource(fileName);

Gelesen hier: Got resources? - JavaWorld

 

[Volvagia]

Ich glaube, dein erstes Beispiel müsste mit einen Slash beginnen, sonst wird vom relativen Pfad ausgegangen. Kann mich aber auch irren.
Nur was hat sich jetzt geändert?

getClassLoader().getResource("org/javaforum/julupus/"+fileName);
getClass().getResource(fileName);

img=Toolkit.getDefaultToolkit().createImage(getClass().getClassLoader().getResource(name));

 

[Julupus]

Das erste Beispiel funktioniert so, wenn das Bild im Classpath unter der Klasse org.javaforum.julupus liegt. Im Dateisystem also $CLASSPATH/org/javaforum/julupus.

Geändert hat sich, dass ich also entweder zwischendrin den getClassLoader() rauslassen muss (dann findet er das Bild auch so), oder eben mit getClassLoader() dann auch den entsprechenden Pfad/das entsprechende Package mit angeben muss (sonst sucht der wohl nur direkt in $CLASSPATH)