# gleichheit von objekten



## Cube (22. Jun 2009)

hallo zusammen ich habe ein kleines problem mit objekten und zwar habe ich ein programm das zwei objekte auf gleichheit prüfen soll dies soll mit equals () gehen bei mir geht das leider nicht kann mir einer sagen was ich falsch mache 

```
public class ObjektErstellen {


	public static void main(String[] args) {
		
		//Definition der Referenzvariablen
		Car car1 ,car2;
		
		//erzeugen des refernztyps/objekt
		car1= new Car("ford",150);
		
		car2=new Car("ford",150);
		
		//gleichheit prüfung
		boolean gleich = car1==car2;
		
		boolean gleich2=car1.equals(car2);
		
		System.out.println("prüfung auf referenzgleichheit: "+gleich);
		System.out.println("prüfung auf referentypen/objekt gleichheit: "+gleich2);
		
	}

}
```


```
class Car {
	int ps;
	double verbrauch;
	String marke;
	
	Car(String marke,int ps)
	{
		marke=marke;
		ps=ps;
		
	}
}
```

es kommt immer false raus aber warum?


----------



## bygones (22. Jun 2009)

du musst in deiner Klasse schon die Methode equals ueberschreiben - ansonsten wird die equals von Object genommen und die verlgeicht auf referenz


----------



## maki (22. Jun 2009)

Hast du equals & hashcode überschrieben?


----------



## Cube (22. Jun 2009)

maki hat gesagt.:


> Hast du equals & hashcode überschrieben?


nein wie macht man sowas?


----------



## The_S (22. Jun 2009)

Siehe Java Blog Buch : 04.03.11 Besondere Methoden (equals, hashCode und toString)


----------



## faetzminator (22. Jun 2009)

etwa so sollte equals aussehen (in Car)


```
public boolean equals(Object o) {
    if (!(o instanceof Car)) {
        return false;
    }
    Car car = (Car) o;
    return car.marke.equals(this.marke) && car.ps == this.ps; // was du auch immer übrprüfen willst...
}
```


----------



## Cube (22. Jun 2009)

ich habe jetzt die equals() methode in meiner Car klasse überschrieben
und die methode im hauptprogramm aufgerufen  nun bekomme ich aber wären der laufzeit einen fehler :Exception in thread "main" java.lang.NullPointerException
	at Car.equals(Car.java:17)
	at ObjektErstellen.main(ObjektErstellen.java:20)

```
public boolean equals(Car b)
	{  
		//vergleich von marke und ps
		
		if (this.ps == b.ps && this.marke.equals(b.marke)) 
		{  
	     return true;  
		}
		
		else
		{
		 return false; 
		}
	}
```


----------



## bygones (22. Jun 2009)

dann schau in Zeile 17 in der Car.java - da is was null....

also entweder ist b selber null oder eine marke ist null...


----------



## faetzminator (22. Jun 2009)

falls gewisse Werte bei dir wirklich null sein sollen, kannst du dir eine Helpermethode schreiben

```
private boolean equals(Object o1, Object o2) {
    if (o1 == null && o2 == null) {
        return true;
    }
    if (o1 == null || o2 == null) {
        return false;
    }
    return o1.equals(o2);
}
```
das könntest du in diesem Fall mit folgender Zeile aufrufen

```
equals(this.marke, b.marke)
```
Du solltest aber eigentlich equals(Object) und nicht equals(Car) schreiben...


----------



## Cube (22. Jun 2009)

```
public boolean equals(Object b)
	{  
		//vergleich von marke und ps
		Car a=(Car) b;
		if (this.ps == a.ps && this.marke.equals(a.marke)) 
		{  
	     return true;  
		}
		
		else
		{
		 return false; 
		}
	}
```
immer noch der selbe fehler

und warum macht man das

equals(Object b)

		Car a=(Car) b;


----------



## The_S (22. Jun 2009)

Du könntest den von mir verlinkten Artikel lesen ...


----------



## faetzminator (22. Jun 2009)

Die Methode, welche von Object definiert wird, ist nunmal equals(Object).
Zusätzlich solltest du, wie in meinem ersten Code eine instanceof Überprüfung machen.
Und den ersten Teil meines letzteren Mails solltest du ebenfalls beachten (equals(Object, Object) gegen nullpointers)
Also etwa so:

```
public boolean equals(Object o) {
    if (!(o instanceof Car)) {
        return false;
    }
    Car car = (Car) o;
    return car.ps == this.ps && equals(car.marke, this.marke); // was du auch immer übrprüfen willst...
}

private boolean equals(Object o1, Object o2) {
    if (o1 == null && o2 == null) {
        return true;
    }
    if (o1 == null || o2 == null) {
        return false;
    }
    return o1.equals(o2);
}
```


----------



## Cube (22. Jun 2009)

ich komm grad gar nicht mehr klar
ich weis das man die equals methode überschreiben muss weil die ja nur sont die  referenz gleichheit prüft 
ich habe nochmal 2 einfacheres programm geschrieben

```
class Car {
	
	String marke;
	
	Car(String marke)
	{
		marke=marke;	
	}
	
	boolean equals(Car car2)
	{
		if(this.marke.equals(car2.marke))
		{
			return true;
		}
		else
		{
			return false;
		}
		
	} 
}
```


```
class Car2 {

	int ps;
	
	Car2(int ps)
	{
		this.ps=ps;	
	}
	
	boolean equals(Car2 car2)
	{
		if(car2.ps==this.ps)
		{
			return true;
		}
		else
		{
			return false;
		}
		
	} 
}
```

car2 funktioniert Car1 nicht wirder kommt ein laufzeitfehler NullPointerException
???:L


----------



## bygones (22. Jun 2009)

```
boolean equals(Car car2)
```
les erstmal was man dir antwortet....
du musst

```
public boolean equals(Object car2)
```
ueberschreiben !

dein 1. bsp geht nicht, da marke im equals null ist, da du es nie setzt.
dein konstruktor ueberschreibt den parameter, setzt nicht die instanzvariable

```
this.marke = marke
```


----------



## sayang (22. Jun 2009)

Du hast im Konstruktor von Car folgenden Fehler:


```
Car(String marke)
{
    marke=marke;    
}
```

Du musst hier daran denken, dass mit "marke" erstmal die dem Konstruktor übergebene Variable meint. Du weist hier den Wert der Variable "marke" sich selbst zu. Und nicht dem Attribut "marke" von Car.
Kurz: da fehlt ein "this." 


```
Car(String marke)
{
    this.marke=marke;    
}
```

Edith sagt, da war jemand schneller als ich


----------



## Cube (22. Jun 2009)

jetzt hab ich's 
hab ja gelesen aber als neuling ist das nicht alles immer grade leicht zu verstehen 

this ist also eine art platzhalter für das jeweilige objekt das bei mir fehlte


```
public boolean equals(Object car2)
```
es geht aber doch auch so wie ich das mache warum soll ich denn da casten?


----------



## bygones (22. Jun 2009)

Cube hat gesagt.:


> es geht aber doch auch so wie ich das mache warum soll ich denn da casten?




```
public class Example {
    private final String _name;

    public Example(String name) {
        _name = name;
    }

    boolean equals(Example other) {
        return other._name.equals(other);
    }

    public static void main(String[] args) {
        Example ex1 = new Example("example1");
        Example ex2 = new Example("example2");

        System.out.println(ex1.equals(ex2)); // false
    }
}
```
so wie du es geschrieben hast - hier nochmals - klappt es nicht, da du nicht equals ueberschreibst !

um eine methode zu ueberschreiben musst du die selbe signatur benutzen wie die obermethode und die ist nun mal

```
boolean equals(Object o)
```


----------



## Cube (22. Jun 2009)

ja hast recht 
du überschreibst die methode ich schreibe eine eigne(also nicht überschrieben) so könnte man das sehen


----------



## sayang (22. Jun 2009)

Cube hat gesagt.:


> this ist also eine art platzhalter für das jeweilige objekt das bei mir fehlte


Nur zur Info: Du brauchst kein this zu schreiben, wenn der Name des Parameters von dem Namen der Objektvariablen abweicht.


```
public class Car {
   private String marke;

   public Car(String eineMarke) {
      marke = eineMarke; // Hier weiss das Programm, was "marke" ist. Daher kein this notwendig
   }
}
```


----------



## bygones (22. Jun 2009)

Cube hat gesagt.:


> ja hast recht
> du überschreibst die methode ich schreibe eine eigne(also nicht überschrieben) so könnte man das sehen


als tipp - wenn du eine methode ueberschreiben willst schreibe immer @Override darueber
zb

```
@Override
public boolean equals(Object o)
```
dann meckert der compiler schon wenn du die methoden nicht richtig definierst


----------



## Cube (22. Jun 2009)

werde ich machen danke für euere hilfe


----------

