Swing Koordinatensystem wird gezeichnet verschwindet aber und die Einteilungen bleiben nicht bestehen

[Alex2013]

Hallo Leute,

ich wollte mich mal an ein Koordinatensystem wagen. Also es zu zeichnen und hierauf Linien sichtbar zu machen. Später kommen hier noch weitere Punkte zu, aber zunächst sollte ja auch die Grundfunktion richtig funktionieren.

Das Problem ist folgendes. Das Koordinatensystem wird korrekt gezeichnet. Nachdem es aber sehr kurz richtig angezeigt wird verschwindet es und es sind nur noch 2 Linien sichtbar (x und y achse).
Wenn man es vergrößert oder verkleinert, sollten ebenso sämtliche Inhalte sichtbar bleiben bzw. durch weiterführende Optionen, welche später hinzugefügt werden, erweitert werden können und diese ebenso sichtbar sein und bleiben. Aber das ist hierbei auch nicht der Fall... :-(

Was mache ich falsch bzw. muss/kann ich anders machen um diese Probleme zu beseitigen?
(Vielleicht löst sich durch das Beheben des einen Problems auch das andere...)

Hier der Code der Hauptklasse:

import java.awt.Container;
import java.awt.Graphics;
import java.awt.Graphics2D;

import javax.swing.JFrame;
import javax.swing.JPanel;


public class KoordinatensystemMitKoordinaten extends JFrame
{
        private static final long serialVersionUID = 1L;
        int x3,x4,y3,y4;
        Koordinaten ko;
        int x,y;
        
        Container c;
        
        //Die Arrays mit den Zwischenschritten werden initialisiert
        Integer []xKo=new Integer[8];
        Integer []yKo=new Integer[8];
        
        public KoordinatensystemMitKoordinaten()
        {
                setSize(900, 700);
        setLocationRelativeTo(null);
        setVisible(true);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        drawLine(x3, x4, y3, y4);
    }
        
        public void paint(Graphics g)
        {
                super.paintComponents(g);
                Graphics2D g2=(Graphics2D)g;
                
                //x Achse
                g.drawLine(0,getHeight()/2 ,getWidth(),getHeight()/2);
       
                //y Achse
                g.drawLine(getWidth()/2, 0, getWidth()/2, getHeight());
                
                String[] line=new String[getWidth()];
                //y linien
                for(int i=0;i<line.length;i++)
                {
                        g.drawLine((getWidth()/2)-5,y+=10,(getWidth()/2)+5,y);
                }
                //x linien
                String[] line2=new String[getHeight()];
                for(int j=0;j<line2.length;j++)
                {
                        g.drawLine(x+=10, (getHeight()/2)-5, x, (getHeight()/2)+5);
                }
        }
        
        public void drawLine(int x3,int x4,int y3,int y4)
        {
                paint(getGraphics());

                x3=(getWidth()-getWidth())+50;
                x4=(getHeight()-getHeight())+200;
                y3=(getWidth()-getWidth())+500;
                y4=(getHeight()-getHeight())+300;
                getGraphics().drawLine(x3,x4,y3,y4);
                repaint();
        }

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

Und die Klasse zum Speichern und wiedergeben von weiteren Koordinaten (für eine spätere Erweiterung):

public class Koordinaten
{
        private String x,y;
        int x2,y2;
        boolean stat=true;
        KoordinatensystemMitKoordinaten kmk;
        Integer []xKo=new Integer[8];
        Integer []yKo=new Integer[8];
        
        
        public int getX2() {
                return x2;
        }

        public void setX(String x) {
                this.x = x;
                int x2=Integer.parseInt(x);
                kmk.repaint();
        }

        public int getY2() {
                return y2;
        }

        public void setY(String y) {
                this.y = y;
                int y2=Integer.parseInt(y);
                kmk.repaint();
        }
        
        public void setKoX(int x2)
    {
                stat=true;
                
                if(stat==true)
                {
                        xKo[0]=this.getX2();
                        xKo[1]=this.getX2();
                        xKo[2]=this.getX2();
                        xKo[3]=this.getX2();
                        xKo[4]=this.getX2();
                        xKo[5]=this.getX2();
                        xKo[6]=this.getX2();
                        xKo[7]=this.getX2();
                }
        }
        
        public void setKoY(int y2)
    {
                stat=false;
                
                if(stat==false)
                {
                        yKo[0]=this.getY2();
                        yKo[1]=this.getY2();
                        yKo[2]=this.getY2();
                        yKo[3]=this.getY2();
                        yKo[4]=this.getY2();
                        yKo[5]=this.getY2();
                        yKo[6]=this.getY2();
                        yKo[7]=this.getY2();
                }
        }
}

Für eine(n) Lösung oder Lösungsansatz wäre ich dankbar 🙂

Lg

Ich habe hierzu auch schon dieses Forum durchsucht und einiges bei Google gesucht und gefunden, aber nicht genau das, was hier vlt. helfen könnte/konnte. Bzw. das Angewandte brachte keine Verbesserung.

 

[Harry Kane]

Erweitere JComponent, und packe deine Zeichenlogik in die paintComponent(Graphics g) Methode. Nur dort sollte gezeichnet werden.
Bei deinem Ansatz überschreibst du die paint-methode (was möglich, aber unpraktisch ist, weil du so dein Koordinatensystem nicht als JComponent in eine existierende Gui einbetten kannst), hast eine drawLIne-Methode, die im Konstruktor aufgerufen wird, aber danach vielleicht nie mehr (oder doch? Wer weiss), und in deiner drawLIne-Methode rufst du paint(getGraphics()) (wobei man getGraphics() von Components eigentlich nie verwenden sollte), und holst dir dann nochmal den getGraphics() und zeichnest da noch etwas drauf.
Ehrlich: das sieht ziemlich chaotisch aus. Wo hast du diesen Ansatz her?

 

[Alex2013]

Du meinst also, dass ich von JComponent erben sollte?
Ich versuche es mal 🙂

 

[Alex2013]

Nun ja, das habe ich selbst überlegt. Da ich es ohne UML Vorlage bzw. ohne UML Ausarbeitung durchführen wollte.
Was für einen Ansatz würdest du vorschlagen? MVC?

 

[Foxei]

Hallo Harry Kane,
dein Fehler ist ganz einfach wenn du getGraphics.drawLine() aufruft Malt er einmahlig eine Linie. Bei nächsten repaint verschwindet sie. Du musst die Koordinaten in einem Array Speichern und diese Array in der PaintComponent Methode durchlaufen und zeichnen lassen.

p.s. dein Code ist ziemlich Unübersichtlich und du befolgst bestimmte programmier Standarts nicht :/ ich bin im Moment nicht zuhause desshalb kann ich dir keine Verbesserungen zeigen. Ich werde mich nach dem Wochenende dir nochmal zuwenden und dir schreiben was verbesserungs würdig ist.
Gruß Simon

 

[Harry Kane]

Nun ja, das habe ich selbst überlegt. Da ich es ohne UML Vorlage bzw. ohne UML Ausarbeitung durchführen wollte.
Was für einen Ansatz würdest du vorschlagen? MVC?

Also ehrlich, hier musste ich schon etwas schmunzeln. Mit meiner Frage zielte ich eher darauf ab, warum du deinen Zeichencode so chaotisch verstreut hast, anstatt in da zu bündeln, wo er hingehört. Keine Tutorials zum Thema "Zeichnen in Swing" gesucht oder gefunden? Irgendwoher musst du ja den Ansatz bekommen haben, bei einer von JFrame abgeleiteten Klasse die paint-Methode zu überschreiben, und dir mit getGraphics() einen Graphics zu beschaffen. Und mich hat nur interessiert, woher.
Wen du mich schon fragst, was ich für einen Ansatz vorschlagen würde: wie würdest du denn den Ansatz nennen, den du gewählt hast?
In deiner KoordinatensystemMitKoordinaten gibt es übrigens noch ein nicht initialisiertes Container und Koordinaten Objekt. Was haben die denn dadrin zu suchen?
@Foxei: inhaltliche fast vollständige Zustimmung meinerseits, nur daß ich nicht der Fragesteller bin.