Überschreiben und Überladen

[Kicker86]

Hallo,

ich versuche gerade das Konzept des Überschreibens und des Überladens zu verstehen. Habe ein Beispiel gefunden, und habe das mal kurz implementiert aber weiss leider nicht was ich in die Methode equals(Objekt p) schreiben soll.

Ich möchte als erstes überprüfen, wie das Überschreiben funktioniert.
Dazu habe ich ausgaben als "True" und "False" um es nachvollziehen zu können.

Kann mir einer sagen was ich in die Methode equals(Objekt p) fürs Testen schreiben könnte? Vielen Dank

public class Objekt {	
	public Boolean equals(Objekt p){
		return true;
	}
}

public class Punkt extends Objekt {
	int x,y;

	public Punkt (int x, int y){
		this.x=x;
		this.y=y;
	}
	
	public Boolean equals(Objekt p){
		return true;
	}
}

public class FarbPunkt extends Punkt{
	String farbe; 
	int x, y;

	public FarbPunkt(int x, int y, String farbe){
		super(x,y);
		this.x=x;
		this.y=y;
		this.farbe=farbe;
	}
	
	public Boolean equals(Objekt p){
		return true;
	}
}

public class Test {

	public static void main(String[] args) {
		Punkt p1 = new Punkt(1,1);
		FarbPunkt fp = new FarbPunkt(1,1,"rot");
		Punkt p2 = new Punkt(0,0);
		
		if(p1.equals(p2))
			System.out.println("p1.equals(p2)  --- TRUE  ");
		else
			System.out.println("p1.equals(p2)  --- FALSE  ");
		if(p1.equals(fp))
			System.out.println("p1.equals(fp)  --- TRUE  ");
		else
			System.out.println("p1.equals(fp)  --- FALSE  ");
		if(fp.equals(p1))
			System.out.println("fp.equals(p1)  --- TRUE  ");
		else
			System.out.println("fp.equals(p1)  --- FALSE  ");
	}
}

 

[eRaaaa]

Also die Methode aus Object heißt

public boolean equals(Object obj) {

also musst du die auch so nennen, weil sonst überschreibst du die ja nicht (also Boolean abändenr zu boolean und Objekt zu Object! )

Was dann da rein gehört ist ja dir überlassen..Überschreiben heißt es einfach, wenn du eine Methode in der Unterklasse mit der gleichen Signatur erstellst wie in der Oberklasse !

Überschreiben:Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 6.10 Methoden überschreiben

Überladen:Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 2.8 Methoden einer Klasse

 

[nrg]

du rufst ja die Methode, wie du schon richtig machst, so auf:
p1.equals(p2)

dh p2 ist dein Parameter und p1 deine aktuelle Instanz.

deine aktuelle Instanz kannst du ja durch "this" deklarieren. deinen Parameter deklarierst du ja bereits in deiner Methodensignatur (bei dir p)

also kannst du ja this mit p vergleichen.

if (this.x == p.x && this.y == p.y)
    return true;
return false;

(ungetestet. hab grad keine jdk da)
ggf noch casten.

grüße

 

[Aldimann]

Bzgl. der equals und hashCode methoden würd ich mir mal ne Menge hier von durchlesen. AngelikaLanger.com - Implementing the equals() Method - Part 1 - Angelika Langer Training/Consulting

Aber ich glaube das Sprengt momentan total deinen Rahmen, also würd ich beides erstmal lassen.

Überladen:

Überladen einer Methode Funktioniert einfach in dem ihre Signatur anders ist:

public void tuWas(String myString1){
//Mach was
}

//Überladen der Methode
public void tuWas(String myString1, String myString2){
//Mach was
}

Die Methoden unterscheiden sich nur in den Übergebenen Parametern. Das ist das Prinzip des Überladens.



Überschreiben:

Um eine Methode zu Überschreiben muss die Klasse in der eine Methode Überschrieben werden soll von einer anderen Klasse erben, die diese Methode schon hat.

Beispiel:

MyClass implementiert tuWas(String myString1) und du willst diese in einer Subklasse MySubClass überschreiben.

Dann muss MySubClass von MyClass erben (class MySubClass extends MyClass) und in MySubClass muss die GLEICHE Methode tuWas(String myString1), mit den GLEICHEN Parametern (anders als das Überladen) implementiert werden.

Ich hoffe das war alles richtig :rtfm: