repaint() aufrufen

[elPresidente]

Hallo!

Ich bin gerade dabei Java zu lernen und hätte mal eine Frage an euch:

Ich habe ein Programm in dem ein 2Dimensionales Array erstellt wird, dann zufällig mit 0 oder 1 gefüllt wird und schließlich ausgegeben werden soll (in Form eines Schabrettmusters).

Klappt soweit auch gut, nur hätte ich jetzt gerne eine Schleife immer wieder neue Zufallswerte reinschreibt und das ganze neu zeichnen.
Ich bilde mir ein das ich das auch richtig umgesetzt hab, nur das aufrufen von repaint() funktioniert nicht :?
Hier mal mein Code:

public class Main {
    public static void main(String[] args) {
        
        int[][] cellArray = new int[12][12];            // Array mit Zellen
                 
        JFrame frm = new JFrame();                      // Neues Fenster
        frm.setSize(300,300);
        frm.add(new Draw(cellArray));                   
        frm.setVisible(true);       
           
        for (int i=0;1<5;i++){
            Rnd RandomCells = new Rnd();                    // Rnd füllt Array zufällig
            cellArray = RandomCells.setzeZufaellig();       // CellArray ist jetzt mit neuen Zufallswerten gefüllt  
            
            Draw drw = new Draw(cellArray);                 
            drw.NeuZeichnen();                              // Hier wird die Methode Neuzeichnen der Klasse Draw aufgerufen
            
            try {Thread.sleep(1000);}                       // 1 Sekunde Pause
            catch (InterruptedException e){} 
        }       
    }  
}



public class Rnd {
    int[][] Rnd = new int[12][12];             //2D-Array wird initialisiert
    Random r = new Random();                   // r ist Zufallsvariable    
       
          int[][] setzeZufaellig(){                          // 2D Array wird mit der Methode rechne() gebildet
            for(int i=1; i<11; i++){                         // Array wird mit Zufallswerten gefüllt
                    for(int j=0; j<10; j++){
                        Rnd [i][j] = 1 + Math.abs(r.nextInt()) % 2 - 1;
                    }
            }                   
            return (Rnd);                                   // gefülltes Array ist returnwert
          }        
}



public class Draw extends JPanel{

    int[][] cells =  new int[12][12];     // Array für Zellen
    
    public Draw(int [][] cellArray) {     // Konstruktor übergibt Werte
      cells = cellArray;
    }
       
    protected void paintComponent( Graphics g )
  {
    super.paintComponent( g );

    for(int i=1; i<11; i++){                        // Wenn im Array 1 steht, volle Zelle zeichnen, sonst leere
                    for(int j=1; j<11; j++){
                       if(cells[i][j]==0) 
                            g.drawRect(i*10+10,j*10+10,10,10);
                       if(cells[i][j]==1) 
                            g.fillRect(i*10+10,j*10+10,11,11);
                    }
         }  
  }
    
    protected void NeuZeichnen() {                  // NeuZeichnen Methode führt repaint() durch   
       repaint();
    }  
}

Das Ergebnis des ganzen ist das er alles macht was ich will, nur irgendwie funktioniert repaint() nicht!
Kann man das ganze überhaupt so machen?? Wo liegt der Fehler?
Bin echt für jede Hilfe dankbar...wie gesagt, bin ein absoluter Java Anfänger!

Vielen Dank![/code]

 

[0x7F800000]

-Du erzeugst auserhalb der schleife ein "Draw"-Objekt, fügst es ins Fenser ein. Das wird auch angezeigt.
-Du startest die schleife.
-dort erstellst du zigtausende "Draw"-Objekte, die nirgendwo niemals sichtbar gemacht werden, und bei jedem
durchlauf vom Garbage-Collector geschreddert werden.
=> Du siehst für alle Ewigkeit nur das allererste "Draw" objekt, das niemals verändert wird.


Unendlich lange neue komponenten in einer unendlichen schleife erzeugen ist quatsch, selbst wenn du die alle sichtbar machst, müllst du nur den speicher zu.

Sorge stattdessen lieber dafür, dass die daten (dieses Array) in deinem "Draw"-Objekt in einer schleife immer wieder mit neuen werten gefüllt wird, und jedes mal neugezeichnet wird. Also EIN Draw-Objekt, nicht 7589327592 Milliarden.
:wink:

Allgemeine Anmerkungen:
-du deutsch? du englisch? was du wollen man? :lol: entscheide dich mal...
-Eine ganze extra-klasse zum füllen von einem array mit zufälligen werten ist quatsch. Lösche die weg, und kopiere die wesentlichen drei zeilen in deine "Draw"-klasse.
-methoden wie "NeuZeichnen()" sind ja wohl der totale blödsinn, was soll das denn sein? EnglischDeutschÜbersetzungs-wrapper-methode?? :bloed:
-ansonsten sieht das halbwegs okay aus...

 

[André Uhres]

Spricht man so mit dem Präsidenten? :lol:

 

[0x7F800000]

...wenn es irgendein selbsternanter präsident von irgendeinem Zentralamerikanischen Schurkenstaat ist: jo^^ der nimmt das auch bestimmt nicht ernst, stimmts amigo?

 

[Guest]

Hi!

Erstmal vielen Dank für die Hilfe und die ehrlichen kommentare *schluck*!

Was Du sagst klingt logisch...ich werd's ausprobieren und ggf. nochmal was posten!

Ich versteh zwar nicht ganz warum das repaint() in einer Endlosschleife läuft aber das es so ist hab ich auch schon gemerkt...

Rein prinzipiell: Warum sind die Draw Objekte denn nicht sichtbar? (Wie würde ich sie sichtbar machen)

Die Extra Klasse für die Zufallswerte will ich eigentlich schon behalten, da ja auch noch ein paar andere Klassen dazukommen die den Array "bearbeiten" sollen. Und dann ist es so denke ich übersichtlicher.

Wegen Deutsch-Englisch: Sorry....werd's ändern

Grüße vom Präsidenten

PS: @André: Ich bin ein netter Präsident, mir mir kann man auf jede Art sprechen :bae:

 

[0x7F800000]

1) repaint() läuft eben nicht in einer endlosschleife. Das musst du schon mit einem Thread aufrufen, das mit dem Thread war schon richtig.

2)Die ganzen Draw objekte sind nicht sichtbar, weil sie nirgendwo sichtbar gemacht werden. Damit sie sichtbar sind, musst du sie in ein fenster einfügen. Stattdessen erzeugst du die nur in einer schleife und machst mit den gar nichts.

Wie gesagt: es ist ein unsinniger ansatz, milliarden von diesen Draw-Komponenten zu erzeugen, du brauchst nur eins, aber du musst den inhalt regelmäßig ändern

Ich würde das etwa so machen:

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

public class Draw extends JComponent{
    
    //member vars
    private int[][] cells;
    
    //thread
    private static class DrawThread extends Thread{
        private Draw drawComponent;
        public DrawThread(Draw _drawComponent){
            drawComponent=_drawComponent;
        }

        public void run(){
            while(true){
            //bei dem BEREITS EXISTIERENDEN Draw-Objekt zellen ändern
            //CellRandomizer.createRandomCells(drawComponent.getCells());
            //neuzeichnen
            drawComponent.repaint();
            //warten
            try{
                sleep(1000);
            }catch(InterruptedException e){
                System.out.println(e);
            }
            }
        }
    }


    //constructor
    public Draw(int w, int h){
        cells=new int[w][];
        for(int i=0; i<w; i++){
        	cells[i]=new int[h];
        }
        DrawThread thread=new DrawThread(this);
        thread.run();
    }
    
    public void paint(){
    	//irgendwelche kästchen zeichnen, was auch immer...
    }
    
    //main
    public static void main(String[] args){
    	JFrame f=new JFrame("Blah");
    	f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	
    	f.getContentPane().add(new Draw(10,10));
    }
}

die main() sollte man übersichtshalber woandershin auslagern usw. aber im grunde dürfte es so ähnlich laufen...

 

[elPresidente]

So, ich hab jetzt eine ganze Weile Deinen Code betrachtet und versucht ihn zu verstehen (hab mich auch etwas in das Thema Threads eingelesen).

Was mir leider noch nicht klar ist ist die "private drawComponent", kannst Du mir bitte nochmal kurz erklären was die genau macht und warum man drawComponent.repaint() aufruft und nicht einfach nur repaint() :?:
Da muss auch noch irgendwo ein Fehler liegen weil er die drawComponent Variable nicht findet (hab ich auskommentiert).

Das nächste Problem ist, das er offenbar die run() Methode gar nicht aufruft, hab's auf verschiedene Arten probiert und nichts ging.

Ich hoffe das ich das nicht alles verbockt hab als ich Deinen Code etwas angepasst hab, aber eigentlich ist ja alles so geblieben:

public class Draw extends JComponent{

     int[][] cells =  new int[12][12];                          // Array für Zellen
   
     private static class DrawThread extends Thread{   
         private Draw drawComponent;                                     // Versteh ich nicht
        public DrawThread(Draw _drawComponent){                 // Versteh ich nicht
            drawComponent=_drawComponent;                         // Versteh ich nicht
        }
     }
             
     public void run(){
           for(int t=0; t<5; t++){
                CellRandomizer RandomCells = new CellRandomizer();                // erzeugt neues CellRandomizer Objekt
                cells = RandomCells.createRandomCells();                          // Ich weiß, dann hab ich wieder 1000 Objekte                             
     //   !!!   drawComponent.repaint();   |Cannot find Symbol, variable drawComponent|                        
                System.out.println("repaint");
            try{
                Thread.sleep(1000);                                 // Pause
            }catch(InterruptedException e){
                System.out.println(e);
            }
            }
     } 
          
        public Draw(){                                                               // Konstruktor
            DrawThread thread=new DrawThread(this);                 // erzeugt neuen Thread
            thread.run();                                                             // und startet ihn
        } 
            
    public void paint( Graphics g )                                 // zeichnet die Zellen
    {
    super.paint( g );    
    for(int i=1; i<11; i++){                                         // Wenn im Array 1 steht, volle Zelle zeichnen, sonst leere
                    for(int j=1; j<11; j++){
                       if(cells[i][j]==0) 
                            g.drawRect(i*10+10,j*10+10,10,10);
                       if(cells[i][j]==1) 
                            g.fillRect(i*10+10,j*10+10,11,11);
                    }
         }  
    }         
}

Ach ja...Du hattest mir ja noch als Hinweis gegeben eine Methode getCells() zu erstellen und über die die Zufallswerte zu holen. Wie würde so eine Methode denn aussehen?? Ich hab jetzt wieder was drin das jedes mal ein neues CellRandomizer-Objekt erzeugt (ich weiß das es dumm ist).

Ich wär echt dankbar für ein paar (hoffentlich) letzte Worte der Erklärung, hab über das Problem schon echt viel verstanden....wäre schön wenn sich der Rest auch noch klärt

Ach ja, die Main Methode ist ausgelagert und ruft das so auf die Du das auch hattest
JFrame frm = new JFrame();
frm.getContentPane().add(new Draw());

 

[0x7F800000]

oops statt "run()" muss man in konstruktor natürlich "start()" aufrufen, sry, ich habs ganz schnell zusammengehackt und nicht nachgerpüft obs läuft. start() soll es heissen, asche auf mein hirn... :cry:

zu dem was du abgeändert hast: die "run()" methode gehört selbstverständlich in die DrawThread-Klasse, bei dir ist die irgendwie wieder nach draußen in die Draw-Klasse herausdiffundiert, das macht natürlich keinen sinn, weil Draw-Klasse ja kein Thread ist...

Das "private Draw drawComponent" ist einfach eine referenz auf die komponente, damit die innere DrawThread-Klasse (das ist je eine andere Klasse, schon klar oder?) eben in der lage ist, mit "drawComponent.repaint()" den inhalt der komponente regelmäßig neuzuzeichnen (...und nebenbei mit neuen zufallswerten füllen)

so, hoffentlich hilfts was... sry, das mit start() hab ich voll verbockt, sry^^

[edit] in diesem thread hier geht es gerade auch um sowas ähnliches, nur wurde dort statt der inneren "DrawThread" die äußere klasse "Timer" verwendet, aber eigentlich ist es ziemlich ähnlich, und vor allem: dort ist das beispiel vollständig: http://www.java-forum.org/de/topic66351_ausgabe-aktualisieren-stoppuhr.html

 

[elPresidente]

Ok, das hab ich jetzt soweit hingekriegt...

Bleiben "nur" noch meine Probleme mit der getCells() Methode. Ich weiß einfach nicht genau wie ich das umsetzen soll (klar, die Methode soll das Array mit neuen Werten füllen, aber wie?)

Und das größte Problem, er scheint den Thread immer noch nicht zu starten.
Das System.out.println("run() läuft, repaint() wird ausgeführt"); wird ja auch nicht ausgegeben :?

public class Draw extends JComponent{

    int[][] cells =  new int[12][12];                           // Array für Zellen
       
    int[][] getCells(){                                                                // Ist das hier völliger Blödsinn
           CellRandomizer RandomCells = new CellRandomizer();   // oder gehts wenigstens in die richtige Richtung?             
           cells = RandomCells.createRandomCells();                     // Ich fürchte eher nicht :|
           return(cells);
    }
      
    private static class DrawThread extends Thread{   
         private Draw drawComponent;                                 
         public DrawThread(Draw _drawComponent){               
            drawComponent=_drawComponent;                
         }  
             
     public void run(){
           while(true){                                                 
             //   CellRandomizer.createRandomCells(drawComponent.getCells());       // ????        
                drawComponent.repaint();                        
                System.out.println("run() läuft, repaint() wird ausgeführt");
                
                try{Thread.sleep(1000);}                                            // Pause
                catch(InterruptedException e){System.out.println(e);}   
            }     
     }
    }
         
    public Draw(){                                                               // Konstruktor
        DrawThread thread=new DrawThread(this);                 // erzeugt neuen Thread
        thread.start();                                                           // und startet ihn
    } 
            
    public void paint( Graphics g ){                                 // zeichnet die Zellen
    super.paint( g );    
        for(int i=1; i<11; i++){                                        // Wenn im Array 1 steht, volle Zelle zeichnen, sonst leere
                    for(int j=1; j<11; j++){
                       if(cells[i][j]==0) 
                            g.drawRect(i*10+10,j*10+10,10,10);
                       if(cells[i][j]==1) 
                            g.fillRect(i*10+10,j*10+10,11,11);
                    }
        }  
    }         
}

Ach Mann...ich hatte zwischenzeitlich echt schon gedacht ich hätte ne Menge begriffen, aber das ist wohl noch ein weiter Weg!![/code]

 

[0x7F800000]

was war denn konkret dein problem, hat doch schon fast alles funktioniert? so läufts definitiv, und ich habe kaum etwas abgeändert... Nur "randomize cells" musst du durch diese komische andere klasse da ersetzen, aber ich hab die ja nicht da, konnte die ja nicht benutzen...

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

public class Draw extends JComponent{ 
	
	// Array für Zellen 
	private static final int N=25;
    int[][] cells =  new int[N][N];
    //member variable für CellRandomizer
    public CellRandomizer randomizer;
       
    private static class DrawThread extends Thread{    
         private Draw drawComponent;                                  
         public DrawThread(Draw _drawComponent){                
            drawComponent=_drawComponent;                
         }  
              
	     public void run(){ 
	           while(!isInterrupted()){
	        	   //ersetze das durch diesen CellRandomizer oder wie auch immer, 
	        	   //ich hab die klasse grad nicht da..
	        	   	drawComponent.randomizer.randomizeCells(drawComponent.cells);
	                drawComponent.repaint();
	                
	                try{Thread.sleep(1000);} 
	                catch(InterruptedException e){System.out.println(e);}    
	            }      
	     } 
    } 
    
    private static class CellRandomizer {
    	//es kann eigentlich statisch geschriben werden, 
    	//aber du wolltest da ja noch irgendwas hinzufügen..
        public void randomizeCells(int[][] array){                
           for(int i=0; i<array.length; i++){ 
           for(int j=0; j<array[i].length; j++){ 
        	   array[i][j]=(Math.random()>0.5)?(0):(1);
           } 
           } 
        }              
    } 
    
    // Konstruktor 
    public Draw(){  
    	randomizer=new CellRandomizer();
        DrawThread thread=new DrawThread(this);
        thread.start(); 
    } 
            
    public void paint( Graphics g ){
    	g.setColor(Color.BLACK);
    	g.fillRect(0, 0, getWidth(), getHeight());
    	g.setColor(Color.WHITE);
        for(int i=0; i<N; i++){
        for(int j=0; j<N; j++){ 
           if(cells[i][j]==0) 
                g.drawRect(i*10+10,j*10+10,10,10); 
           if(cells[i][j]==1) 
                g.fillRect(i*10+10,j*10+10,11,11); 
        } 
        }  
    }
    
  //main
    public static void main(String[] args){
    	JFrame f=new JFrame("Blah");
    	f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	f.setSize(280,300);
    	f.getContentPane().add(new Draw());
    	f.setVisible(true);
    }
}

also, nächstes mal, wenn es möglich ist, ein minimales komplillierbares beispiel posten, bei dem es nicht funktioniert. Dann kann man dir wesentlich schneller helfen, weil man für einen test keinen redundanten code eintippen muss :toll:

edit: achso, zu "getCells()": Wenn eine methode "getXXX" heißt, dann wird es wohl ein getter sein getCells müsste imho lediglich folgendes tun:

public int[][] getCells(){
    return cells;
}

die habe ich komplett entfernt. Eigentlich war es so gedacht, dass du dieses array an den CellRandomizer übergibst, der das alles dann durchmixt. Die sache mit 6578167143781236418 Randomizern war wieder mal quatsch :bae: , wenn du so eine instanz unbedingt haben willst, dann mach daraus eine Member-Variable der Draw-Klasse.

 

[elPresidente]

Wahnsinn...Dein Code funktioniert ja prächtig
Ich glaube das Hauptsächliche Problem lag die ganze Zeit an dieser cellRandomizer Klasse, wenn ich die Zufallszahlen so wie Du generiere (in Draw) ist alles bestens.

Ich hab die Klasse geändert, aber leider kann ich weder die Methode cellRandomizer() noch getCells() von meinem Thread aus aufrufen!

Hier mal das (fast) funktionstüchtige Programm:

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

public class Draw extends JComponent{

    private static final int N=12;
    int[][] cells =  new int[N][N];                           // Array für Zellen
           
    private static class DrawThread extends Thread{   
         private Draw drawComponent;                                 
         public DrawThread(Draw _drawComponent){               
            drawComponent=_drawComponent;
         }  
             
     public void run(){
           while(true){              
                CellRandomizer.randomizeCells(drawComponent.getCells());    // !! Hier liegt das Problem !!
                drawComponent.repaint();                                       
                try{Thread.sleep(1000);}                                            // Pause
                catch(InterruptedException e){System.out.println(e);}   
            }     
     }
    }
                 
    public Draw(){                                                            // Konstruktor
        DrawThread thread=new DrawThread(this);                 // erzeugt neuen Thread
        thread.start();                                                        // und startet ihn
    } 
            
    public void paint( Graphics g ){                                 // zeichnet die Zellen
    super.paint( g );    
        for(int i=1; i<11; i++){                                     // Wenn im Array 1 steht, volle Zelle zeichnen, sonst leere
                    for(int j=1; j<11; j++){
                       if(cells[i][j]==0) 
                            g.drawRect(i*10+10,j*10+10,10,10);
                       if(cells[i][j]==1) 
                            g.fillRect(i*10+10,j*10+10,11,11);
                    }
        }  
    }
      
}


public class CellRandomizer {
  
    private static final int N=12;
    int[][] Rnd = new int[12][12];              //2D-Array wird initialisiert
    
    public void randomizeCells(){               
       for(int i=0; i<N; i++){
            for(int j=0; j<N; j++){
                Rnd[i][j]=(Math.random()>0.5)?(0):(1);
            }
       }
    }
    
    public int[][] getCells(){                  // getter
        return Rnd;
    }                   
}


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

public class Main { 
     
    public static void main(String[] args){ 
       JFrame f=new JFrame("Blah");
       f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       f.setSize(280,300);
       f.getContentPane().add(new Draw());
       f.setVisible(true);
    }
}

[/code]

 

[0x7F800000]

hab den letzten code-post abgeändert, dort stehts jetzt... :lol:

"N" an zwei stellen deklarieren ist pfui, unflexibel.

 

[elPresidente]

Perfekt!!!
Genau so hatte ich mir das vorgestellt

Werd jetzt die nächste Zeit schön damit rumspielen und hoffen das ich bald ALLES daran verstehe :###
Ich kann den Code zwar größtenteils nachvollziehen aber selber drauf gekommen wär ich nie!

Also nochmal: Vielen Dank für Deine Hilfe, das alles hat mich echt vorangebracht!!!

Grüße!