Instanzen, Referenzen und Collections

[makkes]

Guten Abend Allerseits !

Eigentlich programmiere ich schon seit fast drei Jahren immer wieder mal mit Java. Im Moment stehe ich aber *völlig* auf dem Schlauch. Ich mache gerade eine Erfahrung, die mein ganzes Weltbild in Sachen OO auf den Kopf stellt. Ich hoffe es ist ein Syntaxfehler. lol.

Folgender Code:

import java.util.ArrayList;

class Test{
	public static void main(String args[]){
		ArrayList<String> name = new ArrayList<String>();
		String fname = "FOO";
		String lname = "BAR";
		name.add(fname);
		name.add(lname);
		fname="JOHN";
		lname="DOE";
		System.out.println(name.get(0)+ " " +name.get(1));
	}
}

erzeugt die Ausgabe:

FOO BAR

sollte aber doch nach aller Theorie - nach der Java grundsätzlich mit Referenzen arbeitet erzeugen:

JOHN DOE

Oder objektorientiert gedacht, ändere ich doch die Stringinstanzen fname und lname, was sich dann auch in der Liste niederschlagen müsste.
In Ruby wäre es so:

name = "FOO"
array = [name]
name = "JOHN"
puts array
==> ["FOO"]

Was sinnvoll ist, da durch name = "JOHN" ein NEUES Objekt (Chararray) an die Variable name gebunden wird.
der Aufruf "JOHN" erzeugt das Chararray. Schreibe ich in Ruby stattdessen:

name = "FOO"
array = [name]
name[0..name.length]=""
name.concat("JOHN")       
puts array
==> ["JOHN"]

Passiert das Erwartete.

name[0..name.length]="" -- >löscht die Zeichen *im bestehenden* Chararray.

name.concat("JOHN") --> hängt an das jetzt leere Chararray die Zeichen JOHN. Intern wird dabei ein neues Array mit dem Inhalt JOHN erzeugt, durch concat werden diese 4 Chars aber wieder ins erste Array gepackt. Sinnvoll also. Etwas undurchsichtig, aber konsequent.

Ich dachte dann ich könnte mal probieren:
anstatt

fname="JOHN";
lname="DOE";

zu schreiben

fname.replace(fname,"JOHN");
lname.replace(lname,"DOE");

das gibt aber auch zurück:

FOO BAR

Verwirrt, durcheinander ? Ich auch !

 

[Templon]

Das liegt daran, dass du einfach die lokalen Referenzen "umbiegst". Dies beinflusst die Referenzen in der Liste nicht. Diese zeigen immer noch auf das erste Objekt. Hier noch ein wenig Code zur veranschaulichung:

[Java]
import java.util.ArrayList;

class Test{
public static void main(String args[]){
ArrayList<MyDataType> list = new ArrayList<MyDataType>();

MyDataType first = new MyDataType(10);
MyDataType second = new MyDataType(15);

list.add(first);
list.add(second);

first.setValue(100);
second.setValue(115);

first = new MyDataType(1000);
second = new MyDataType(1015);

System.out.println(list.get(0)+ " " +list.get(1));

// gibt nicht 1000 1015 aus sondern 100 115
}
}

class MyDataType {
private int value;

public MyDataType(int value) {
super();
this.value = value;
}

public int getValue() {
return value;
}

public void setValue(int value) {
this.value = value;
}

@Override
public String toString() {
return String.valueOf(value);
}
}
[/Java]

[...]
zu schreiben

fname.replace(fname,"JOHN");
lname.replace(lname,"DOE");

Strings sind immutable, du musst folgendes schreiben:

fname = fname.replace(fname,"JOHN");
lname = lname.replace(lname,"DOE");

Das wiederum "biegt" aber wieder nur die lokalen Referenzen um. Also könntest du folgendes machen:

name.set(0, "John");
name.set(1, "Doe");

 

[makkes]

Hm. Ich hätte das so nicht erwartet. Aber nun gut.
Witzigerweise ist mir trotz einiger Projekte die ich in Java schon gemacht habe, dieser Sachverhalt noch nie aufgefallen. Im Regelfall kommen eben eher Konstrukte wie in Deinem Beispiel vor.
Ich wollte jetzt nur eben was testen, und war recht überrascht.

Danke auf jeden Fall !

Was macht eigentlich der super()-Konstruktor in Deinem Bsp? Den Object-Konstruktor aufrufen?

 

[Marco13]

Hm ... Strings sind da aber schon Sonderfälle... Es sind zwar "normale" Objekte, werden aber Sprachintern gesondert behandelt. D.h. sowas...

        ArrayList<String> name = new ArrayList<String>();
        String fname = "FOO";
        name.add(fname);
        fname="JOHN";

bewirkt NICHT, dass "der String, der vorher 'FOO' enthielt, danach 'JOHN' enthält" - das geht schon nicht, weil Strings nicht veränderbar sind. Was dort steht ist von der Bedeutung her eher sowas wie

        ArrayList<String> name = new ArrayList<String>();
        String fname = "FOO";
        name.add(fname);
        fname= new String("JOHN"); // Ein neuer String

Man sollte Strings aber nicht mit "new String" erstellen - wie gesagt, das ist ein Sonderfall....