Kurze Frage zum Ergebniss

[Schocksen]

public class MischMasch4 {
int zähler = 0;
public static void main(String[] args){
int anzahl = 0;
MischMasch4[] m4a = new MischMasch4[20];
int x = 0;

while(x<10){

m4a[x] = new MischMasch4();
m4a[x].zähler = m4a[x].zähler + 1;
anzahl = anzahl + 1;
anzahl = anzahl + m4a[x].vielleichtNeu(x);
x = x + 1;
}
System.out.println(anzahl + " " + m4a[4].zähler);
}


public int vielleichtNeu(int index) {
if (index < 5){
MischMasch4 m4 = new MischMasch4();
m4.zähler =m4.zähler + 2;
return 1;
}
return 0;
}

}

Ausgabe = 15 1

So jetzt zu meiner Frage. Wie ich auf das Ergebniss von anzahl komme, also 15 ist mir nach längerer Überlegung klar geworden.
Allerdings versteh ich das Ergebniss von m4a[x].zähler nicht.
Nach meiner Überlegung läuft die while Schleife ja 10mal durch, erstellt dabei jedesmal ein neues MischMasch4 Objekt in dem array m4a an der Stelle von x.(grün markiert)
Dann setzt er an jeder m4a[x] den Zähler und zählt jedesmal +1 auf den Zähler dazu.(rot markiert).
Ausgeben will er die 5.Stelle im Array (m4a[4].zähler) welche ja dann im 5. Durchlauf eigentlich 5 sein müsste?

Ich glaub ich bin hier ziemlich auf dem Holzweg, aber da ich noch totaler Java Anfänger bin komm ich momentan einfach nicht weiter, war schon super stolz auf mich dass ich anzahl gelöst habe aber die 2.Ausgabe bringt mich zum verzweifeln.
Kann mir da wer erklären wieso ich auf 1 komme, und falls meine vorherigen Überlegungen mit Objekten ins Array und +1 aufzählen und sowas falsch sind vlt. korrigieren kann.

 

[SlaterB]

> Dann setzt er an jeder m4a[x] den Zähler und zählt jedesmal +1 auf den Zähler dazu.(rot markiert).
> Ausgeben will er die 5.Stelle im Array (m4a[4].zähler) welche ja dann im 5. Durchlauf eigentlich 5 sein müsste?

ich verstehe deine Erklärungen nicht soweit, dass ich sie korrigieren könnte

jedes neue Objekt hat anfangs einen Zähler-Wert von 0, für alle Objekte wird der Zähler um 1 erhöht, 0+1 ist immer 1,
daher ist die Ausgabe 1 doch ganz normal

die zähler sind nicht von x abhängig und auch nicht miteinander verknüpft (etwa zähler des vorherigen Objektes +1)

 

[Schocksen]

naja also ich war der annahme das dem zähler bei jedenm Durchlauf +1 dazugerechnet wird.
Also wäre der Zähler nach dem ersten Durchlauf 1, nach dem zweiten Durchlauf 2, nach dem dritten 3 usw.
Und in das Objekt wird halt jedesmal der aktuelle Zähler rein gesetzt.

Dann ist also meine Frage wieso der Zähler nach jedem Durchlauf obwohl eins dazu gezählt wird trotzdem 0 ist.

 

[SlaterB]

> Dann ist also meine Frage wieso der Zähler nach jedem Durchlauf obwohl eins dazu gezählt wird trotzdem 0 ist.

hmm, die Ausgabe spricht von 1, zumindest für den Zähler vom 4. Objekt,
ich behaupte, dass alle Zähler auf 1 stehen,
wieso sagst du dann 'trotzdem 0'?

> Also wäre der Zähler nach dem ersten Durchlauf 1, nach dem zweiten Durchlauf 2, nach dem dritten 3 usw.

doch nicht 0?!

wenn ein neues Objekt erzeugt wird, ist dessen Anfangszustand von int-Variablen immer 0, fallst du das meinst

 

[Schandro]

Gehen wir mal von diesem Code aus:

public class MischMasch4 {

	int zähler = 0;

	public static void main(String[] args) {
		MischMasch4[] m4a = new MischMasch4[20];
		
		int x = 0;
		while (x < 10) {
			m4a[x] = new MischMasch4();
			m4a[x].zähler = m4a[x].zähler + 1;
			
			x = x + 1;
		}
		
		System.out.println(m4a[4].zähler);
	}
}

Ich hab einfach nur die Methode vielleichtNeu rausgekürzt, die ist zZ. egal


In diesem Code werden insgesamt 10 Objecte von der Klasse MischMasch4 erstellt. Jedes einzelne dieser Objecte hat einmal die Variable zähler. Das heisst es gibt den int zähler insgesamt 10 mal.

Wenn du nun innerhalb der Schleife schreibst:

m4a[x].zähler = m4a[x].zähler + 1;

Dann wird die zähler Variable des x'sten Objectes um eins erhöht. Der anfangswert ist 0, deswegen ist sie nach dem Aufruf 1.

Wenn jedes Object den zähler seines Vorgängerobjectes+1 haben soll, musst du schreiben:

m4a[x].zähler = m4a[x-1].zähler + 1;

Das Problem daran: Beim allerersten Durchlauf gibt es noch gar kein "Vorgängerobject". Deswegen wird eine ArrayIndexOutOfBoundsException geschmissen.
Deshalb müssen wir eine if-Abfrage einbauen:

if(x>0){
m4a[x].zähler = m4a[x-1].zähler + 1;
}

Jetzt wird der zähler bei allen Objecten weiterhin auf zähler des Vorgängerobjectes+1 gesetzt. AUßER beim ersten Object, da ist x nämlich nicht größer 0. Deshalb bleibt der zähler des ersten Objectes bei 0.


PS: Ich hab ihr überall "Object" geschrieben, weil es einfacher ist. Damit meinte ich natürlich immer nur die 10 Objecte der Klasse MischMasch4 die in dem Array liegen.

 

[Schocksen]

Ok, ich war halt der Annahme dass einfach ein leeres Object erstellt wird und in dieses immer der aktuelle Zähler gesetzt wird welcher sich nach jedem durchlauf +1 hochzählt.

Ich bin gar nicht auf die Idee gekommen dass beim erstellen des Object schon der Zähler( also die int variable mit 0) eingesetzt wird.

Aber jetzt wirds mir klar, der Punktoperator verweist also immer auf den Zähler im object[x], und dieser wird dann immer um 1 erhöht, in dem Fall also von 0 auf 1. Und das bei jedem Objekt.

Ich hatte halt komischerweise den Gedankengang dass einfach der Zähler (den ich ganz am anfang mit 0 deklariert hab) bei jedem Durchlauf der Schleife eins hoch gezählt wird, was aber ja vollkommener quatsch wird, da die variable Zähler ja beim kompletten Durchlauf gar nicht angerührt wird, sondern nur der jeweilige Zähler der sich gerade im object[x] befindet.

Dank euch für die Hilfe, bin wieder ein ganzes Stück weiter gekommen heute.:toll: