Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
mich würde interessieren ob public void abcd () ausgeführt werden kann oder ob ein Fehler auftritt.
Mich verwirrt da final steht. Normalerweise werden bei Vererbungen die Methoden überschrieben aber da in der Superklasse final steht bin ich mir nicht sicher da daraus eine konstante Methode gemacht wurde.
MfG
Java:
public class auto{
public final void abcd()
}
public class bmw extends auto{
public void abcd()
}
Das ist ja genau das was ich nicht verstehe. Bei meinem Beispiel wird die Methode aufgerufen aber da ich den Inhalt nicht sehe, wie kann ich erkennen ob die Methode überschrieben wird.
Sobald eine Methode in der Subklasse aufgerufen wird, würde ich sagen dass die Methode überschrieben wird. Aber die erste Antwort war dass die Methode nur aufgerufen wird.
Wie erkenne ich ob die Methode nur aufgerufen wird oder überschrieben wird.
Ist es richtig dass die Methode aufgerufen wird wenn sie ein void ist und überschrieben wird wenn sie alles andere als void ist.
Nein, das bestimmt, ob sie etwas zurück gibt oder nicht.
Java:
public class A {
public String getName() {
return "Franz";
}
public final int getSquare(int a) {
return a * a;
}
}
Hier kann eine Klasse X [c]getName()[/c] überschreiben. [c]getSquare()[/c] aber nicht, denn als ich [c]A[/c] implementierte, wusste ich, dass [c]getSquare()[/c] immer [c]a^2[/c] zurückgeben soll.
package help;
public class A {
public void anything() {
// mach irgendetwas
}
public final void notOverridable() {
/* Führe Code aus, der nicht überschrieben werden kann */
}
public final int getNotOverridable(int a) {
return a;
}
}
Java:
package help;
public class B extends A {
@Override
public void anything() {
/*
* der Super-Aufruf kann auch weggelassen werden und ein komplett neuer
* Inhalt geschrieben werden
*/
super.anything();
/*
* Code hinzufügen, der mit dem Inhalt der in der Oberklasse definierten
* Methode arbeiten soll
*/
int a = 10 + 13;
}
@Override
public final void notOverridable() {
/*
* Hier bekommst du ein Fehler, da die Unterklasse die Methode nicht
* überschreiben darf! Es ist nicht möglich, einen neuen Inhalt in der
* Methode zu verfassen/implementieren
*/
}
public void aufruf() {
anything(); // Aufruf einer Methode innerhalb einer Klasse ohne Objekt
A a = new A();
/*
* Aufruf der Methode aus der Oberklasse A. Aufruf möglich,
* überschreiben nicht!
*/
a.getNotOverridable(5);
}
}
Um es mal zu verdeutlichen hier zwei Klassen. Beide kommentiert. Sollte jetzt verständlich werden.
Ich versuche das mal mit einem Variablenbeispiel zu erklären.
Zuerst wir Methode A auf und dann Methode B.
Code:
A -> B
Durch die Methode A wird der name auf Heinz gesetzt.
Durch die Methode B würde der name auf Peter gesetzt, wenn der nicht final(unveränderbar/einmal veränderbar) wäre und nicht schon Heinz heißen würde.
Java:
private final String name;
public void A(){
name = "Heinz";
}
public void B(){
name = "Peter"; //Funktioniert nicht weil da schon etwas drin ist, was du sonst überschreiben würdest
}
Mal davon abgesehen, dass man Methodennamen klein schreibt.
Um mal das Missverständnis des Aufrufes und des Überschreibens zu erklären. Eine Methode rufst du auf, wenn du den Inhalt aus dieser zur Anwendung bringen möchtest.
Java:
A a = new A();
a.abcd();
Das ist ein Aufruf, weil du hier nicht an den Code der Methode gehst und diesen veränderst, sondern weil du sagst, auf dem Objekt "a" soll nun die Methode "abcd" aufgerufen(!) werden und der Code darin ausgeführt! Nichts sonst!
Wenn du aber eine Methode überschreibst, dann veränderst du in gewisserweise den Inhalt dieser Methode. Dir bleibt zwar die Möglichkeit die alte Methode mit dem alten Inhalt aufzurufen und deinen neuen daranzuhängen, das ist aber jetzt ein anderes Thema/andere Frage.
Java:
public class A {
public void overridable() {
int a = b + c;
}
}
Java:
public class B extends A {
@Override
public void overridable() {
int a = b + d;
}
Hier überschreibst du die Methode, weil du ihr einen ANDEREN Inhalt, eine andere Arbeitsweise "übergibst". Du möchtest, dass die Methode nicht die "alte" Arbeitsweise ausführt, sondern eine von dir bestimmte, die dann als Standardarbeitsweise ausgeführt wird. Hier überschreibst du die Methode, aber aufrufen tust du sie hier nicht! Du bestimmt einen neuen Code-Rumpf für die Methode!
Außerdem ist es bei den finalen Attributen genauso! Die finalen Attribute sind unveränderbar nach erstmaliger Zuweisung, entweder durch den Konstruktor oder schon in der Deklaration selbst! Dieses Verhalten kannst du auf die Methoden übertragen. Die Methoden kann man verwenden, aber ihren Inhalt wie in einem finalen Attribut nicht verändern!
