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.
class A {
void m(A a) {System.out.println("1"); //Zeile 1
}
class B extends A {
void m(A a) {System.out.println("2"); //Zeile 2
void m(B a) {System.out.println("3"); //Zeile 3
}
class Test {
public static void main(String[] args) {
B b=new B();
A a=b;
a.m(a);
a.m(b);
b.m(a);
b.m(b);
}
Hier folgt die Ausgabe
2
2
2
3
Die in Zeile 1 dekl. Methode wird in Subklasse B durch die Zeile 2 überschrieben.
In KLasse B ist m (A a) überladen durch die Methode m( B b).
Zur Übersetzungszeit werden die beiden Methodenaufrufe a.m(a) und a.m(b) an die in Zeile 1 deklarierte Methode gebunden.
Weil Variable a zur Laufzeit ein B-Objekt enthält, wird wegen der dynamischen Methodenauswahl die sie überschreibende Methode der Klasse B ausgeführt, also 2mal "2" ausgegeben.
So stehts in der Erläuterung! Dieser letzte Satz verstehe ich nicht. Zur Laufzeit enthält die Variable a ein B-Objekt, soweit klar. Bei a.m(a) wird 2 ausgegeben, auch klar. Aber müßte bei a.m(b) nicht 3 ausgegeben werden?
a ist ja eigentlich vom Typ A, und Typ A kennt kein "void m(B a) {..}"
Du kannst es leicht überprüfen:
Wenn du in Klasse A einen "void m(B a) {..}" reintust, dann kommt 3.
Zur Laufzeit enthält die Variable a ein B-Objekt, soweit klar. Bei a.m(a) wird 2 ausgegeben, auch klar. Aber müßte bei a.m(b) nicht 3 ausgegeben werden?
HI, ich glaube so ganz klar ist dir das mit dem B-Objekt enthalten noch nicht. B ist eine Erweiterung von A (siehe extends Direktive). Das heißt, dass ein B alles kann was ein A kann (und ggf. mehr).
Eine Zeile wie
Code:
A a = new B();
Legt eine Variable a vom Typ A an. Dass heißt für Java nur, dass dieses a alle Eigenschaften von A haben muss. Eine Erweiterung von diesem A um weitere Variablen, mit weiteren Methoden kann dabei verwendet werden. Aber auf diese hast du keinen Zugriff:
Code:
class A {
public void doFoo1() {
...
}
}
class B extends A {
public void doFoo2() {
...
}
}
public class Main {
public static void main(String[] args) {
A a = new B();
B b = new B();
b.doFoo1(); // möglich, da von A geerbt / A erweitert
b.doFoo2(); // möglich da b vom Typ B
a.doFoo1(); // möglich da vom Typ A
a.doFoo2(); // nicht möglich! Variable ist vom Typ A und kennt nur die Eigenschaften von A
((B)a).doFoo2(); // möglich da explizit gecastet
}
}
Das zu verstehen ist eine wichtige Grundlage für die OOP. Du wirst später noch auf Interfaces und abstrakte Klassen stossen. Diese eignen sich für eine solche Vorgehensweise immer besonders gut. Du hast dann nur eine abstrakte Struktur. In Interfaces sind zum Beispiel nur die öffentlichen Methoden bekannt. Das zugewiesene Objekt ist damit völlig austauschbar.
muss mich mal mit ner Frage in den Thread einklinken. Ich hätte nicht gedacht, dass sowas wie
Code:
A a = new B();
überhaupt möglich ist! Auf der linken Seite wird ja eine Variable a vom Typ A angelegt, und dann wird ihr (auf der rechten Seite) eine Instanz der Klasse B zugewiesen?! Das geht dann aber nur, wenn B von A abgeleitet ist oder??
Und noch ne Frage: wenn ich in einer Klasse keinen Konstruktor angebe, was für ein Konstruktor (mit welcher Implementierung) wird dann aufgerufen? Es ist ja immer die Rede von diesem "Standartkonstruktor" aber wie sieht der konkret aus?
Hi,
in meinem Beispiel von vorhin erbt doch B auch von A. Der Begriff der Vererbung ist hier einfach nur schlecht gewählt. Ich denke intuitiver ist weiterhin der Begriff erweitern. Natürlich ist beides hier das Gleiche.
Was wichtig ist, B ist ein spezielleres A. A hat die Methode doFoo1(). B erweitert A, hat also auch schon mal eine Methode namens doFoo1(). B kann diese Methode jetzt überschreiben oder eben nicht.
Soweit so gut. B erweitert jetzt die Klasse A um eine weitere Methode doFoo2(). Diese Methode hat nur B. A weiß gar nicht, dass es eine solche Methode gibt (und das interessiert A auch gar nicht).
Wenn ich jetzt ein A möchte, dann heißt dass nur, dass ich eine Klasse möchte, die die Funktion doFoo1(); anbietet. Wie diese Methode eigentlich implementiert ist, dass ist mir egal.
Wie gesagt, richtig deutlich wird so etwas wenn man Interfaces betrachtet. Diese sind abstrakt, es kann keine direkte Instanz von einem Interface geben. Was es gibt sind nur Instanzen von Klassen, die dieses Interface implementieren. Wozu also ein Interface?
Die Idee ist eigentlich ganz einfach. Implementiert eine Klasse ein Interface oder erbt sie von einer anderen, ist es einfach nur eine Zusicherung, dass eine bestimmte Methode existiert.
Ein sehr einfaches Interface ist Comparable. Es bietet einfach nur die Möglichkeit zwei Elemente miteinander zu vergleichen. Es wird -1, 1 oder 0 geliefert (für kleiner, größer oder gleich).
Entwickelt man jetzt einen Sortieralgorithmus der super schnell und super toll ist, so möchte man wohl alles damit sortieren. Man hat nun zwei Möglichkeiten.
Die erste Möglichkeit wäre es für jede Klasse die man sortieren möchte eine eigene Variante zu schreiben (viel Spaß!). Das kostet viel Zeit, führt leicht zu fehlern und wenn man dann einen noch tolleren Sortieralgorithmus findet war alles für den ...
Die andere Möglichkeit ist es, dass man einfach das Comparable Interface verwendet. Hat man zwei Instanzen einer Klasse die dieses Interface implementiert, weiß man zwar nicht wie diese Instanzen verglichen werden, aber man weiß dass die Methode compare() existiert. Diese vergleicht (ohne das wir wissen wie) und sagt ob das erste Element kleiner, größer oder gleich ist. Mehr wollen wir gar nicht wissen, ist super!
Ein kleines Beispiel anhand der Maximum Funktion. Ist zwar kein Sortieralgo, aber bin gerade zu faul einen aufzuschreiben:
Code:
// einfaches Suchen eines Maximum in einem Array
// Version 1
Integer findMax(Integer[] i) {
Integer res = null;
if (i.length > 0) {
res = i[0];
for (int j = 0; j < i.length; j++) {
if (res.intValue() < i[j].intValue()) {
res = i[j];
}
}
}
return res;
}
Byte findMax(Byte[] b) {
Byte res = null;
if (b.length > 0) {
res = b[0];
for (int j = 0; j < b.length; j++) {
if (res.intValue() < b[j].intValue()) {
res = b[j];
}
}
}
return res;
}
// und noch für jede andere Klasse so weiter...
// findet man nun einen besseren Weg darf man von vorne beginnen
// Version 2
Comparable findMax(Comparable[] c) {
Comparable res = null;
if (c.length > 0) {
res = c[0];
for (int j = 0; j < c.length; j++) {
if (res.compareTo(c[i])) { // wie die Methode heißt hab ich gerade nicht im Kopf, glaube compare oder compareTo
res = c[j];
}
}
}
return c;
}
// das ganze kann man noch etwas schöner mit Generics machen, hier gibt es dann auch die Zusicherung und man muss nicht noch casten!
So, der Unterschied sollte grob klar sein. In Version 2 habe ich diese eine Methode, die für alle Instanzen verwendet werden kann, die das Interface Comparable implementieren. Die Wrapper Integer, Short, ... gehörten natürlich dazu. Vom Interface Comparable gibt es aber trotzdem keine Instanzen.
Code:
Comparable c;
c = new Comparable(); // geht nicht! Comparable ist nur ein Interface!
c = new Integer(); // geht, da Integer implements Comparable gilt
Das gleiche hat man dann halt mit Klassen und Vererbung. Der Typ einer Variablen sichert eben nur die Eigenschaften dieses Typs zu. Wird ein Instanz zugewiesen die spezieller ist (mehr kann, etwas auf eine bestimmte Art und Weise macht), so ist das egal.
Das Maximum eines Arrays ist größer als jeder andere Wert im Array. Ob größer dabei heißt, dass es eine größere Zahl, ein höheres Datum, eine spätere Zeit, .... ist ist egal!
muss mich mal mit ner Frage in den Thread einklinken. Ich hätte nicht gedacht, dass sowas wie
Code:
A a = new B();
überhaupt möglich ist! Auf der linken Seite wird ja eine Variable a vom Typ A angelegt, und dann wird ihr (auf der rechten Seite) eine Instanz der Klasse B zugewiesen?! Das geht dann aber nur, wenn B von A abgeleitet ist oder??
Und noch ne Frage: wenn ich in einer Klasse keinen Konstruktor angebe, was für ein Konstruktor (mit welcher Implementierung) wird dann aufgerufen? Es ist ja immer die Rede von diesem "Standartkonstruktor" aber wie sieht der konkret aus?
Richtig, der Code geht nur, wenn B von A abgeleitet ist.
Ist B aber auch:
Code:
class B extends A {
Der Standardkonstruktor ist der Konstruktor ohne Parameter.
Wenn man in der Klasse garkeinen Konstruktor angibt, wird implizit einer erzeugt, der einfach nichts macht.
muss mich mal mit ner Frage in den Thread einklinken. Ich hätte nicht gedacht, dass sowas wie
Code:
A a = new B();
überhaupt möglich ist! Auf der linken Seite wird ja eine Variable a vom Typ A angelegt, und dann wird ihr (auf der rechten Seite) eine Instanz der Klasse B zugewiesen?! Das geht dann aber nur, wenn B von A abgeleitet ist oder??
a ist ja eigentlich vom Typ A, und Typ A kennt kein "void m(B a) {..}"
Du kannst es leicht überprüfen:
Wenn du in Klasse A einen "void m(B a) {..}" reintust, dann kommt 3.
Vieles ist mir einleuchtend.
Ich glaub aber, ich komme mit der Schreibweise void m(B a) nicht so ganz zurecht.
a heißt, das es vom Typ A ist, und was heiß das große B in void?
wenn a.m(b) aufgerufen wird,heißt das doch, das von der Klasse A die Variable b gewünscht wird. Diese gibt es in meiner Ausführung nicht. Also wird die überschreibene Methode aufgerufen: void m (A a) und 2 (Zeile 2) ausgegeben. Warum wird nicht die überladene Methode ausgeführt und Zeile 3 ausgegeben? Schließlich ist im Aufruf a.m(b) in Zeile 3 void m(B b) b enthalten?
Den Tip von Andre Uhres habe ich ausprobiert.
Kann man das dann so interpretieren:
Bei Aufruf von a.m(b) wird die Methode von der Klasse A void m(B a) aufgerufen, da aber B von A erbt und durch A a=b wird die Methode in Klasse B durch void m(B b) überschrieben und damit Zeile 3 ausgegeben.
Liege ich damit richtig?
:shock:
Du solltest dringend Einführungskapitel eine Java-Buchs durcharbeiten.
Ich glaub aber, ich komme mit der Schreibweise void m(B a) nicht so ganz zurecht.
a heißt, das es vom Typ A ist, und was heiß das große B in void?
Nein! Es gibt die Methode des Namens m die nichts zurückliefert (void) und einen
Parameter übergeben bekommt. Dieser Parameter wird innerhalb der Methode a
genannt und muß vom Typ (eine Instanz der Klasse) B sein.
...
alle weiteren Fragen überblicke ich im Moment nicht. :autsch:
Insbesondere solltest du dich mit einfacheren Beispielen beschäftigen, als mit solchen hier, die gleich zwei Konzepte miteinander vermengen und "Seiteneffekte" beobachten.
