JFrame zeigt Hintergrund und nicht den Inhalt

[Freak]

Hi. Hab ein Problem mit JAVA und zwar immer wenn ich ein Programm ausführen will das ein Frame benötigt wird der Hintergrund duchsichtig und ich seh die Entwicklungsumgebung. Am Anfang hat es eh noch richtig funktioniert, aber jetzt ist eben dieses Problem aufgetreten. Weiss jemand was ich tun soll?

 

[Quaxli]

Ja, führe das Programm nie an Tagen mit ungerader Stundenzahl aus und stelle sicher, daß Du keine Java-Version mit linksdrehenden class-Files hast.

Wenn das nicht hilft, poste ein Beispielprogramm und schreibe uns, welches Entwicklungsumgebung Du verwendest. Das ist aber eher so die allerletzte Notlösung.

 

[André Uhres]

Lass dich nicht von Quaxli ins Boxhorn jagen!
Du blockierst wahrscheinlich den EDT (Event Dispatch Thread).
Das Problem könnte man etwa so simulieren:

   public static void main(final String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new PinDemo().setVisible(true);
                try {
                    Thread.sleep(900000);
                } catch (InterruptedException ex) {
                }
            }
        });
    }

wobei PinDemo der JFrame wäre.

 

[Freak]

Danke. Ich werde es probieren. Geht es auch eigentlich auch ohne dem, weil sonst muss ich das ja zu jedem Programm dazuschreiben.

 

[thE_29]

Es wäre nett wenn du mal dein Programm posten würdest um den Fehler besser zu analysieren

 

[Guest]

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

public class JumpingBalls extends JFrame {

	//Richtung und Position initialisieren
	private int xPos = 1;
	private int yPos = 1;
	private int xRicht = 3;
	private int yRicht = 1;

	//JFrame erzeugen
	public JumpingBalls(){
		setSize(800, 600);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setVisible(true);

		//Timer erzeugen
		Timer timer = new Timer (100,
				new ActionListener(){
			public void actionPerformed (ActionEvent e){
			}
		}
		);
		timer.start();
	}

	//Ball zeichnen
	public void paint(Graphics g){
		g=getContentPane().getGraphics();
		g.setColor(Color.black);
		g.fillOval(0, 0, 50, 50);
	}

	//main-Methode
	public static void main(String[] args) {
		new JumpingBalls();
	} 

	//Ball bewegen
	public void move(){

		//Länge und Breite initialisieren
		int h=getContentPane().getHeight();
		int w=getContentPane().getWidth();

		Graphics g = getContentPane().getGraphics();
		g.setColor(Color.white);
		g.fillOval(xPos, yPos, 50 ,50);
		g.setColor(Color.blue);

		if(xPos>w-50 || xPos<=0){
			xRicht*=-1;
		}
		if(yPos>h-50 || yPos<=0){
			yRicht*=-1;
		}

		g.fillOval(xPos, yPos, 50, 50);
	}
}

 

[Guest]

Die Entwicklungsumgebung die ich benutze ist Eclipse.

 

[Leroy42]

...und stelle sicher, daß Du keine Java-Version mit linksdrehenden class-Files hast.

:shock: Mist aber auch!

Warum hat mir das niemand vorher gesagt? :x

 

[thE_29]

Wieso holst du dir ein neues Graphics Objekt?

 

[André Uhres]

In Swing malst du gewöhnlich nicht direkt auf den JFrame, sondern auf eine JComponent
oder auf eine von JComponent abgeleitete Komponente wie JPanel oder JLabel.
Mehr dazu: http://www.java-forum.org/de/viewtopic.php?p=408862#408862

 

[Guest]

Was soll ich jetzt genau machen? Ich meine in der Schule funktioniert mein Programm ja gut, nur halt zu hause nicht. Also am Programm kann es ja nicht liegen.

 

[Quaxli]

Also am Programm kann es ja nicht liegen.

Doch, tut es. Daß es bei Dir in der Schule zufällig funktioniert, heißt nicht, daß es richtig ist. Sieht man ja daran, daß es bei Dir zuhause nicht tut was es soll. Bei mir übrigens auch nicht.

Aber wer Code postet kriegt auch geholfen : Weiter unten Dein Programm, an dem ich mal ein bißchen rumgefrickelt habe, so daß es läuft, wenn auch nicht schön. Zu den Ursachen gleich mehr:

Änderungen:
Üblicherweise wird nur in der überschriebenen paint-Methode gezeichnet - nirgendwo sonst. Es gibt ein paar wenige Ausnahmen, aber für als Anfänger kannst Du das als eiserne Regel betrachten: getGraphics() == böse
Ich habe die Änderungen kommentiert, so daß Du nachvollziehen kannst, was ich geändert habe.

Warum es nicht schön läuft:
Du hast von JFrame geerbt. Das funktioniert prinzipiell, aber wenn Du das Programm startest, wirst Du sehen, daß der Ball einen Spur zieht. Ursache ist, daß JFrame nicht doppelgepuffert ist. Dieses müßtest Du entweder einbauen (Forumssuche: Doppelbufferung) oder aber (die bessere Lösung) lieber von JPanel erben, welches von Haus aus doppelt gepuffert ist.

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

public class JumpingBalls extends JFrame {

	private static final long	serialVersionUID	= 1L;
	
	//Richtung und Position initialisieren
   private int xPos = 1;
   private int yPos = 1;
   private int xRicht = 3;
   private int yRicht = 1;

   //JFrame erzeugen
   public JumpingBalls(){
      setSize(800, 600);
      setDefaultCloseOperation(EXIT_ON_CLOSE);
      setVisible(true);

      //Timer erzeugen
      Timer timer = new Timer (100,
            new ActionListener(){
         public void actionPerformed (ActionEvent e){
        	 move(); // --> hab' ich hier mal eingebaut
         }
      }
      );
      timer.start();
   }

   //Ball zeichnen
   public void paint(Graphics g){
      //g=getContentPane().getGraphics(); --> Graphics wird an die Methode übergeben
      g.setColor(Color.black);
      //g.fillOval(0, 0, 50, 50);
      g.fillOval(xPos,yPos,50,50);
   }

   //main-Methode
   public static void main(String[] args) {
      new JumpingBalls();
   }

   //Ball bewegen
   public void move(){

  	  System.out.println("hier");
      //Länge und Breite initialisieren
      //int h=getContentPane().getHeight(); --> weiter unten anders abgefragt
      //int w=getContentPane().getWidth();

      /*Graphics g = getContentPane().getGraphics();  --> Zeichnen nur in paint-Methode! 
      g.setColor(Color.white);
      g.fillOval(xPos, yPos, 50 ,50);
      g.setColor(Color.blue);*/   
  	 

  	  //move enthielt keine Positionsänderung
  	  xPos += 1;
  	  yPos += 1;
  	 
      //Abfrage der Grenzen hier
      if(xPos>getWidth()-50 || xPos<=0){
         xRicht*=-1;
      }
      if(yPos>getHeight()-50 || yPos<=0){
         yRicht*=-1;
      }

      //g.fillOval(xPos, yPos, 50, 50); --> dto.
      repaint(); // --> jetzt wird gemalt
   }
}

[/quote]

 

[Quaxli]

Im Folgenden nochmal ein Beispiel mit JPanel als Vaterklasse. Außerdem habe ich den Timer rausgeschmissen und an der Bewegungsberechnung rumgespielt. Ich habe das Wichtigste kommentiert. Wenn Du Fragen hast, frage.

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

//Erbt von JPanel und Implementiert Runnable um GameLoop in separatem Thread auszuführen
public class JumpingBalls extends JPanel implements Runnable {

	private static final long	serialVersionUID	= 1L;

	//Richtung und Position initialisieren
	// Positionswerte als Double wg. höherer Rechengenauigkeit 
	private double						xPos							= 50;
	private double						yPos							= 50;
	//Anpassung der Änderungen an die neue Bewegungsberechnung
	private int								xRicht						= 100;
	private int								yRicht						= 20;
	
	//neue Variablen
	JFrame										frame;
	long											last							= 0;

	public static void main(String[] args) {
		new JumpingBalls();
	}

	//JFrame erzeugen
	public JumpingBalls() {
		//Fenster erzeugen
		frame = new JFrame("Moving Ball");
		frame.setSize(800, 600);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		
		setPreferredSize(new Dimension(800, 600));
		frame.add(this); //dieses Panel in den Frame packen

		frame.setVisible(true); // frame anzeigen

		last = System.nanoTime(); //Variable für Zeitmessung initialisieren

		//Ersetzen des Timers durch eigenen Thread. Damit läuft die Spielschleife separat in der Run-Methode
		// ggf. in Threads einlesen ;-)
		Thread t = new Thread(this);
		t.start();

	}

	//Ball zeichnen - bei JPanels immer paintComponent überschreiben, statt paint
	public void paintComponent(Graphics g) {
    super.paintComponent(g); //super-Aufruf nie vergessen! Sonst wird u. U. schlecht gezeichnet
		g.setColor(Color.black);
		// da xPos und yPos jetzt double sind, zum Zeichnen nach int casten
		g.fillOval((int) xPos, (int) yPos, 50, 50);
	}

	// Spielschleife bzw. GameLopp als separater Thread
	public void run() {

		//Ausführen solange man ein Fenster sieht
		while (frame.isVisible()) {

			//Zeit messen, die für den letzten Loop benötigt wurde. Auflösung in Nano-Sekunden
			long delta = System.nanoTime() - last; 
			//akt. Zeit für nächsten Loop merken
			last = System.nanoTime();

			//Bewegungsänderung in Abhängigkeit von der benötigten Zeit. Damit ist eine flüssige Bewegung gewährleistet			
			if (xRicht != 0) {
				xPos += xRicht * (delta / 1e9);
			}

			if (yRicht != 0) {
				yPos += yRicht * (delta / 1e9);  //1e9 = 10 hoch 9
			}

			//Ränder abfragen
			if (xPos >= getWidth()-50 || xPos <= 0) {
				xRicht *= -1;
			}

			if (yPos >= getHeight()-50 || yPos <= 0) {
				yRicht *= -1;
			}

			//Neuzeichnen anstoßen
			repaint();

			//Thread kurz schlafen legen, sonst wird alles andere gebremst.
			try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
			}

		}

	}
}