Java Array Problemchen

[.:| chuky |:.]

Moin Leute, da ich keinen allgemeinen Java-Probleme-Sammelthread gefunden habe eröffne ich mal einen neuen für mein Problem, den ich dann lösche, sobald alles geklärt ist!

Ist auch eigentlich eine recht einfache frage. Ich nutze als Programmierumgebung aus dem Unterricht BlueJ!

Nun zu meiner Frage:

Wir sind momentan bei Arrays, und wir sollen ein Applet erstellen, das 100 Kästchen (in 10x10 Reihen) ausgibt, wo in jedem Kästchen fortlaufend die jeweilige Nummer steht (00 - 99).

Um die Kästchen zu erzeugen habe ich in der Paint-Methode einfach g.drawRect(x,y,d,e) eingegeben und das in eine Schleife gepackt. Die Kästchen sind also nun da. Meine Frage ist, wie ich jedes davon mit Zahlen bestücken kann, bzw. wie man das mit Arrays löst, denn möglich muss es damit ja sein, wenn es eine Aufgabe zu Arrays ist

Hoffe ihr könnt mir helfen

Danke im voraus, chuky

 

[Gelöschtes Mitglied 45455]

Schreibst halt in jedem Schleifendurchlauf die Laufvariable in das aktuell zu zeichnende Kästchen.

 

[.:| chuky |:.]

genau das hatte ich ja auch vor, aber mit welchem Befehl geht das? darauf sollte meine Frage eigentlich abzielen

 

[bawder]

hi, könntest du den code posten?
ich übe derzeit java und deine anwendung würde mich stark interessieren.

könnte man auch ganz frech einfach eine schleife von 0 nach 99 zählen lassen und die werte eintragen?

 

[Gelöschtes Mitglied 45455]

genau das hatte ich ja auch vor, aber mit welchem Befehl geht das? darauf sollte meine Frage eigentlich abzielen

Deine Laufvariable i in deiner for Schleife, die die Kästchen nacheinander zeichnet und bei 100 abbricht (ich gehe mal von einer for Schleife aus), liest du aus und schreibst die Zahl immer sofort mit in das Kästchen rein.
Je nachdem ob du bei 1 oder 0 anfangen willst musst halt anpassen...

Wenn es eine while Schleife ist wirst du wohl auch eine Zählvariable haben, da du die Kästchen ja zählst.

Alternativ schreibst du in den Datentyp der Felder einfach noch ne Variable für ne Nummer rein, schreibst die vorher rein und liest sie dann irgendwann aus und malst dann die Zahlen...

 

[Nephalem]

wenns ums reine hochzählen geht würde ich in dem fall 2 schleifen ineinander nehmen, die eine die die reihen hochzählt und die andere die die spalten zählt. die werte kannste ja dann aus deinen zählvariablen ausrechnen:

for (i=0; i<10, i++){
for(j=0; j<10;j++){
system.out.println(10*i+j);
}
}

gibt euch die ensprechenden zahlen aus, anpassen müsst ihrs noch selbst :P

 

[tigger]

handelt es sich dabei um ein Graphics Object ?

dann sollte es folgender Befehl sein

g.drawString("Hallo Welt !", xPos, yPos) sein

für den Test mit Array legst du dir wie beim Zeichnen der Rechtecke dann ein doppeltes Array in der Art

int[][] myArray = new int[10][10];

an und initialisierst es in einer doppelten Schleife mit den Laufvariablen i,j und increment von 1 mit

myArray[i, j] = counter++;

wobei counter eine vorher angelegte int Variable mit Initialwert 0 ist

wenn beim Zeichnen d und e deine Breite und Höhe eines Rects sind, zeichnest du den Text mit

g.drawString(String.valueOf(myArray[i, j]), x+d/2, y+e/2)

um den Text ungefähr mittig auszurichten

wenn du x und y um deine Breite eines Kästchens inkrementierst, musst du entweder wieder durch die Breite teilen, um den richtigen Index auf das myArray zu bekommen oder du inkrementierst dein x und y um jeweils 1 und stellst deine Zeichenmethoden wie folgt um

g.drawRect(x*d,y*e,d,e);
g.drawString(String.valueOf(myArray[x, y]), x*d+d/2, y*e+e/2);

hab zwar schon paar Tage nichts mehr mit Java gemacht, aber sollte passen

 

[.:| chuky |:.]

hi, könntest du den code posten?
ich übe derzeit java und deine anwendung würde mich stark interessieren.

könnte man auch ganz frech einfach eine schleife von 0 nach 99 zählen lassen und die werte eintragen?

Hier ist erstmal der Code, für alle, damit du (bawde) den angucken kannst, und damit alle anderen verstehen wie mein Programm bisher aussieht:

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int[] a = new int[10];
    int[] b = new int[10];
    int d = 40;
    int e = 40;
    int r = 0;
    int s = 0;

    public void paint(Graphics g)
    {
        for(int x=40; x<=500; x+=50)
        {
            for(int y=40; y<=500; y+=50)
            {
                g.drawRect(x,y,d,e);
                
                r+=1;
            }
            s+=1;
            r=0;
        }
    }
    
}

Hier noch paar kurze Erläuterungen:
Die Arrays sind bisher nur so da, ohne Verwendung
x und y geben die Position des jeweiligen Kästchens an, und werden in den Schleifen hochgezählt, um passend in die nächste Zeile zu springen nach 10 Quadraten.
d ist die Breite, e die Höhe (oder andersrum, ist ja egal weil's ein Quadrat ist (könnte man also auch eine Variable nehmen))
r und s sind Laufvariablen, die in den Schleifen erhöht werden. Die wollte ich für die Beschriftung nehmen, da normale int-Zahlen ja nicht im Format "04" sondern nur als "4" ausgegeben werden. r verändert die 2. Zahl, s die 1.
so, das sollte denke ich vorerst ausreichen

ne Schleife (bzw 2) habe ich ja die hochzählen und die Positionen angeben.

Deine Laufvariable i in deiner for Schleife, die die Kästchen nacheinander zeichnet und bei 100 abbricht (ich gehe mal von einer for Schleife aus), liest du aus und schreibst die Zahl immer sofort mit in das Kästchen rein.
Je nachdem ob du bei 1 oder 0 anfangen willst musst halt anpassen...

Wenn es eine while Schleife ist wirst du wohl auch eine Zählvariable haben, da du die Kästchen ja zählst.

Alternativ schreibst du in den Datentyp der Felder einfach noch ne Variable für ne Nummer rein, schreibst die vorher rein und liest sie dann irgendwann aus und malst dann die Zahlen...

Meine Frage war ja genau, wie ich die Zahlen darein schreibe

wenns ums reine hochzählen geht würde ich in dem fall 2 schleifen ineinander nehmen, die eine die die reihen hochzählt und die andere die die spalten zählt. die werte kannste ja dann aus deinen zählvariablen ausrechnen:

for (i=0; i<10, i++){
for(j=0; j<10;j++){
system.out.println(10*i+j);
}
}

gibt euch die ensprechenden zahlen aus, anpassen müsst ihrs noch selbst :P

Wie du siehst habe ich 2 for-Schleifen, die hochzählen!

handelt es sich dabei um ein Graphics Object ?

dann sollte es folgender Befehl sein

g.drawString("Hallo Welt !", xPos, yPos) sein

für den Test mit Array legst du dir wie beim Zeichnen der Rechtecke dann ein doppeltes Array in der Art

int[][] myArray = new int[10][10];

an und initialisierst es in einer doppelten Schleife mit den Laufvariablen i,j und increment von 1 mit

myArray[i, j] = counter++;

wobei counter eine vorher angelegte int Variable mit Initialwert 0 ist

wenn beim Zeichnen d und e deine Breite und Höhe eines Rects sind, zeichnest du den Text mit

g.drawString(String.valueOf(myArray[i, j]), x+d/2, y+e/2)

um den Text ungefähr mittig auszurichten

wenn du x und y um deine Breite eines Kästchens inkrementierst, musst du entweder wieder durch die Breite teilen, um den richtigen Index auf das myArray zu bekommen oder du inkrementierst dein x und y um jeweils 1 und stellst deine Zeichenmethoden wie folgt um

g.drawRect(x*d,y*e,d,e);
g.drawString(String.valueOf(myArray[x, y]), x*d+d/2, y*e+e/2);

hab zwar schon paar Tage nichts mehr mit Java gemacht, aber sollte passen

Ja, ist ein graphics-Objekt!

Das mit dem doppelten Array werde ich dann morgen ändern, ist sinnvoller als 2 einzelne, hast schon recht

d und e sind breite und höhe, richtig!

Warum steht bei deinem drawRect-Befehl "x*d" bzw. "y*e"? wozu soll das gut sein?

Und noch die Frage, was der Befehl "String.valueOf(myArray[x, y]" ausgibt?!

Danke für all eure Hilfe

 

[tigger]

d und e sind breite und höhe, richtig!

Warum steht bei deinem drawRect-Befehl "x*d" bzw. "y*e"? wozu soll das gut sein?

Und noch die Frage, was der Befehl "String.valueOf(myArray[x, y]" ausgibt?!

da du dies ja zu Übungszwecken machen sollst, werde ich dir vorerst auch noch keine Musterlösung präsentieren

wenn du deine Höhe und Breite mit 1 inkrementierst, bewirkt das x*d und y*e das selbe, als wenn du die Laufvariablen um Höhe und Breite hochzählst

bei dir wird dann zum Beispiel die Schleife so aus sehen

Durchlauf 1: xPos = x = 40
Durchlauf 2: xPos = x = 90

das selbe dann für y

bei mir wäre es

Durchlauf 1: xPos = x * d = 1 * 40 = 40
Durchlauf 2: xPos = x * d = 2 * 40 = 80

da du von dem Abstand zwischen den Kästchen nichts gesagt hast, geht das noch schief und muss dann angepasst werden, aber wenn du x * (d+10) machst, passt es

String.valueOf( Integer-Variable ) gibt den Wert des int als String zurück, aber da das Array eine entsprechende toString() Methode beinhaltet bzw ein einzelnes Feld ja nur eine integer Variable ist, sollte die reine Angabe von myArray[i, j] reichen

weitere Denkanstösse schreib ich jetzt an entsprechender Stelle in den Quellcode, umsetzen musst du es selbst

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int[][] myArray = new int[10][10];
    int size = 40;
    // um Verwirrungen zu vermeiden, gibt es eine eigene Variable für den Abstand der Kästchen
    int distance = 50;
    // Abstand zum Rand
    int offset = 40;
    // eigene Variablen für x und y Position
    int xPos = 0;
    int yPos = 0;
    // Variable für die hochzählende Kästchennummer
    int counter = 0;

    public void paint(Graphics g)
    {
        // Aufgabe: doppelte Schleife zum Füllen des Array, Schleifen wie beim Zeichnen
        // der Rechtecke, alternativ zusammen mit der Schleife des Zeichnens

        // Aufgabe: Schleife von 0 bis <10 und Inkrementierung von 1
        for(int x=40; x<=500; x+=50)
        {
            // Aufgabe: Schleife von 0 bis <10 und Inkrementierung von 1
            for(int y=40; y<=500; y+=50)
            {
                // x und y Position für das Kästchen ermitteln
                xPos = offset + x * distance;
                yPos = offset + y * distance;

                g.drawRect(xPos, yPos, size, size);

                // Aufgabe: schau dir mal FontMetrics an, mit den Funktionen getHeight
                // und StringWidth könntest du dir die genauen Maße der auszugebenden
                // Zahlen ermitteln und wenn du diese Breite / Höhe von den 2 unten
                // genannten Variablen noch abziehst, hast du sauber mittig zentriert
                // musst das allerdings von den Zahlen im Format 00 ermitteln nach 
                // unten genannter String.format Methode :)
                // x und y Position für das Zeichnen des Textes anpassen
                xPos += size / 2;
                yPos += size / 2;

                // Aufgabe: schau dir mal String.format an, da übergibst du einen String
                // als Muster mit z.B. %d als Parameter für eine Dezimalzahl und danach
                // dann der eigentliche Parameter
                g.drawString(myArray[x, y], xPos, yPos);
            }
        }
    }
    
}

falls du weiter in Richtung Informatik arbeitest, kann ich dir nur 1 Tipp geben

Lern früh genug, Online Quellen zu nutzen und dich selbt in Sachen einzulesen, für Java ist z.B. hier eine gute Anlaufstelle

 

[.:| chuky |:.]

Ich werde später Informatik studieren drum bin ich nicht wie der Rest des Kurses faul sondern versuche, Java so gut es geht zu lernen, um es später nicht mehr zu müssen

"Java ist auch eine Insel" habe ich schon bei mehreren Problemen benutzt, hat mir auch immer geholfen, aber heute hatte ich dazu keine Motivation, sondern wollte mal nen anderen Weg gehen! Zumal mir die Lösungen dort sehr fachmännisch vorkommen, als wenn sie direkt aus der Feder von Sun stammen, und hier habe ich erwartet, "menschlichere" Hilfe zu erhalten, die ich leichter verstehe. Das habe ich ja nun auch bekommen

Allerdings verstehe ich (zumindest heute um diese Uhrzeit) nicht, was du mir da alles vermitteln willst (nur manches!). Vielleicht kommt mir das morgen, sonntag oder sonst wann bzw. beim implementieren in meinen Code!

Dir danke ich auf jeden Fall für deine Hilfe, hast mir ja schon bis hierhin geholfen und normalerweise sollte ich es mit deinen (und den anderen) Tipps hinbekommen, das Applet so zu gestalten wie es verlangt ist!

Vielen Dank

Edit: um das Programm weiter zu vereinfachen habe ich mich jetzt entschieden, die anfängliche Verschiebung auch einfach auf 50 zu setzen, dann kann ich mir die offset variable sparen

Edit2: habe mein Programm jetzt mal deinem angeglichen, sodass ich aber noch erkennen kann, dass ich es auch geschrieben habe:

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int m,n;
    int[][] felder = new int[m][n];
    int size = 40;

    public void paint(Graphics g)
    {
        for(int x=50; x<=500; x+=50)
        {
            for(int y=50; y<=500; y+=50)
            {
                g.drawRect(x,y,size,size);
                g.drawString(String.valueOf(felder[m][n]), x+10, y+10);
                n++;
            }
            m++;
            n = 0;
        }
    }
    
}

Ob das so laufen müsste musst du mir sagen, definitiv feststehen tut, dass es nicht klappt! Das 1. Rechteck wird gezeichnet, danach nix mehr. Also kann das Applet mit dem drawString(...)-Befehl nichts anfangen und stoppt. Das jedoch ohne Fehlermeldung! (die Positionen der Schrift sind erstmal fiktiv gesetzt, werden später dann angepasst!)

 

[tigger]

Ich werde später Informatik studieren drum bin ich nicht wie der Rest des Kurses faul sondern versuche, Java so gut es geht zu lernen, um es später nicht mehr zu müssen

ok, dann solltest du aber eher versuchen, die Struktur und Systematik hinter solchen Ansätzen zu lernen anstatt dich so auf die Programmiersprache zu versteifen

in meiner bisherigen Laufbahn kamen da schon Java, Delphi, C++, C#, php und html zum Einsatz, wobei ich mir C# selber beigebracht habe, da es recht ähnlich zu Java ist

Allerdings verstehe ich (zumindest heute um diese Uhrzeit) nicht, was du mir da alles vermitteln willst (nur manches!). Vielleicht kommt mir das morgen, sonntag oder sonst wann bzw. beim implementieren in meinen Code!

schaus dir einfach mal in Ruhe an, soviel steckt da nicht dahinter

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int m,n;
    int[][] felder = new int[m][n];
    int size = 40;

    public void paint(Graphics g)
    {
        for(int x=50; x<=500; x+=50)
        {
            for(int y=50; y<=500; y+=50)
            {
                g.drawRect(x,y,size,size);
                g.drawString(String.valueOf(felder[m][n]), x+10, y+10);
                n++;
            }
            m++;
            n = 0;
        }
    }
    
}

autsch, das geht böse in die Hose

du musst m und n erstmal sinnvoll initialisieren z.B. mit 0, dann hast du dein Array felder bisher nur deklariert und definiert, aber nicht initialisiert, sprich nie einen Wert für die einzelnen Felder zugewiesen. Setz dein Array auf die Größen [10][10] anstatt m und n, das geht sowieso nicht so, wie du dir gedacht hast, da ein int Array eh nur die Zahl selbst ohne führende Nullen speichert.

Setz den Code hier noch vor deine Schleife zum Zeichnen zum Füllen des Array

int counter = 0;

for (int i = 0; i < 10; i++)
{
  for (int j = 0; j < 10; j++)
  {
    felder[i][j] = counter++;
  }
}

damit hast du dein Array dann schon mal sauber von 0 bis 99 initialisiert

dann ersetzt du dein Zeichnen mit drawString durch

g.drawString(String.format("%0d", felder[m][n]), x+10, y+10);

um deine Zahlen, die im Array als 0, 1, 2 ... 99 stehen mit führender Null als String auszugeben, wenn die Zahl keine 2 Stellen ausfüllt, also Zahlen ab 10 werden auch als 10 ausgegeben, nicht als 010

so sollte es funktionieren

du musst für das Array die Ranges beachten, deine m und n in deiner Variante dürfen da z.B. bei meiner Beschränkung nicht auf einen Index größer 9 zugreifen bei einer Größenangabe von 10 Feldern, sonst knallt es !!

also nochmal komplett, wichtig sind die initialisierten Variablen von m und n
auf den Wert 0

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int m = 0
    int n = 0;
    int[][] felder = new int[10][10];
    int size = 40;

    public void paint(Graphics g)
    {
        int counter = 0;

        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < 10; j++)
            {
                felder[i][j] = counter++;
            }
        }

        for(int x=50; x<=500; x+=50)
        {
            for(int y=50; y<=500; y+=50)
            {
                g.drawRect(x,y,size,size);
                g.drawString(String.format("%0d", felder[m][n]), x+10, y+10);
                n++;
            }
            m++;
            n = 0;
        }
    }
    
}

oder mit einem eindimensionalen Array

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int[] felder = new int[100];
    int size = 40;

    public void paint(Graphics g)
    {
        int counter = 0;

        for(int x=50; x<=500; x+=50)
        {
            for(int y=50; y<=500; y+=50)
            {
                felder[counter] = counter;

                g.drawRect(x,y,size,size);
                g.drawString(String.format("%0d", felder[counter]), x+10, y+10);

                counter++;
            }
        }
    }
    
}

 

[.:| chuky |:.]

hey, war den ganzen Tag arbeiten, daher konnte ich bisher nicht antworten!

autsch, das geht böse in die Hose

du musst m und n erstmal sinnvoll initialisieren z.B. mit 0, dann hast du dein Array felder bisher nur deklariert und definiert, aber nicht initialisiert, sprich nie einen Wert für die einzelnen Felder zugewiesen. Setz dein Array auf die Größen [10][10] anstatt m und n, das geht sowieso nicht so, wie du dir gedacht hast, da ein int Array eh nur die Zahl selbst ohne führende Nullen speichert.

In unserer BlueJ-Umgebung werden Variablen ohne Angabe automatisch 0 zugeordnet, eine Initialisierung muss ich also nicht zwangsläufig vornehmen

Setz den Code hier noch vor deine Schleife zum Zeichnen zum Füllen des Array

int counter = 0;

for (int i = 0; i < 10; i++)
{
  for (int j = 0; j < 10; j++)
  {
    felder[i][j] = counter++;
  }
}

damit hast du dein Array dann schon mal sauber von 0 bis 99 initialisiert

Das ergibt Sinn, sonst habe ich von dem Applet ja gar nichts hab ich voll vergessen

dann ersetzt du dein Zeichnen mit drawString durch

g.drawString(String.format("%0d", felder[m][n]), x+10, y+10);

Was bringt der "%0d" befehl? habe den gegoogelt und nix ordentliches gefunden....

um deine Zahlen, die im Array als 0, 1, 2 ... 99 stehen mit führender Null als String auszugeben, wenn die Zahl keine 2 Stellen ausfüllt, also Zahlen ab 10 werden auch als 10 ausgegeben, nicht als 010

so sollte es funktionieren

du musst für das Array die Ranges beachten, deine m und n in deiner Variante dürfen da z.B. bei meiner Beschränkung nicht auf einen Index größer 9 zugreifen bei einer Größenangabe von 10 Feldern, sonst knallt es !!

also nochmal komplett, wichtig sind die initialisierten Variablen von m und n
auf den Wert 0

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int m = 0
    int n = 0;
    int[][] felder = new int[10][10];
    int size = 40;

    public void paint(Graphics g)
    {
        int counter = 0;

        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < 10; j++)
            {
                felder[i][j] = counter++;
            }
        }

        for(int x=50; x<=500; x+=50)
        {
            for(int y=50; y<=500; y+=50)
            {
                g.drawRect(x,y,size,size);
                g.drawString(String.format("%0d", felder[m][n]), x+10, y+10);
                n++;
            }
            m++;
            n = 0;
        }
    }
    
}

oder mit einem eindimensionalen Array

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int[] felder = new int[100];
    int size = 40;

    public void paint(Graphics g)
    {
        int counter = 0;

        for(int x=50; x<=500; x+=50)
        {
            for(int y=50; y<=500; y+=50)
            {
                felder[counter] = counter;

                g.drawRect(x,y,size,size);
                g.drawString(String.format("%0d", felder[counter]), x+10, y+10);

                counter++;
            }
        }
    }
    
}

das eindimensionale array funktioniert genauso? ist dann nur ein einzelnes großes Array?

Ansonsten probiere ich das zweidimensionale morgen aus, das sieht für mich sinnvoller aus

Danke

Edit: Ich habe mein Programm jetzt mit der counter-Schleife zur Initialisierung ausgestattet. Weiterhin wollte das Programm den drawString-befehl allerdings nicht schlucken, nach einem Kästchen ohne Nummerierung hat es aufgehört. Ich habe mir also was anderes einfallen lassen: Ich zeichne das Quadrat und danach kommt eine if-else-bedingung, die abfragt, wie hoch die nummer des Arrays ist. Wenn sie unter 10 ist, wird beim drawString-Befehl eine 0 vor den Array-Wert geschrieben, ist sie über 10, dann nicht. Jetzt läuft das Programm durch, man kann für einen Bruchteil einer Sekunde sehen, dass 100 Felder inkl. Nummern ausgegeben werden, und danach ist auf einmal nur noch 1 Kästchen da ohne Nummerierung... Das Programm funktioniert nun also, es stoppt aber nicht nach dem 100. Feld.

Kannst du mir sagen, woran das liegt, tigger?

Hier noch der momentane Code:

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int m,n;
    int[][] felder = new int[10][10];
    int size = 40;
    int counter;

    public void paint(Graphics g)
    {
        for(int i=0; i < 10; i++)
        {
            for(int j=0; j < 10; j++)
            {
                felder[i][j] = counter++;
            }
        }
        
        for(int x=50; x<=500; x+=50)
        {
            for(int y=50; y<=500; y+=50)
            {
                g.drawRect(x,y,size,size);
                if(felder[m][n] < 10)
                {
                    g.drawString("0" + String.valueOf(felder[m][n]), x+10, y+10);
                }
                else
                {
                    g.drawString(String.valueOf(felder[m][n]), x+10, y+10);
                }
                n++;
            }
            m++;
            n = 0;
        }
    }
    
}

Grüße!

 

[tigger]

In unserer BlueJ-Umgebung werden Variablen ohne Angabe automatisch 0 zugeordnet, eine Initialisierung muss ich also nicht zwangsläufig vornehmen

ok, dann war die Initialisierung nicht nötig, aber ein zweidimensionales Array mit den Größen [0][0] machte wenig Sinn

das eindimensionale array funktioniert genauso? ist dann nur ein einzelnes großes Array?

klar funktioniert das genauso

brauchst das zweidimensionale nur, wenn du auch zweidimensionale Daten abbilden willst, z.B. zweidimensionale Koordinaten

wie du schon sagst, ist dann in dem Fall nur ein großes Array und der Zugriff erfolgt eben über das Hochzählen einer Index-Variablen counter, die gleichzeitig den eigentlichen Wert des jeweiligen Feldes im Array vorgibt.

g.drawString(String.format("%0d", felder[m][n]), x+10, y+10);

Was bringt der "%0d" befehl? habe den gegoogelt und nix ordentliches gefunden....

um deine Zahlen, die im Array als 0, 1, 2 ... 99 stehen mit führender Null als String auszugeben, wenn die Zahl keine 2 Stellen ausfüllt, also Zahlen ab 10 werden auch als 10 ausgegeben, nicht als 010

die Antwort steht doch genau eine Zeile untendrunter, dieser Format Befehl erspart dir das lästige Erkennen und Beheben der führenden Null

Edit: Ich habe mein Programm jetzt mit der counter-Schleife zur Initialisierung ausgestattet. Weiterhin wollte das Programm den drawString-befehl allerdings nicht schlucken, nach einem Kästchen ohne Nummerierung hat es aufgehört. Ich habe mir also was anderes einfallen lassen: Ich zeichne das Quadrat und danach kommt eine if-else-bedingung, die abfragt, wie hoch die nummer des Arrays ist. Wenn sie unter 10 ist, wird beim drawString-Befehl eine 0 vor den Array-Wert geschrieben, ist sie über 10, dann nicht. Jetzt läuft das Programm durch, man kann für einen Bruchteil einer Sekunde sehen, dass 100 Felder inkl. Nummern ausgegeben werden, und danach ist auf einmal nur noch 1 Kästchen da ohne Nummerierung... Das Programm funktioniert nun also, es stoppt aber nicht nach dem 100. Feld.

dein Code stoppt bestimmt nach dem 100. Durchlauf, und da dein Array sinnvoll gefüllt wird, sollte es auch nicht an dem drawString Befehl liegen

ich würde momentan eher behaupten, dass deine Paint Methode entweder zu wenig oder zu häufig aufgerufen wird.

Konnte auf die Schnelle leider nichts finden, ob sich paint bei mehrfachem Zeichnen selbst unterbrechen kann und wieder von vorne anfängt, dann wäre es klar, warum du über das erste Kästchen nicht hinaus kommst.

Das geschieht, wenn das Formular durch das 1. Zeichnen des Kästchens das Signal bekommt, dass sich die Zeichenfläche geändert hat und dann wieder paint aufruft, bin mir aber wie gesagt nicht ganz sicher

die eigentliche paint Routine soll so klein wie möglich gehalten werden, also probier es mal so

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int m,n;
    int[][] felder = new int[10][10];
    int size = 40;
    int counter;

    // init() wird vom System beim Initialisieren aufgerufen, wird ja
    // nur einmal gebraucht
    public void init()
    {
        for(int i=0; i < 10; i++)
        {
            for(int j=0; j < 10; j++)
            {
                felder[i][j] = counter++;
            }
        }
    }

    // run() wird vom System beim Start des Applets aufgerufen
    public void run()
    {
         // Endlosschleife
         while (true) 
         {
             // neues Zeichnen nach 3 Sekunden = 3000 Millisekunden anfordern
             repaint(3000);
         }
     }

    public void paint(Graphics g)
    {
        for(int x=50; x<=500; x+=50)
        {
            for(int y=50; y<=500; y+=50)
            {
                g.drawRect(x,y,size,size);
                g.drawString(String.format("%0d", felder[m][n]), x+10, y+10);
                n++;
            }
            m++;
            n = 0;
        }
    }
    
}

damit sollte dein Applet dann im 3 Sekundentakt neu gezeichnet werden

 

[.:| chuky |:.]

Hey,

dein letzter Code funktioniert bei mir wieder nicht. 1 Kästchen, mehr kommt nicht!

Ich habe noch ein wenig rumprobiert (und deine Idee der init-Methode übernommen), und nun läuft es. Bzw. im Webbrowser lief es auch vorher schon, nur nicht, wenn man es dazu gebracht hat, sich zu aktualisieren (hätte also eine stop-Methode einbauen können dafür). Der bei BlueJ eingebaute applet-viewer hat das applet also immer automatisch neu gestartet, und dann konnte es ja nicht funktionieren, da x bzw. y schon so hoch waren, dass die Schleifen nicht durchlaufen! Am ende der paint-Methode habe ich nun einfach alle Laufvariablen m, n, x und y auf 0 gesetzt. Somit wird dasselbe ausgegeben, wenn das applet sich aktualisiert!

So sieht der Code nun aus:

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int m, n;
    int y, x;
    int[][] felder = new int[10][10];
    int size = 40;
    int counter;
    
    public void init()
    {
        for(int i=0; i < 10; i++)
        {
            for(int j=0; j < 10; j++)
            {
                felder[i][j] = counter++;
            }
        }
    }


    public void paint(Graphics g)
    {       
        for(y=50; y<=500; y+=50)
        {
            for(x=50; x<=500; x+=50)
            {
                g.drawRect(x,y,size,size);
                if(felder[m][n] < 10)
                {
                    g.drawString("0" + String.valueOf(felder[m][n]), x+15, y+25);
                }
                else
                {
                    g.drawString(String.valueOf(felder[m][n]), x+15, y+25);
                }
                n++;
            }
            m++;
            n = 0;
        }
        y=0;
        x=0;
        m=0;
        n=0;
    }
    
}

und so sieht das Applet dann auf dem Bildschirm aus:

Vielen vielen Dank für deine Hilfe tigger, auch wenn ich mein Programm weitestgehend nach meinem Kopf und Können programmiert habe, hast du mir mit deinen Ideen doch dazu verholfen, das Applet auf die Reihe zu kriegen!

 

[tigger]

Ich habe noch ein wenig rumprobiert (und deine Idee der init-Methode übernommen), und nun läuft es. Bzw. im Webbrowser lief es auch vorher schon, nur nicht, wenn man es dazu gebracht hat, sich zu aktualisieren (hätte also eine stop-Methode einbauen können dafür). Der bei BlueJ eingebaute applet-viewer hat das applet also immer automatisch neu gestartet, und dann konnte es ja nicht funktionieren, da x bzw. y schon so hoch waren, dass die Schleifen nicht durchlaufen! Am ende der paint-Methode habe ich nun einfach alle Laufvariablen m, n, x und y auf 0 gesetzt. Somit wird dasselbe ausgegeben, wenn das applet sich aktualisiert!

wetten wir um einen virtuellen Keks, dass der Fehler mit einer Zuweisung von m = 0 vor dem Zeichnen gegessen ist ?

oder alternativ da, wo es jetzt steht, als einzige Zuweisung. Der Rest tut zwar nicht weh, aber wird eh wieder überschrieben. x und y kannst du auch wieder innerhalb der for Schleifen definieren

der Fehler ist mehr als dämlich, die Variable m als Klassenvariable behält nach dem ersten Paint-Durchlauf den Index 10, auf den beim 2. Zeichnen versucht wird zuzugreifen

das Zeichnen des Kästchens geht noch gut, aber beim Versuch auf Index 10 des Arrays zuzugreifen knallt es ganz häßlich ^^

Vielen vielen Dank für deine Hilfe tigger, auch wenn ich mein Programm weitestgehend nach meinem Kopf und Können programmiert habe, hast du mir mit deinen Ideen doch dazu verholfen, das Applet auf die Reihe zu kriegen!

gern geschehen

abschließend darf ich dir noch beichten, dass ich keine eine Zeile davon jemals durch nen Compiler gejagt hab, um es mal selber zu testen

 

[.:| chuky |:.]

Der Keks geht an dich, hast recht. habe das jetzt auch so geändert Ich habe auch nur alle Variablen dahin geschrieben, weil ich keine Lust mehr auf forschen hatte (das n am ende 0 ist ist ja ganz logisch durch die letzte Aktion und das y und x durchlaufen und am start wieder 50 sind ist auch klar, weil sie in der schleife ja so deklariert werden!)

Ja, das ich ne Variable nehme, die bei Neustart nicht wieder auf 0 gesetzt ist ist schon blöd

Das brauchst du nicht beichten, ich bin fest davon ausgegangen, dass du es nie durch den Compiler gejagt hast, denn wenn du die gleichen Probleme gehabt hättest wie ich (zB dass nur 1 Kästchen kommt) dann hättest du mir ja nicht gesagt, das funktioniert

So abschließend nochmal mein weitestgehend optimierter Code für alle, die mitlesen und interessiert dran sind:

import java.applet.*;
import java.awt.*;

public class Nr9 extends Applet
{
    int[][] felder = new int[10][10];
    int size = 40;
    int counter;
    
    public void init()
    {
        for(int i=0; i < 10; i++)
        {
            for(int j=0; j < 10; j++)
            {
                felder[i][j] = counter++;
            }
        }
    }


    public void paint(Graphics g)
    {  
        int m = 0;
        int n = 0;
        for(int y=50; y<=500; y+=50)
        {
            for(int x=50; x<=500; x+=50)
            {
                g.drawRect(x,y,size,size);
                if(felder[m][n] < 10)
                {
                    g.drawString("0" + String.valueOf(felder[m][n]), x+15, y+25);
                }
                else
                {
                    g.drawString(String.valueOf(felder[m][n]), x+15, y+25);
                }
                n++;
            }
            m++;
            n = 0;
        }
    }
    
}

(habe m und n nur deshalb zusammen in der paint-Methode deklariert, weil sie ja eine gemeinsame Funktion haben, und m erst da zu erstellen ist sinnvoller als vorher und dann da immer auf 0 zu setzen)

 

[bawder]

hast du in dem code auch irgendwo eine main methode?

 

[.:| chuky |:.]

Nein! die braucht ein applet nicht unbedingt

 

[tigger]

ok, dann passt es ja jetzt

Das brauchst du nicht beichten, ich bin fest davon ausgegangen, dass du es nie durch den Compiler gejagt hast, denn wenn du die gleichen Probleme gehabt hättest wie ich (zB dass nur 1 Kästchen kommt) dann hättest du mir ja nicht gesagt, das funktioniert

ja, da hast du Recht

manchmal muss es aber auch einfach nochmal kurz liegen gelassen werden, dass man danach wieder mit anderen Augen dran geht

hast du in dem code auch irgendwo eine main methode?

so wie ich das auf die Schnelle gesehen habe, hat ein Applet normalerweise eine run-Methode, in der das Applet mit einer while(true) Schleife künstlich am Leben gehalten wird, damit ist es dann so ähnlich wie die Main Methode einer normalen Klasse, die ja auch so lange "lebt", bis die Instanz der Klasse gelöscht wird

 

[.:| chuky |:.]

@ tigger: mit der run-methode hast du wohl recht die muss aber zum glück auch nicht geschrieben werden, sondern wird automatisch von der umgebung erstellt