# Doppeltes Gleich?



## Favorite_11 (2. Apr 2014)

Hallo zusammen,

ich habe ein Problem. Wir haben ein Codebeispiel bekommen und ich weiß nicht genau was das doppelte Gleich-Zeichen im return bedeutet:


```
public boolean istAmEnde() {
	return (aktuell.nf == null);
}
```

Gruß


----------



## Tobse (2. Apr 2014)

Grundlagen lernen 

Das 
	
	
	
	





```
==
```
 ist ein Vergleichs-Operator. Vergleiche liefern immer 
	
	
	
	





```
boolean
```
 Werte. Als beispiel:

Folgende beiden Code-Beispiele sind exakt das selbe:

```
if (fensterWinkel > 0)
{
    System.out.println("Das Fenster ist auf");
}
else
{
    System.out.println("Das Fenster ist zu");
}
```


```
boolean fensterIstAuf = fensterWinkel > 0;
if (fensterIstAuf)
{
    System.out.println("Das Fenster ist auf");
}
else
{
    System.out.println("Das Fenster ist zu");
}
```


----------



## Natac (2. Apr 2014)

Ein Beispiel, wo gar kein == vorkommt!? :autsch:

Wie du mit 
	
	
	
	





```
>
```
 und 
	
	
	
	





```
<
```
 prüfen kannst, ob Zahlen größer oder kleiner als andere sind, kannst du mit 
	
	
	
	





```
==
```
 testen, ob zwei Dinge (nicht nur Zahlen) gleich (identisch) sind.

Wenn du Objekte miteinander vergleichen möchtest, dann bietet sich aber eher die Methode [c]equals(Object o)[/c] an, die jedes Objekt hat.

Mehr Grundlagen gibts hier. :rtfm:


----------



## Tobse (2. Apr 2014)

Natac hat gesagt.:


> Ein Beispiel, wo gar kein == vorkommt!? :autsch:
> 
> Wie du mit
> 
> ...



Da stellt sich jetzt die Frage, was das größere Vergehen ist. Dass dem TE die Intelligenz unterstellt wird, die Analogie zwischen einem 
	
	
	
	





```
>
```
 und einem 
	
	
	
	





```
==
```
 zu erkennen oder aber dass hier das Bild vermittel wird, man könne Zwei Objekte mittels 
	
	
	
	





```
==
```
 auf Identität prüfen. Denn lezteres ist schlicht *falsch*.

```
==
```
 prüft immer, ob zwei _Referenzen_ auf *das selbe* Objekt zeigen. Das Funktioniert bei _primitiven Datentypen_ nur, weil die JVM bei einer Referenz auf eine schon bestehende, identische Zahl die gleichen Referenzen benutzt.


----------



## kaoZ (2. Apr 2014)

Ich glaube er meinte ,


```
==
```
 Vergleicht *Referenzen* und liefert einen _booleschen_ Wert.

Beim nutzen des Verlgeichsoperators 
	
	
	
	





```
==
```
 , werden lediglich Referenzen der 2 Objekte Verglichen 
(Belegung von Attributen werden hier ignoriert)

bedeutet in deinem Konkreten fall, das wenn 


```
aktuell.nf
```
 ( was auch immer das sein soll ? Klasse? Variable ? Deklaration inkorrekt ?!)

mit *null* initialisiert wurde _true_ liefert

andernfalls _false_ liefert;

Das Bedeutet das 2 Objekte die gleiche Identität haben können , jedoch nicht zwingend auch gleich, im Sinne von "gleich" sind.


----------



## Natac (3. Apr 2014)

Tobse hat gesagt.:


> Da stellt sich jetzt die Frage, was das größere Vergehen ist. Dass dem TE die Intelligenz unterstellt wird, die Analogie zwischen einem
> 
> 
> 
> ...


Intelligenz zu unterstellen halte ich nie für falsch.  Und auf Zahlen bezogen (womit ich ja argumentiert habe) empfinden ich es als durchaus sinnig, 
	
	
	
	





```
==
```
 mit 
	
	
	
	





```
>
```
 und 
	
	
	
	





```
<
```
 auf eine Ebene zu stellen. Denn eine Zahl kann größer, kleiner oder eben gleich einen andere Zahl sein. Viel intuitiver gehts wohl kaum.



Tobse hat gesagt.:


> oder aber dass hier das Bild vermittel wird, man könne Zwei Objekte mittels
> 
> 
> 
> ...


Kommt stark darauf an, wie du Identität jetzt definierst. Wenn ich wissen möchte, ob zwei variablen das selbe Objekt beinhalten, dann kann ich durchaus 
	
	
	
	





```
==
```
 verwenden, weile es eben die Referenzen (wie du ja auch selbst schreibst) vergleicht. Um zu prüfen ob zwei Objekte semantisch gleich sind, sollte man eh 
	
	
	
	





```
equals
```
 verwenden.



Tobse hat gesagt.:


> ```
> ==
> ```
> prüft immer, ob zwei _Referenzen_ auf *das selbe* Objekt zeigen. Das Funktioniert bei _primitiven Datentypen_ nur, weil die JVM bei einer Referenz auf eine schon bestehende, identische Zahl die gleichen Referenzen benutzt.


Ich halte es nicht für schlau einen Anfänger mit Referenzen zu konfrontieren. Denn diese Spielen in Java eigentlich keine Rolle, da nicht zwischen Pointer und Objekt unterschieden wird.


----------



## Tobse (3. Apr 2014)

Natac hat gesagt.:


> Ich halte es nicht für schlau einen Anfänger mit Referenzen zu konfrontieren. Denn diese Spielen in Java eigentlich keine Rolle, da nicht zwischen Pointer und Objekt unterschieden wird.



Naja, wenn es um Pass-by-Reference oder Pass-By-Value geht ist es schon wichtig, das prinzip von Referenzen zu verstehen. Pointer sind natürlich wieder ne Geschichte für sich und in Java unwichtig.


----------



## Favorite_11 (4. Apr 2014)

Ok vielen Dank. Habt mir sehr geholfen.

Also generell wusste ich das == der Vergleichsoperator ist aber wusste nicht, dass man es auch einfach so im return benutzen kann.. 

Zu nf: Es geht hier um eine Klasse, die eine Liste abbildet. nf verweist auf das nächste Element in der Liste...


----------



## kaoZ (5. Apr 2014)

Klassen schreibt man groß, variablen lowerCamelCase
Bedeutet konkret Du müsstest es so schreiben
Und auch dementsprechend deklarieren

```
Aktuell.nF
```

Zudem sollte man eindeutige und aussagekräftige Bezeichner verenden,  sonst entsteht schnell totales Chaos


----------

