Ausgabe bei Ausführung |
28.12.2014, 01:07 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 | Ausgabe bei Ausführung System.out.println(o1.m() + o2.m()); ->(1+2)=(3) System.out.println(o2.m() + o3.m()); ->(2+2)=(4) System.out.println(o2.n()); ->2 System.out.println(print(o1)); ->Parameter A: Ich bin ein A. System.out.println(print(o2));->Parameter B: Ich bin ein B. System.out.println(print(o3));->Parameter B: Ich bin ein B. System.out.println(o1.add(o1));2+2= 4 System.out.println(o1.add(o2));geht nicht? System.out.println(o2.add(o3)); 4+4=8 System.out.println(o2.add(o2));3+3=6 |
||||||||||||||||||||
|
|||||||||||||||||||||
28.12.2014, 08:00 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl | Sei so lieb und gib den Code in Textform und nicht als Bild an, dann kann ich es auch ausführen ohne abtippen zu müssen. |
||||||||||||||||||||
28.12.2014, 08:04 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 |
|
||||||||||||||||||||
28.12.2014, 09:25 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl | Viel besser. Die erste Unstimmigkeit haben wir hier:
Es gibt die Variablen A.a und B.a.
ruft aber den Konstruktor der Elternklasse auf und setzt somit das A.a, währed B.a auf dem Anfangswert 0 bleibt. Bei B.getA() wird daher eine 0 zurückgegeben. o1.add(o2) macht also 2+0 = 2
Ist ein B.add(A). Da B diese Funktion nicht anbietet (hat nur B.add(B)), wird A.add(A) aufgerufen. this.getA() ist daher 3, b.getA() liefert eine 0 (Begründung siehe oben)
greift zweimal auf B zu, also 0 + 0 = 0. |
||||||||||||||||||||
Anzeige | |||||||||||||||||||||
|
|||||||||||||||||||||
28.12.2014, 09:49 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 | ich sehe gerade, dass in der überschritt des übungsblattes steht : Interface kann man das verstehen ohne Interface behandelt zuhaben? |
||||||||||||||||||||
28.12.2014, 10:05 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl | Es geht hier um Vererbung und Polymorphie, um das zu verstehen, musst du keine Interfaces kennen. |
||||||||||||||||||||
28.12.2014, 10:51 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 | ich tun mich das alles nach zuvollziehen (o1.add(o2)); wieso wird hier ruft aber den Konstruktor der Elternklasse auf und setzt somit das A.a, aber wieso? ich verstehe auch nicht wieso es die Variablen A.a und B.a. gibt? |
||||||||||||||||||||
28.12.2014, 11:01 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 | A o3 = new B(4); was genau macht das? |
||||||||||||||||||||
28.12.2014, 11:32 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl |
die Klassen haben beide eine Variable namens a, aber es sind trotzdem 2 verschiedene Variablen. Dabei verdeckt B.a A.a. Deshalb liefert B.getA() immer 0.
legt ein B Objekt an und speichert einen Verweis auf ein A Objekt ab. |
||||||||||||||||||||
28.12.2014, 11:45 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 | legt ein B Objekt an und speichert einen Verweis auf ein A Objekt ab d.h wenn ich eine Methode mit A o3 = new B(4); 03.beliebigeMethode aufrufe dann wird die beliebigeMethode von B aufgerufen, da es sich um ein Objekt aus B handelt? wird hingegen haben wir public int(A a) und public int(B b), dann wird public int(A a) ausgeführt? |
||||||||||||||||||||
28.12.2014, 11:57 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl |
Bei o2.add(o3) wird o2.add(B b) aufgerufen, da o3 ein B ist. o3 verhält sich wie ein B. Einen Unterschied gibt es aber: die main kennt o3 als A und erlaubt daher nur, dessen Funktionen aufzurufen.
ruft die Funktion add der Klasse A auf, da o3 in der main als A und nicht als B bekannt ist. Mein Rat: hole dir NetBeans/eclipse und gehe das Programm mit Hilfe des Debuggers Zeile für Zeile durch, dann siehst du, wann welche Funktion aufgerufen wird. |
||||||||||||||||||||
28.12.2014, 12:18 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 |
wieso ist einmal B.add(A). und dann B.add(B) und was genau ist die main im Programm? |
||||||||||||||||||||
28.12.2014, 12:50 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl | das ist die main:
Ich tue mir gerade schwer, wie ich das erklären soll, hilft dir das weiter? Javainsel |
||||||||||||||||||||
28.12.2014, 13:14 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 | o1.add(o2) das problem was ich habe ist folgendes 01 ist von A und damit o1.add(o2) auf etwas zugegriffen, was eig nicht in der klasse A gibt System.out.println(o2.add(o2)); //0 das habe ich verstanden System.out.println(print(o3)); die main nimmt es als 03 als A auf also wird public static String print(A a){ return "Parameter A: " + a.toString(); } aus geführt? bei a.toString wird aber aber auf B klasse zugegriffen also Paramerter A: ich bin ein B |
||||||||||||||||||||
28.12.2014, 13:21 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl | [qoute]o1 ist von A und damit o1.add(o2) auf etwas zugegriffen, was eig nicht in der klasse A gibt [/quote] aber o2 ist ja als B nichts anderes als ein abgeleitetes A. Daher kann es verwendet werden (wenn es in A eine Funktion add(B) geben würde, würde die genommen werden. Gibt es aber nicht, also die zweitbeste Lösung, die ein A erwartet. toString() gibt es für 2 Klassen (eigentlich für 3, auch für Object, von dem A erbt). o3 ist von Typ B, ruft also B.toString() auf. Hätte B noch eine Funktion, die A nicht besitzt, könntest du sie in der main nicht aufrufen, da o3 dort als A deklariert ist. |
||||||||||||||||||||
29.12.2014, 04:21 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 | wie nimmt das allg Prinzip das hinter diesen Prozess steht? |
||||||||||||||||||||
29.12.2014, 07:56 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl | Das nennt sich Polymorphie. |
||||||||||||||||||||
08.01.2015, 06:07 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 | [quote]Original von eulerscheZahl Viel besser. Die erste Unstimmigkeit haben wir hier:
Es gibt die Variablen A.a und B.a.
ruft aber den Konstruktor der Elternklasse auf und setzt somit das A.a, währed B.a auf dem Anfangswert 0 bleibt. Bei B.getA() wird daher eine 0 zurückgegeben. o1.add(o2) macht also 2+0 = 2 [quote] "Bei Attributen tritt dabei der Effekt der Versteckens auf: Das Attribut der Vaterklasse ist in der abgeleiteten Klasse nicht mehr sichtbar" genau das haben wir hier vorliegen, auf das Attribute this.a ist nicht mehr sichtbar in der Vaterklasse. muss in der abgeleiteten klasse Es ist nicht erlaubt, den Default-Konstruktor aufzurufen, obwohl ein expliziter Konstruktor in der Vaterklasse vorhanden ist und der Default-Konstruktor nicht existiert was wenn in der vaterklasse public class A { private int a; public A(){ // ohne in klammern int a this.a = a; } und muss eine abgeleitet klasse stets mit super beginnen also ich mein public class B extends A { private int a; public B(int a){ super(a);// ohne super obwohl in der vaterklasse ein -Konstruktor vorhanden ist } |
||||||||||||||||||||
08.01.2015, 06:09 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 | "Bei Attributen tritt dabei der Effekt der Versteckens auf: Das Attribut der Vaterklasse ist in der abgeleiteten Klasse nicht mehr sichtbar" genau das haben wir hier vorliegen, auf das Attribute this.a ist nicht mehr sichtbar in der Vaterklasse. und deshalb ist this.a nicht mehr sichtbar in B ?? |
||||||||||||||||||||
08.01.2015, 06:35 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl | zum Verstecken: ja, genau das ist der Fall. Aber this.a ist weiterhin vorhanden - nur einen ein anderes a. Nämlich das der Kindklasse.
wenn kein a an die Funktion übergeben wird, dann ist this.a nur eine andere Schreibweise für a. Und da der Initialwert (und somit aktuelle Wert) 0 ist, setzt du ihn erneut zu 0. super(a) ruft den Konstruktor der Elternklasse auf. Das ist nicht verpflichtend, kommt eben darauf an, welches Verhalten du erzielen willst. |
||||||||||||||||||||
08.01.2015, 06:42 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 |
und der einzige zugriff this.a erfolgt durch den befehl super, richtig? |
||||||||||||||||||||
08.01.2015, 06:45 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl | Ja, das ursprüngliche a kriegst du nur über super.a - oder besser gesagt über super.getA(), da a ja private ist. |
||||||||||||||||||||
08.01.2015, 06:48 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 | noch eins das in der klasse A def funktion public int getA(){ return this.a; kann nun jede beliebig klasse zugriffen werden mit super.getA()? |
||||||||||||||||||||
08.01.2015, 13:51 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl | Wenn Klasse B von A erbt, kannst du mit super.getA() darauf zugreifen. Wenn Klasse C von B erbt und B und C ebenfalls ein getA() haben, wirst du an A.getA() nicht mehr herankommen. Ein super.super gibt es nicht. Außerhalb der Klasse geht das auch nicht: B b = new B(2); b.super.getA(); geht also auch nicht. |
||||||||||||||||||||
24.01.2015, 01:37 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
neuling96 |
bestimme den wert von o3.n() o3.n() ist =2 (überschreiben effekt) jetzt soll die Methode int n() von A ausgeklammert werden was liefert nun o3.n() die main kennt o3 als A, allerdings wird erst zur lauzeit entscheiden, welche methode ausgeführt, aber in A gibt es int n () nicht mehr ich denke der Compiler überprüft vor der laufzeit ob überhaupt die Methode enthalten ist?? (ist geraten) und damit geht es nicht, weil int n() nicht in A gibt?? |
||||||||||||||||||||
24.01.2015, 09:06 | Auf diesen Beitrag antworten » | ||||||||||||||||||||
eulerscheZahl | Der Compiler stellt zwar fest, ob A die Methode n() hat, weshalb sich das Programm auch nicht starten lässt. Aber mit Laufzeit hat das nichts zu tun (das ist auch nicht Aufgabe des Compilers, sonst könntest du dir Laufzeitfehler ja auch schon beim Compilieren anzeigen lassen). |
|
Verwandte Themen
Die Beliebtesten » |
|
Die Größten » |
Die Neuesten » |