Heute gibt es wieder mal nach langer Zeit ein Java Thema. Dieses Thema ist auf den ersten Blick sehr trivial und man schreibt das bestimmt vielfach am Tag ohne drüber nachzudenken.

Konkret gehts heute um return-Statements und auf welche Art diese einen Wert zurück geben. Ein Beispiel soll dies verdeutlichen, nehmen wir an wir haben eine toString() Methode. Diese kann man auf 2 Arten implementieren:

	public String toString(){
		return "hallo";
	}

	public String toString2(){
		return new String("hallo");
	}



Der Unterschied liegt auf der Hand, in der ersten Methode geben wir direkt eine Zeichenfolge zurück und in der zweiten erzeugen wir erstmal ein Objekt von Typ String und geben das dann zurück. Funktioniert beides, aber was benutzt du, und warum?
Denn so unscheinbar das auch aussieht gibt es hier Unterschiede, denn je nachdem welche der beiden Funktionen wir ausführen bekommen wir etwas anderes, ein Beispiel:
		String t1 = toString();
		String t2 = toString();

		String b1 = toString2();
		String b2 = toString2();

		System.out.println(t1.equals(t2));	//true
		System.out.println((t1 == t2));		//true

		System.out.println(b1.equals(b2));	//true
		System.out.println((b1 == b2));		//false

		System.out.println(b1.equals(t1));	//true
		System.out.println((b1 == t1));		//false



Interessant sind hier immer jeweils die zweiten Ausgabezeilen, denn diese sagen, dass wir den == Operator nicht benutzen dürfen und bekommen somit unterschiedliche Referenzen auf verschiedene Objekte zurück.
Nur nicht im ersten Fall, wo wir das Ergebnis ohne new zurück geben, dort können wir den == Operator verwenden – demnach bekommen wir immer exakt die gleiche Referenz zurück egal wie oft wir diese Methode aufrufen, aber wie kann das sein?
Die Antwort liegt wieder in den Grundlagen 🙂 denn auch in der ersten Methode geben wir ein Objekt vom Typ String zurück. Dieses Objekt wird erzeugt wenn die Klasse gestartet wird und ist ab dann Klasseninventar, was unter anderem heißt dass es exakt nur ein einziges Mal vorhanden ist.
Daher geben alle Abfragen dieses Strings immer die eine Referenz auf diesen Klassenstring zurück, was dafür sorgt dass wir dem == Operator hier anwenden dürfen und auch folgendes funktioniert:
String a = "hallo";
String b = "hallo";

System.out.println(a == b);	//true



Da Strings in Java ebenfalls immutable ist können diese ihren Inhalt nicht ändern, womit die Referenz immer die selbe sein wird.
Warum nun das Ganze? Ich wollte einfach auf diesen kleinen aber doch wichtigen Unterschied hinweisen, da es da zu Fehlern kommen kann wenn man Ergebnisse vergleichen will und man das nicht weiß.