Swing JButtons werden nach repaint() doppelt dargestellt

[Nele]

Hallo zusammen

Ich muss in diesem Semester als Projekt ein Spiel programmieren. Meine Gruppe hat sich auf Schiffe Versenken geeinigt. Das Spiel läuft auch bereits.

Allerdings haben wir das Problem, dass alle JButtons nach dem repaint() aufruf zusätzlich in der oberen linken Ecke des Fensters gezeichnet werden.
Wir können uns absolut nicht erklären warum.
Als ich es bei meinem Bruder getestet habe, war dies bei ihm nicht der Fall. Daher kann es ja nicht wirklich am Code liegen oder?
Ich habe bereits die aktuellsten Versionen runtergeladen. Also Java 8 und aktuelle java development kit. Auch das compiler level habe ich in Eclipse mit dem von meinem Bruder abgestimmt. Ist alles identisch.

Nur wo liegt dann das Problem?

Hier mal zwei Bilder, damit ihr wisst wovon ich schreibe
So sieht das Fenster zu Beginn aus:


So sieht das Fenster aus, wenn man einen Button anklickt und daraufhin das Schiff gesetzt wird:


Nun hier noch der Code:
Das ist unser JFrame:

package game;


import javax.swing.JFrame;
import java.awt.Toolkit;
import javax.swing.JPanel;

public class Position
{
    private JPanel feld;
    private int x;
    private int y;

    public Position() {

        initComponent();

    }

    public void initComponent() {

        JFrame newFrame= new JFrame();
                
        x = Toolkit.getDefaultToolkit().getScreenSize().width;
        y = Toolkit.getDefaultToolkit().getScreenSize().height;
        y = y - 40;
        newFrame.setSize(x, y);
        newFrame.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        newFrame.setTitle("Positionierung der Schiffe");
        newFrame.setVisible(true);
       
        FrameManager frameManager = FrameManager.getInstance();
        frameManager.registerFrame("PositionFrame", newFrame);
        frameManager.showFrame("PositionFrame");
       
        feld = new PanelPosition(x / 3, y / 8, 10);

        newFrame.add(feld);
    }

}

Das ist unser JPanel:

package game;

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

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JButton;
import javax.swing.JPanel;

public class PanelPosition extends JPanel {

   private Graphics graphics;
   
   private boolean feldSpieler[][];

   // Feld Spieler1
   private int x;
   private int y;
   
   private int xLength;
   private int yLength;

   private int outsideBox;
   
   //Achsenbeschriftung Feld
   private String[] beschriftungX = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
   private String[] beschriftungY = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" };

   // Länge des Schiffs
   private int laenge;

   private JButton schiff2er;
   private JButton schiff3er;
   private JButton schiff4er;
   private JButton schiff5er;
   private JButton vertikalButton;
   private JButton weiter;

   private SchiffeSpielfeld feld;

   private int[] ship = new int[6];
   private int[] shipX = new int[6];
   private int[] shipY = new int[6];
   private int[] shipLaenge = new int[6];
   private int[] shiphoehe = new int[6];


   private boolean vertikal;
   private boolean loeschen;

   // Koordinaten der Schiffe
   private int x1;
   private int y1;

   private boolean click = false;
   private boolean mouseListener = false;

   private JButton zuruecksetzen;


   public PanelPosition(int x, int y, int level) {
       this.x = x;
       this.y = y;
       
       feldSpieler = new boolean[level][level];

       xLength = x + 40 * level;
       yLength = y + 40 * level;


       weiter = new JButton("Start!");
       schiff2er = new JButton("2-Felder-Schiff");
       schiff3er = new JButton("3-Felder-Schiff");
       schiff4er = new JButton("4-Felder-Schiff");
       schiff5er = new JButton("5-Felder-Schiff");
       vertikalButton = new JButton("vertikale Ausrichtung");
       zuruecksetzen = new JButton("Schiffe zurücksetzen");

       add(schiff2er);
       add(schiff3er);
       add(schiff4er);
       add(schiff5er);
       add(vertikalButton);
       add(weiter);
       add(zuruecksetzen);

       feld = new SchiffeSpielfeld(x, y);

       zuruecksetzen.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent evt) {
               zuruecksetzenActionPerformed(evt);
           }
       });

       weiter.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent evt) {
               weiterActionPerformed(evt);
           }

       });

       schiff2er.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent evt) {
               schiffActionPerformed(evt);
           }

       });

       schiff3er.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent evt) {
               schiffActionPerformed(evt);
           }

       });

       schiff4er.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent evt) {
               schiffActionPerformed(evt);
           }

       });

       schiff5er.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent evt) {
               schiffActionPerformed(evt);
           }

       });
       vertikalButton.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent evt) {
               vertikalActionPerformed(evt);
           }

       });

   }

   
   public void weiterActionPerformed(ActionEvent evt) {
       new Spielfeld(feldSpieler);
       
       FrameManager frameManager = FrameManager.getInstance();
       frameManager.hideFrame("PositionFrame");
   }

   public void zuruecksetzenActionPerformed(ActionEvent evt) {
       
       FrameManager frameManager = FrameManager.getInstance();
       frameManager.destroyFrame("PositionFrame");
       
       Position framePosition = new Position();
       
   }
       

   public void vertikalActionPerformed(ActionEvent evt) {
       vertikal = true;
   }

   
   public void schiffActionPerformed(ActionEvent evt) {

       if (schiff2er.hasFocus()) {

           mouseListener = true;

           click = true;

           Mouse(2);

       }

       if (schiff3er.hasFocus()) {

           mouseListener = true;
           click = true;

           Mouse(3);

       }

       if (schiff4er.hasFocus()) {

           mouseListener = true;
           click = true;

           Mouse(4);

       }

       if (schiff5er.hasFocus()) {

           mouseListener = true;
           click = true;

           Mouse(5);

       }

   }

   public void Mouse(int o) {

       
       if (mouseListener) {
           addMouseListener(new MouseAdapter() {
               public void mousePressed(MouseEvent e) {
                   if (click) {
                       if (ship[o] == 0) {
                       
                           
                           int t = e.getX();
                           int f = e.getY();

                           x1 = feld.convertX(t);
                           y1 = feld.convertY(f);

                           int px = feld.positionInFieldX(x, t);
                           int py = feld.positionInFieldY(y, f);

                           laenge = o;

                           boolean valid = true;
                           
                           // Das Schiff soll nicht vertikal platziert werden
                           if (!vertikal) {
                           


                               for (int c = px; c < px + o; c++) {

                                   if (feldSpieler[c][py]) {

                                   
                                       valid = false;
                                       
                                       

                                   }
                               }

                               if (valid) {

                                   for (int i = px; i < px + o; i++) {

                                       feldSpieler[i][py] = true;

                                   }

                                   repaint();
                               } else {
                                   click = false;
                                   laenge = 0;
                                   vertikal = false;
                               }

                           }

                           // Das Schiff soll vertikal platziert werden
                           else {

                               for (int v = py; v < py + o; v++) {

                                   if (feldSpieler[px][v]) {

                                       valid = false;

                                   }
                               }
                               if (valid) {
                                   for (int j = py; j < py + o; j++) {

                                       feldSpieler[px][j] = true;

                                   }

                                   repaint();
                               } else {
                                   click = false;
                                   laenge = 0;
                                   vertikal = false;

                               }
                           }

                       }

                   }

               }
           });

       }

   }

   public void paintComponent(Graphics g) {
       
       this.graphics = g;
       
       if (click) {
           
       
           
           if (!vertikal) {
               g.setColor(Color.BLACK);
               g.fillRect(x1, y1, laenge * 40, 40);
               ship[laenge] += 1;
               shipX[laenge] = x1;
               shipY[laenge] = y1;
               shipLaenge[laenge] = laenge * 40;
               shiphoehe[laenge] = 40;

           } else {
               g.setColor(Color.BLACK);
               g.fillRect(x1, y1, 40, laenge * 40);
               ship[laenge] += 1;
               shipX[laenge] = x1;
               shipY[laenge] = y1;
               shipLaenge[laenge] = laenge * 40;
               shiphoehe[laenge] = 40;

           }
       }
       this.paintSpielfeld(g);
       this.paintBeschriftungX(15, 10);
       this.paintBeschriftungY(15, 25);

       click = false;
       laenge = 0;
       vertikal = false;

   }
   
   private void paintSpielfeld(Graphics g)
   {
       for (int i = x; i < xLength; i = i + 40) {
           for (int j = y; j < yLength; j = j + 40) {

               g.setColor(Color.BLACK);
               g.drawRect(i, j, 40, 40);

           }

       }
       
   }
   
   private void paintBeschriftungX(int stepX, int stepY)
   {
       int index = 0;

       for (int b = x; b < xLength; b = b + 40) {
           this.graphics.setColor(Color.BLACK);
           this.graphics.drawString(this.beschriftungX[index], b + stepX, y - stepY);
           index++;
       }
   }
   
   private void paintBeschriftungY(int stepX, int stepY)
   {
       int index = 0;

       for (int b = y; b < yLength; b = b + 40) {
           this.graphics.setColor(Color.BLACK);
           this.graphics.drawString(beschriftungY[index], x - 15, b + 25);
           index++;
       }
       
   }
}

Ich hoffe sehr, dass mir einer von euch weiterhelfen kann. So sieht das ganze natürlich sehr unschön aus...

Liebe Grüße
Nele

 

[Harry Kane]

newFrame.setVisible(true);
gehört ans Ende der initComponent()-Methode.
Und bitte vor setVisible() noch newFrame.pack() aufrufen.

 

[Nele]

Meinst du das so?

Das löst aufjedenfall nicht das Problem und nun habe ich das Problem, dass nicht das ganze Fenster aufgeht sondern nur die Buttons oben angezeigt werden...

    public Position(String flotte, String meer) {
        initComponent();

    }

    public void initComponent() {

        JFrame newFramePosition = new JFrame();

        x = Toolkit.getDefaultToolkit().getScreenSize().width;
        y = Toolkit.getDefaultToolkit().getScreenSize().height;
        y = y - 40;
        newFramePosition.setSize(x, y);
        newFramePosition.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        newFramePosition.setTitle("Positionierung der Schiffe");
   
        FrameManager frameManager = FrameManager.getInstance();
        frameManager.registerFrame("PositionFrame", newFramePosition);
        frameManager.showFrame("PositionFrame");
   
       
        feld = new PanelPosition(x / 3, y / 8, 10, flotte, meer);
       
        newFramePosition.add(feld);
        newFramePosition.pack();
       
        newFramePosition.setVisible(true);
    }
}

 

[Soloeco]

Das das ganze Fenster nun nicht mehr aufgeht wird an dem newFramePosition.pack() liegen denke ich. Aber es stimmt schon, das setVisible ruft man grundsätzlich immer zum Schluss auf.
Woran das mit den doppelten Zeichnen liegt kann ich aktuell leider nicht sagen, ich sitze aktuell selber in einer Vorlesung zu Programmieren und müsste mich in deinen Code erst einlesen, was leider etwas schwierig ist, da wenige Kommentare vorhanden sind und die Variablen meiner Ansicht nach nicht sehr sinnvoll benannt sind, aber das auch nur am Rande als Bemerkung. Ich kann mich gerne später mal ein wenig einlesen.

Liebe Grüße und viel Erfolg noch, vielleicht findest du/ihr den Fehler ja doch noch

EDIT: Was genau dieses pack() macht kann ich leider nicht gut erklären :/

 

[Nele]

Ohje, tut mir Leid
Da hast du Recht. Die meisten Variablennamen sind nicht besonders gut benannt. Da müssen wir uns nochmal ran setzten, bevor wir das unserem Prof abgeben. Nicht das der noch durchdreht

Das wäre super!

 

[Soloeco]

Also ich habe mir den Code nun einmal angesehen und der scheint soweit schlüssig zu sein. Ich dachte zunächst, dass das doppelte Zeichnen durch einen ungewollten repaint Aufruf hervorgerufen wird, doch selbst dann sollten die ja nicht in der Ecke sein, sondern an der eigentlichen Stelle sein sollen. Dazu kommt noch das Argument, dass es auf dem PC deines Bruders funktioniert, somit kann ich es mir auf keinste Weise logisch erklären. Tut mir leid, da kann ich euch leider gerade nicht weiterhelfen :/

Jedoch als weitere Anmerkungen:
-

nun habe ich das Problem, dass nicht das ganze Fenster aufgeht sondern nur die Buttons oben angezeigt werden...

Hat sich dies erledigt?
- Wenn ihr das Fenster so setzen wollt, dass die Taskleiste sowie die obere Leiste zu sehen ist, dann könnt ihr folgendes benutzen, jedenfalls mache ich das häufig so:

meinFensterName.setExtendedState(JFrame.MAXIMIZED_BOTH);

- Und ich denke ihr solltet euch Gedanken machen, ob wirklich so viel in einer Klasse stehen muss. Eine andere Gruppe bei uns macht ebenfalls dieses Projekt, jedoch mit JavaFX und ich weiß nicht wie die das umsetzen, da ich selbst genug mit meiner Autobahnsimulation zu tun habe

 

[Nele]

Ach so ein Mist
Aber danke, dass du drüber geschaut hast

Wir fragen einfach unseren Prof. Wenn der das nicht weiß können wir es auch nicht wissen

Super vielen Dank für den Hinweis!
Damit öffnet es mir das Fenster ganz

 

[Harry Kane]

pack() sorgt dafür, dass ein Fenster eine Größe gesetzt bekommt, die es benötigt, nicht zuviel, nicht zuwenig.
Die optimale Größe für euer PanelPosition ist die Größe der JButtons plus ev. ein kleiner Rand. Ihr zeichnet aber in der überschriebenen paintComponent() Methode von PanelPosition ausserhalb des Bereiches der JButtons. Dieser "Zeichenbereich" verschwindet nach Aufruf von pack(), weil er nicht in die Größenberechnung eingeht (so schlau ist pack() nun auch wieder nicht).
Dies bringt mich zu folgendem Punkt: man kann JPanels entweder als normale Container verwenden (also Komponenten wie JButtons drauf packen), oder als Zeichenfläche, um spezielle Grafikoperationen durchzuführen (z. B. um Gitter, Images, etc. zu zeichnen). Nur im letzten Fall muss paintComponent() überschrieben werden. Ihr macht beides (Komponenten hinzufügen und selber zeichnen) mit ein und demselben JPanel. Ich würde eher dazu raten, die Zeichenoperationen in einer unabhängigen Instanz von JPanel abzulegen, die auch auf das JFrame gepackt wird.
Ich habe mir die paintComponent(Graphics) von PanelPosition angeschaut. Ihr ruft an keiner Stelle super.paintComponent(Graphics) auf. Das Fehlen dieses Aufrufs könnte die von euch beschrieben Artefakte verursachen. Fügt den Aufruf einfach mal ein.

 

[JCODA]

Zudem:
this.graphics = g;
Ist schlicht falsch in der paintComponent. Das GraphicsObject kann nur während des paintComponent Aufrufs sinnvoll genutzt werden, spätere Verwendungen können sich durch alle möglichen Darstellungsfehler bemerkbar machen.

 

[Nele]

Vielen Dank für die Hinweise!
Ich werde mir das am Montag bzw. Dienstag genauer anschauen und dann berichten

 

[Nele]

So, ich habe es nun endlich geschafft deinen Vorschlag mit dem Aufruf super.paintComponent(Graphics) auszuprobieren. Es lag tatsächlich daran, dass der Aufruf gefehlt hat. Jetzt zeichnet es nur noch das, was es tatsächlich neu zeichnen soll wieder. Vielen Dank für die Hilfe!!

Zum this.graphics = g;
Dann sollten wir also lieber alles, wofür wir graphics brauchen auch in die paintComponent schreiben?
Wir haben das ausgelagert, weil das sonst eine ewig lange und unübersichtliche Methode geworden wäre xD
oder gibt es da noch eine andere Alternative?

 

[Harry Kane]

Du kannst aus der paintComponent andere Methoden aufrufen und an die den Graphics übergeben, um das Zeichnen etwas strukturierter zu gestalten.

 

[Nele]

Okay, meinst du das so:

 public void paintComponent(Graphics g) {

      paintBeschriftungX(g, 15, 10);
     }
 
   private void paintBeschriftungX(Graphics g, int stepX, int stepY)
   {
       int index = 0;

       for (int b = x; b < xLength; b = b + 40) {
         g.setColor(Color.BLACK);
 
           g.drawString(this.beschriftungX[index], b + stepX, y - stepY);
           index++;
       }
   }

Anstatt so:

 public void paintComponent(Graphics g) {
    
    this.graphics = g;

       this.paintBeschriftungX(15, 10);
     }
 
   private void paintBeschriftungX(int stepX, int stepY)
   {
       int index = 0;

       for (int b = x; b < xLength; b = b + 40) {
         this.graphics.setColor(Color.BLACK);
 
           this.graphics.drawString(this.beschriftungX[index], b + stepX, y - stepY);
           index++;
       }
   }