Programmablauf < Java < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 23:57 Fr 05.10.2007 | | Autor: | Herby |
Hallo,
ich habe hier ein paar Verständnisprobleme:
Der Code lautet:
| 1: |
| | 2: | public class SprungTest {
| | 3: |
| | 4: | /**
| | 5: | * @param args
| | 6: | */
| | 7: | public static void main(String[] args) {
| | 8: | Hauptschleife:
| | 9: | for (int i = 1; i < 10; i++) {
| | 10: | for (int j = 1; j < 10; j++) {
| | 11: | System.out.print(j + " ");
| | 12: | if (j == i) {
| | 13: | System.out.println();
| | 14: | continue Hauptschleife;
| | 15: | }
| | 16: | }
| | 17: | }
| | 18: | }
| | 19: |
| | 20: | }
| | 21: |
|
und die Ausgabe ist dementsprechend:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9
Was passiert hier ![[kopfkratz3]](/images/smileys/kopfkratz3.gif "[kopfkratz3]")
Es wird das das Programm (ist das der richtige Ausdruck?) gestartet.
Der,die,das ??? läuft in die erste for-Schleife.
Wie geht es nun weiter?
Die Bedingung ist "true" - also wird i inkrementiert - und dann?
Wodurch entsteht die erste 1 als Ausgabe?
Was ist der Unterschied zwischen print() und println()?
Wieso steht bei println() nichts in der Klammer?
Thx for answering questions
Liebe Grüße
Herby
blödes Programmierkramklamauk
|
|
| |
|
| Status: |
(Antwort) fertig  | | Datum: | 01:01 Sa 06.10.2007 | | Autor: | rainerS |
Hallo Herby,
> Hallo,
>
> ich habe hier ein paar Verständnisprobleme:
>
> Der Code lautet:
>
> | 1: |
| | 2: | > public class SprungTest {
| | 3: | >
| | 4: | > /**
| | 5: | > * @param args
| | 6: | > */
| | 7: | > public static void main(String[] args) {
| | 8: | > Hauptschleife:
| | 9: | > for (int i = 1; i < 10; i++) {
| | 10: | > for (int j = 1; j < 10; j++) {
| | 11: | > System.out.print(j + " ");
| | 12: | > if (j == i) {
| | 13: | > System.out.println();
| | 14: | > continue Hauptschleife;
| | 15: | > }
| | 16: | > }
| | 17: | > }
| | 18: | > }
| | 19: | >
| | 20: | > }
| | 21: | >
| | 22: | > |
>
> und die Ausgabe ist dementsprechend:
>
> 1
> 1 2
> 1 2 3
> 1 2 3 4
> 1 2 3 4 5
> 1 2 3 4 5 6
> 1 2 3 4 5 6 7
> 1 2 3 4 5 6 7 8
> 1 2 3 4 5 6 7 8 9
>
>
> Was passiert hier
>
> Es wird das das Programm (ist das der richtige Ausdruck?)
> gestartet.
> Der,die,das ??? läuft in die erste for-Schleife.
>
> Wie geht es nun weiter?
>
> Die Bedingung ist "true" - also wird i inkrementiert - und
> dann?
Nein. Die For-Schleife hat die Form:
for(init; cond; iter)
1. Die Anweisung "init" wird nur zu Beginn ausgeführt.
2. Die Bedingung "cond" wird am Anfang jedes Schleifendurchlaufs geprüft. Ist sie false, wird die Schleife sofort (nach unten) verlassen.
3. Die Anweisung "iter" wird am Ende jedes Schleifendurchlaufs, unmittelbar vor dem nächsten Durchlauf ausgeführt.
> Wodurch entsteht die erste 1 als Ausgabe?
Zunächst wird die äußere for-Schleife betreten, i wird der Wert 1 zugeweisen und die Bedingung i<10 geprüft.
Dann wird die innere for-Schleife betreten, j wird der Wert 1 zugeweisen und die Bedingung j<10 geprüft.
Der String j+" " besteht dann aus zwei Zeichen: der 1 und einem Leerzeichen und wird ausgegeben.
> Was ist der Unterschied zwischen print() und println()?
println erzeugt zusätzlich einen Zeilenvorschub, nachdem es seinen Parameter ausgegeben hat.
> Wieso steht bei println() nichts in der Klammer?
Das ist eine Variante ohne Parameter, die nur einen Zeilenvorschub ausgibt.
Die Anweisung "continue Hauptschleife" bedeutet, dass an dieser Stelle der aktuelle Durchlauf der äußeren Schleife (markiert durch "Hauptschleife") beendet wird, das heisst, die innere Schleife wird beendet, es wird i um 1 hochgezählt, die Bedingung i<10 geprüft und, falls true, der nächste Schleifendurchlauf gestartet.
Viele Grüße
Rainer
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 13:48 Sa 06.10.2007 | | Autor: | Herby |
Hallo Rainer,
danke schön für deine Erklärungen.....
..... es geht aber noch ein bisschen weiter 
> >
> > | 1: |
| | 2: | > > public class SprungTest {
| | 3: | > >
| | 4: | > > /**
| | 5: | > > * @param args
| | 6: | > > */
| | 7: | > > public static void main(String[] args) {
| | 8: | > > Hauptschleife:
| | 9: | > > for (int i = 1; i < 10; i++) {
| | 10: | > > for (int j = 1; j < 10; j++) {
| | 11: | > > System.out.print(j + " ");
| | 12: | > > if (j == i) {
| | 13: | > > System.out.println();
| | 14: | > > continue Hauptschleife;
| | 15: | > > }
| | 16: | > > }
| | 17: | > > }
| | 18: | > > }
| | 19: | > >
| | 20: | > > }
| | 21: | > >
| | 22: | > > |
> >
> > und die Ausgabe ist dementsprechend:
> >
> > 1
> > 1 2
> > 1 2 3
> > 1 2 3 4
> > 1 2 3 4 5
> > 1 2 3 4 5 6
> > 1 2 3 4 5 6 7
> > 1 2 3 4 5 6 7 8
> > 1 2 3 4 5 6 7 8 9
> >
> >
> > Was passiert hier
> >
> > Es wird das das Programm (ist das der richtige Ausdruck?)
> > gestartet.
> > Der,die,das ??? läuft in die erste for-Schleife.
> >
> > Wie geht es nun weiter?
> >
> > Die Bedingung ist "true" - also wird i inkrementiert - und
> > dann?
>
> Nein. Die For-Schleife hat die Form:
>
> for(init; cond; iter)
>
> 1. Die Anweisung "init" wird nur zu Beginn ausgeführt.
> 2. Die Bedingung "cond" wird am Anfang jedes
> Schleifendurchlaufs geprüft. Ist sie false, wird die
> Schleife sofort (nach unten) verlassen.
Wohin nach unten, an welche Stelle?
> 3. Die Anweisung "iter" wird am Ende jedes
> Schleifendurchlaufs, unmittelbar vor dem nächsten Durchlauf
> ausgeführt.
wann ist der der Durchlauf der äußeren Schleife beendet?
Vor Eintritt in die innere Schleife oder vor oder nach der if-Anweisung?
> > Wodurch entsteht die erste 1 als Ausgabe?
>
> Zunächst wird die äußere for-Schleife betreten, i wird der
> Wert 1 zugeweisen und die Bedingung i<10 geprüft.
> Dann wird die innere for-Schleife betreten, j wird der
> Wert 1 zugeweisen und die Bedingung j<10 geprüft.
> Der String j+" " besteht dann aus zwei Zeichen: der 1 und
> einem Leerzeichen und wird ausgegeben.
Und was hat das nun mit dem i auf sich? Warum diese if-Anweisung?
> > Was ist der Unterschied zwischen print() und println()?
>
> println erzeugt zusätzlich einen Zeilenvorschub, nachdem es
> seinen Parameter ausgegeben hat.
>
> > Wieso steht bei println() nichts in der Klammer?
>
> Das ist eine Variante ohne Parameter, die nur einen
> Zeilenvorschub ausgibt.
>
> Die Anweisung "continue Hauptschleife" bedeutet, dass an
> dieser Stelle der aktuelle Durchlauf der äußeren Schleife
> (markiert durch "Hauptschleife") beendet wird, das heisst,
> die innere Schleife wird beendet, es wird i um 1
> hochgezählt, die Bedingung i<10 geprüft und, falls true,
> der nächste Schleifendurchlauf gestartet.
Ok, dann stellt sich mir noch die Preisfrage, warum in Zeile 2 dann nicht nur eine 2 auftaucht, sondern eine 1 und eine 2 - sowie danach eine 1 und eine 2 und eine 3....
Liebe Grüße
Herby
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 14:07 Sa 06.10.2007 | | Autor: | Infinit |
Hallo Herby,
ich schreibe meine Antworten an die entsprechenden Stellen Deines Postings.
Viele Grüße,
Infinit
> Hallo Rainer,
>
>
> danke schön für deine Erklärungen.....
>
> ..... es geht aber noch ein bisschen weiter
>
> > >
> > > | 1: |
| | 2: | > > > public class SprungTest {
| | 3: | > > >
| | 4: | > > > /**
| | 5: | > > > * @param args
| | 6: | > > > */
| | 7: | > > > public static void main(String[] args) {
| | 8: | > > > Hauptschleife:
| | 9: | > > > for (int i = 1; i < 10; i++) {
| | 10: | > > > for (int j = 1; j < 10; j++) {
| | 11: | > > > System.out.print(j + " ");
| | 12: | > > > if (j == i) {
| | 13: | > > > System.out.println();
| | 14: | > > > continue Hauptschleife;
| | 15: | > > > }
| | 16: | > > > }
| | 17: | > > > }
| | 18: | > > > }
| | 19: | > > >
| | 20: | > > > }
| | 21: | > > >
| | 22: | > > > |
> > >
> > > und die Ausgabe ist dementsprechend:
> > >
> > > 1
> > > 1 2
> > > 1 2 3
> > > 1 2 3 4
> > > 1 2 3 4 5
> > > 1 2 3 4 5 6
> > > 1 2 3 4 5 6 7
> > > 1 2 3 4 5 6 7 8
> > > 1 2 3 4 5 6 7 8 9
> > >
> > >
> > > Was passiert hier
> > >
> > > Es wird das das Programm (ist das der richtige Ausdruck?)
> > > gestartet.
> > > Der,die,das ??? läuft in die erste for-Schleife.
> > >
> > > Wie geht es nun weiter?
> > >
> > > Die Bedingung ist "true" - also wird i inkrementiert - und
> > > dann?
> >
> > Nein. Die For-Schleife hat die Form:
> >
> > for(init; cond; iter)
> >
> > 1. Die Anweisung "init" wird nur zu Beginn ausgeführt.
> > 2. Die Bedingung "cond" wird am Anfang jedes
> > Schleifendurchlaufs geprüft. Ist sie false, wird die
> > Schleife sofort (nach unten) verlassen.
>
> Wohin nach unten, an welche Stelle?
Gemeint ist hier der Ausführungsteil, der der gerade eben verlassenen Schleife folgt
>
> > 3. Die Anweisung "iter" wird am Ende jedes
> > Schleifendurchlaufs, unmittelbar vor dem nächsten Durchlauf
> > ausgeführt.
>
> wann ist der der Durchlauf der äußeren Schleife beendet?
> Vor Eintritt in die innere Schleife oder vor oder nach der
> if-Anweisung?
Beide Schleifen sind ineinander verschachtelt, die innere Schleige wird abgearbeitet bis zur Abbruch-Bedingung durch die if-Abfrage, danach beginnt das gleiche Spiel mit einem um 1 erhöhten j-Wert.
>
> > > Wodurch entsteht die erste 1 als Ausgabe?
> >
> > Zunächst wird die äußere for-Schleife betreten, i wird der
> > Wert 1 zugeweisen und die Bedingung i<10 geprüft.
> > Dann wird die innere for-Schleife betreten, j wird der
> > Wert 1 zugeweisen und die Bedingung j<10 geprüft.
> > Der String j+" " besteht dann aus zwei Zeichen: der 1
> und
> > einem Leerzeichen und wird ausgegeben.
>
> Und was hat das nun mit dem i auf sich? Warum diese
> if-Anweisung?
Um die Schleife verlassen zu können, erfolgt die if-Abfrage.
> > > Was ist der Unterschied zwischen print() und println()?
> >
> > println erzeugt zusätzlich einen Zeilenvorschub, nachdem es
> > seinen Parameter ausgegeben hat.
> >
> > > Wieso steht bei println() nichts in der Klammer?
> >
> > Das ist eine Variante ohne Parameter, die nur einen
> > Zeilenvorschub ausgibt.
> >
> > Die Anweisung "continue Hauptschleife" bedeutet, dass an
> > dieser Stelle der aktuelle Durchlauf der äußeren Schleife
> > (markiert durch "Hauptschleife") beendet wird, das heisst,
> > die innere Schleife wird beendet, es wird i um 1
> > hochgezählt, die Bedingung i<10 geprüft und, falls true,
> > der nächste Schleifendurchlauf gestartet.
>
> Ok, dann stellt sich mir noch die Preisfrage, warum in
> Zeile 2 dann nicht nur eine 2 auftaucht, sondern eine 1 und
> eine 2 - sowie danach eine 1 und eine 2 und eine 3....
>
Eben wegen der verschachtelten Schleifen, die Schleife über die Variable j wird immer wieder durchlaufen, aber immer später abgebrochen, da der i-Wert der äußeren Schleife von Durchlauf zu Durchlauf um Eins erhöht wird.
> Liebe Grüße
> Herby
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 15:18 Sa 06.10.2007 | | Autor: | Herby |
Hallo Infinit,
> > > >
> > > > | 1: |
| | 2: | > > > > public class SprungTest {
| | 3: | > > > >
| | 4: | > > > > /**
| | 5: | > > > > * @param args
| | 6: | > > > > */
| | 7: | > > > > public static void main(String[] args) {
| | 8: | > > > > Hauptschleife:
| | 9: | > > > > for (int i = 1; i < 10; i++) {
| | 10: | > > > > for (int j = 1; j < 10; j++) {
| | 11: | > > > > System.out.print(j + " ");
| | 12: | > > > > if (j == i) {
| | 13: | > > > > System.out.println();
| | 14: | > > > > continue Hauptschleife;
| | 15: | > > > > }
| | 16: | > > > > }
| | 17: | > > > > }
| | 18: | > > > > }
| | 19: | > > > >
| | 20: | > > > > }
| | 21: | > > > >
| | 22: | > > > > |
> > > >
> > > > und die Ausgabe ist dementsprechend:
> > > >
> > > > 1
> > > > 1 2
> > > > 1 2 3
> > > > 1 2 3 4
> > > > 1 2 3 4 5
> > > > 1 2 3 4 5 6
> > > > 1 2 3 4 5 6 7
> > > > 1 2 3 4 5 6 7 8
> > > > 1 2 3 4 5 6 7 8 9
> > > >
> > >
> > > 1. Die Anweisung "init" wird nur zu Beginn ausgeführt.
> > > 2. Die Bedingung "cond" wird am Anfang jedes
> > > Schleifendurchlaufs geprüft. Ist sie false, wird die
> > > Schleife sofort (nach unten) verlassen.
> >
> > Wohin nach unten, an welche Stelle?
>
> Gemeint ist hier der Ausführungsteil, der der gerade eben
> verlassenen Schleife folgt
also vor "System.out.println();"?
> >
> > > 3. Die Anweisung "iter" wird am Ende jedes
> > > Schleifendurchlaufs, unmittelbar vor dem nächsten Durchlauf
> > > ausgeführt.
> >
> > wann ist der der Durchlauf der äußeren Schleife beendet?
> > Vor Eintritt in die innere Schleife oder vor oder nach
> der
> > if-Anweisung?
>
> Beide Schleifen sind ineinander verschachtelt, die innere
> Schleife wird abgearbeitet bis zur Abbruch-Bedingung durch
> die if-Abfrage, danach beginnt das gleiche Spiel mit einem
> um 1 erhöhten j-Wert.
d.h. i wird nach der if-Abfrage inkrementiert?
> >
> > Und was hat das nun mit dem i auf sich? Warum diese
> > if-Anweisung?
> Um die Schleife verlassen zu können, erfolgt die
> if-Abfrage.
ok 
> >
> > Ok, dann stellt sich mir noch die Preisfrage, warum in
> > Zeile 2 dann nicht nur eine 2 auftaucht, sondern eine 1 und
> > eine 2 - sowie danach eine 1 und eine 2 und eine 3....
> >
>
> Eben wegen der verschachtelten Schleifen, die Schleife über
> die Variable j wird immer wieder durchlaufen, aber immer
> später abgebrochen, da der i-Wert der äußeren Schleife von
> Durchlauf zu Durchlauf um Eins erhöht wird.
Mist, ich dachte gerade ich hätte es kapiert, aber dann spielte ich ein bisschen im Programm rum und es kam eine neue Frage auf:
![[guckstduhier]](/images/smileys/guckstduhier.gif "[guckstduhier]") Variation
Vielen Dank Infinit
lg
Herby
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 15:58 Sa 06.10.2007 | | Autor: | Infinit |
Hallo Herby,
ich probiere mal aus, die Wirkungsbereiche der unterschiedlichen Schleifen in Deinem Programm farblich zu markieren, dann sollte, so hoffe ich zumindest, klarer sein, wo was anfängt und wo was aufhört. Drück mir mal die Daumen, das das hinhaut.
Hier kommt das Programm:
1:
2: > > > > public class SprungTest {
3: > > > >
4: > > > > /**
5: > > > > * @param args
6: > > > > */
7: > > > > public static void main(String[] args) {
8: > > > > Hauptschleife:
9: > > > > for (int i = 1; i < 10; i++) {
10: > > > > for (int j = 1; j < 10; j++) {
11: > > > > System.out.print(j + " ");
12: > > > > if (j == i) {
13: > > > > System.out.println();
14: > > > > continue Hauptschleife;
15: > > > > }
16: > > > > }
17: > > > > }
18: > > > > }
19: > > > >
20: > > > > }
21: > > > >
22: > > > >
Die innere Schleife mit der Zählvariablen j geht von Zeile 10 bis 16, die äußere Schleife mit der Zählvariablen i schließt die innere Schleife mit ein und geht von Zeile 9 bis Zeile 17. Wenn die innere if-Anweisung "true" ist, also bei i=j, hüpft die Verarbeitung von der inneren in die äußere Schleife. Beim Verlassen der inneren Schleife hüpft das Programm in die Zeile 17, findet dort den Abschluß der äußeren Schleife und beginnt einen neuen äußeren Schleifendurchlauf, das i wird inkrementiert.
Ich hoffe, die Farbe hilft etwas beim Verstehen.
Viele Grüße,
Infinit
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 22:16 Sa 06.10.2007 | | Autor: | Herby |
Hallo Infinit,
vielen Dank für deine Erklärungen, diesen Part hab ich nun
Liebe Grüße
Herby
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 15:06 Sa 06.10.2007 | | Autor: | Herby |
Hallo,
ich habe das Programm etwas abgeändert
Der Code lautet:
| 1: |
| | 2: |
| | 3: | public class SprungTest {
| | 4: |
| | 5: | /**
| | 6: | * @param args
| | 7: | */
| | 8: | public static void main(String[] args) {
| | 9: | Hauptschleife:
| | 10: | for (int i = 1; i < 16; i++){
| | 11: | for (int j = 1; j < 13; j++){
| | 12: | System.out.print(j + " ");
| | 13: | if (j == i){
| | 14: | System.out.println();
| | 15: | continue Hauptschleife;
| | 16: | }
| | 17: | }
| | 18: | }
| | 19: | }
| | 20: |
| | 21: | }
|
und die Ausgabe ist
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10 11
1 2 3 4 5 6 7 8 9 10 11 12
1 2 3 4 5 6 7 8 9 10 11 12 13
1 2 3 4 5 6 7 8 9 10 11 12 13 1 2 3 4 5 6 7 8 9 10 11 12 13 1 2 3 4 5 6 7 8 9 10 11 12 13
ich hätte nun erwartet, dass die Ausgabe folgendermaßen aussieht
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10 11
1 2 3 4 5 6 7 8 9 10 11 12
1 2 3 4 5 6 7 8 9 10 11 12 13
1 2 3 4 5 6 7 8 9 10 11 12 13
1 2 3 4 5 6 7 8 9 10 11 12 13
1 2 3 4 5 6 7 8 9 10 11 12 13
warum wird in der letzten Zeile alles hintereinander geschrieben?
Liebe Grüße
Herby
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 15:35 Sa 06.10.2007 | | Autor: | rainerS |
Hallo Herby,
> warum wird in der letzten Zeile alles hintereinander
> geschrieben?
Weil für i>13 die innere Schleife immer nur bis 13 geht, und daher dann i=j false ist. Damit wird auch kein Zeilenvorschub ausgegeben.
Viele Grüße
Rainer
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 22:45 Sa 06.10.2007 | | Autor: | Herby |
Hallo,
ich weiß nun, was ich da machen muss
lg
Herby
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 22:47 Sa 06.10.2007 | | Autor: | Herby |
Hi Rainer,
> Hallo Herby,
>
> > warum wird in der letzten Zeile alles hintereinander
> > geschrieben?
>
> Weil für i>13 die innere Schleife immer nur bis 13 geht,
> und daher dann i=j false ist. Damit wird auch kein
> Zeilenvorschub ausgegeben.
>
> Viele Grüße
> Rainer
damit ist nun alles klar - danke schön ![[hut]](/images/smileys/hut.gif "[hut]")
Liebe Grüße
Herby
|
|
|
|
![[bonk]](/images/smileys/bonk.gif "[bonk]"){kind=small}
![[haee]](/images/smileys/haee.gif "[haee]"){kind=small}
