2 Objekte (mathematisch) vergleichen in der equals Methode

[conspectumortis]

Hallo , liebe Gemeinde.


Ich bin gerade dabei eine Aufgabe zu bearbeiten .
Leider muss ich zugeben das ich bei einer Teilaufgabe stocke (hashCode und toString waren kein Problem):

Wir sollen 2 Objekte in der von uns neu definierten equals Methode vergleichen und bei Gleichheit des reellen Zahlenwertes (ein Objekt nur mit reeller Zahl und das andere Objekt mit reeller Zahl mit imaginären Anteil) entweder true oder false zurückliefern.

Mein Problem ist ,auch nachdem ich mit in meinen Büchern eingelesen habe ,zu verstehen wie ich die 2 Objekte auf Gleichheit in der equals Methode teste.
Im trivialen Fall wüsste ich wie ich das mit 2 in einer Klasse vorhandenen Variablen auf Gleichheit testen würde.

Genauer gesagt,ich bin etwas planlos wie ich auf die reelle Zahl des einen objektes und nur auf die Reelle Zahl des anderen Objektes zugreife und vergleiche.



Falls mir jemand einen allgemeinen Fall für den Vergleich 2er Objekte in der equals Methode sagen könnte,könnte ich das vom Verständnis her dann auf meinen Fall verändert übertragen,oder auch nicht ^^ Zumindest könnte ein Ansatz mir weiterhelfen.


Danke im Vorraus
conspectu

 

[maki]

Falls mir jemand einen allgemeinen Fall für den Vergleich 2er Objekte in der equals Methode sagen könnte,könnte ich das vom Verständnis her dann auf meinen Fall verändert übertragen,oder auch nicht ^^ Zumindest könnte ein Ansatz mir weiterhelfen.

#
Bitte schön, aus der Java Api Doku zu Object#equals:

equals
public boolean equals(Object obj)Indicates whether some other object is "equal to" this one.
The equals method implements an equivalence relation on non-null object references:

It is reflexive: for any non-null reference value x, x.equals(x) should return true.
It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
For any non-null reference value x, x.equals(null) should return false.
The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).

Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.

Es gibt da ein paar Regeln zu beachten, Eclipse generiert einem equals und hashcode auch auf Wunsch.

Die hascode MEthode hast du wahrscheinlich nicht richig implmentiert 😉

 

[Murray]

Im trivialen Fall wüsste ich wie ich das mit 2 in einer Klasse vorhandenen Variablen auf Gleichheit testen würde.

Was "Gleichheit" bedeutet, muss man im jeweiligen Anwendungsfall entscheiden und die Methode dann entsprechend implementieren. Wenn man unter Gleichheit versteht, dass alle Membervariablen gleich sind, dann muss man prinzipiell nur alle Vergleiche UND-verknüpfen.

Genauer gesagt,ich bin etwas planlos wie ich auf die reelle Zahl des einen objektes und nur auf die Reelle Zahl des anderen Objektes zugreife und vergleiche.

Wenn in Deinem Fall bei der Ermittling der "Gleichheit" nicht alle Membervariablen herangezogen werden sollen, ist das doch kein Problem: lass den entsprechenden Vergleich einfach weg.

Wie sieht denn der Code für die Klasse bisher aus?

 

[Marco13]

Allgemein

class Complex
{
    private float real;
    private float imag;

    public boolean equals(Object object)
    {
        if (object instanceof Complex)
        {
            Complex other = (Compley)object;
            return real == other.real && imag == other.imag;
        }
        return false;
    }
}

Bachte aber, dass solche Vergleiche zwischen floats ziemlich diffizil sind - eigentlich müßte man da (wie auch bei hashCode) sowas wie Float.floatToIntegerBits(oder wie das heißt) verwenden....

 

[conspectumortis]

@Murray

Bisher hab ich das mal soweit gemacht:

//öffentliche Oberklasse Complex
public class Complex {
	
	//geschützte Variablen double real und komplex
	protected double real;
	protected double komplex;
	
	//öffentlicher Konstruktor wird von Real.java verwendet
    public Complex (double i, double j) {
    	real= i; //reeller Teil
    	komplex = j; //imaginärer Teil
        }
	
       
    //öffentliche umgeschriebene hashCode Methode
    public int hashCode () {
    double x=real,y=komplex; //reelle & img Teile der Zahl
    x=x+y;
    int f= (int)x; //Umwandlung von double x in int x
    //Abfrage um immer einen potiviten HashWert zu erlangen
    if(x>0){
    	return (int) ((x-f)*1000000);//positiver HashWert
    }
    else 
       	/*Falls x negativ multipliziere 6 Stellen nach Komma 
    	mit negativen 1000000 um positiven HashWert zu erhalten*/
    	return (int) ((x-f)*-1000000);
    }
    

 /*   public boolean equals (Object obj) {
	if (!(obj instanceof Complex)) return false;
	return true;
    }*/
    
    //umgeschriebene toString Methode
    public String toString () {
    	
    	/*Falls komplexer Anteil einer imaginären Zahl grösser/gleich 0
    	 * schreibe in der System.out.println Methode ein "+"
    	 * vor der komplexen Anteil der Zahl*/
    	if(komplex>=0){
        	return real + "+" + komplex+ "i";
    	}
    	else
    		/*negativ "-" wird automatisch bei dem komplexen Anteil
    		einer imaginären Zahl eingefügt*/
    		return real + "" + komplex+ "i";
   }
    
    
}

und dann noch die Unterklasse

//öffentliche Unterklasse Real
public class Real extends Complex{

	//öffentlicher Konstruktor Real
	public Real(double i) {
		/*mit Oberklasse Complex-Konstruktor überladen,
		 * 2ter erwarteter Wert mit 0 angebeben*/
		super(i,0); 
	}
	
	
	//öffentliche Methode int hashCode
    public int hashCode () {
    	//gebe Methode HashCode der Oberklasse zurück 
    	return super.hashCode();
    }

    
  /*  public boolean equals (Object obj) {
    	if (!(obj instanceof Real)) return false;
    		return true;
    }*/
    
    
	//Überschreibt die toString Methode in der Oberklasse
    public String toString () {
        	return  real + "";//reelle Zahl ausgegeben als String
        }

}

 

[Murray]

Das

public boolean equals (Object obj) {
   if (!(obj instanceof Complex)) return false;
   return true;
}

ist doch schon ein Ansatz.

Normalerweise würde man jetzt wohl noch die Membervariablen berücksichtigen, also etwa so:

public boolean equals (Object obj) {
   if (!(obj instanceof Complex)) return false;
   return ((Complex)obj.real == real) && ( (Complex)obj.komplex == komplex);
}

Wenn Du jetzt - aus welchen Gründen auch immer - nur den reellen Anteil vergleichen wilst, dann muss der zweite Vergleich einfach weg.

Aber: wie Marco schon geschrieben hat: da floats ja nur mit einer bestimmten Genauigkeit abgebildet werden, ist man in den meisten Fällen gut beraten, zwei floats nicht exakte Übereinstimmung zu prüfen.

Zweites Aber: wenn im equals wirklich nur noch der reelle Anteil berücksichtigt werden soll (warum auch immer man das machen sollte), dann sollte der komplexe Anteil auch nicht in den Hash-Code eingehen.

 

[conspectumortis]

danke murray und marco13

@murray
Laut Aufgabenstellung wird der Hashcode bei einer komplexen Zahl aus ihrer reellen Zahl und imaginären Zahl zusammenaddiert dann als int wert umgewandelt ,dieser int Wert wird von dem vorherigen Gesamtwert (double) abgezogen und die Zahl dann bis zur 6ten Zahl nach dem Komma wieder als int Wert zurückgegeben.

Gleiches gilt für die alleinstehende reelle Zahl ,nur das ihr imaginär Teil 0.0 ist und das eben zum reellen Teil der Zahl dazu addiert wird und wie oben vorgegangen wird.

Frag mich nicht wieso das so gewollt ist,aber ich hab das nur so gemacht wie es verlangt wurde =)


Ihr habt mir alle weitergeholfen danke,ich krieg das glaub nun hin =)


In diesem Sinne
einen guten abend euch noch

 

[Murray]

@murray
Laut Aufgabenstellung wird der Hashcode bei einer komplexen Zahl aus ihrer reellen Zahl und imaginären Zahl zusammenaddiert dann als int wert umgewandelt ,dieser int Wert wird von dem vorherigen Gesamtwert (double) abgezogen und die Zahl dann bis zur 6ten Zahl nach dem Komma wieder als int Wert zurückgegeben.

OK, dann passt es schon: die "Sonderbehandlung" in der abgeleiteten Klasse greift ja nur dann, wenn der imaginäre Teil 0 ist - und in dem Fall geht er ja auch nicht wirklich in die Berechnung des HashCodes ein.

 

[Marco13]

Darüber, warum der Imaginärteil einer komplexen Zahl "komplex" heißt, oder warum bei "public Real(double i) {" ein "i" übergeben wird, das weder die imaginäre Einheit, noch der Imaginäreteil ist, könnte man sicher streiten, aber... zu der Frage nach dem Grund für die "komischen" Berechnungen des Hashwertes (Ohne die genau nachvollzogen zu haben) : Vermutlich soll damit der Ungenauigkeit der float- und double-Darstellung Rechnung getragen werden. Also, vermutlich werden mit diesem Verfahren z.B. die Zahlen
(1,2)
und
(1.00000001,2.0000000067)
als gleich angesehen (und liefern demnach dann den gleichen hashCode, und sind laut "equals" dann true). Ist aber nur geraten.

 

[Murray]

Dann müsste man das gleiche Verfahren aber auch beim equals anwenden - sonst liefern zwei "sehr ähnliche" Zahlen zwar den gleichen Hash-Code, sind aber trotzdem lt. equals-Methode nicht gleich.

 

[Marco13]

Das ist OK so.

EDIT: Allerdings wären sie (entgegen der Aussage in meinem letzten Post) dann eben nicht equals (wenn er das NUR bei hashCode so machen würde)