| Die letzten 10 Beiträge |
| eulerscheZahl |
Die Prüfung der Methodenaufrufe zur Laufzeit ist richtig. Den anderen Teil kann ich dir leider nicht beantworten, dazu reicht mein Wissen nicht aus. |
| neuling96 |
methoden werden dynamisch gebunden,. es wird also zur laufzeit festgestellt, aus welchem objekt die methode genommen wird und bei überladenen methoden wird aber schon zur compilezeit ausgewählt
habe ich das soweit richtig verstanden? |
| eulerscheZahl |
Nein, setA() gibt es nicht, sollte nur ein Beispiel sein.
swap müsste so aussehen:
| code: |
1:
2:
3:
4:
5:
6:
|
public static void swap(A a1, A a2) {
A c = a2;
a2 = a1;
a1 = c;
a1.add(a2); //a1 und a2, o ist hier unbekannt.
} |
|
| Zitat: |
| swap(o1, o2);// hat zur folge dass nach Ausführung 02.a= 3 folgt |
stimmt. |
| Tim0 |
was macht die Funktion o1.setA(3)?
die gibt es doch gar nicht? |
| Tim0 |
Mal angenommen swap sehe so aus:
public static void swap(A a1, A a2) {
A c = a2;
a2 = a1;
a1 = c;
o1.add(o2);
}
public static void main(String[] args) {
A o1 = new A(1);
B o2 = new B(2);
A o3 = new B(o1.getA() + o2.getA() + o2.getB());
swap(o1, o2);// hat zur folge dass nach Ausführung 02.a= 3 folgt
und das behalten wird!
habe ich das richtig erfasst? |
| Karlito |
Ah, jo, supi, danke Dir!
Gruß,
Karlito |
| eulerscheZahl |
Du meinst swap(o1, o2);?
Es werden zwar die Adressen an die Funktion übergeben, die aber wiederum per value und nicht per reference.
Das heißt, wenn man in der Funktion schreibst o1.setA(3), hat das Auswirkungen. Wenn man die Referenzen tauscht nicht, da die nach Ausführung der Funktion wieder gelöscht werden. |
| Karlito |
Ich zweifel an Zeile 8 der Kommentare! Habe es mir aber noch nicht genau angeschaut...
Gruß,
Karlito |
| eulerscheZahl |
Glückwunsch, die Kommentare stimmen alle 
|
| neuling96 |
Verebung
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
|
class C {
public static String print(A a) {
return "A: " + a.toString();
}
public static String print(B b) {
return "B: " + b.toString();
}
public static void swap(A a1, A a2) {
A c = a2;
a2 = a1;
a1 = c;
}
public static void swap(A[] as, int index1, int index2) {
A c = as[index2];
as[index2] = as[index1];
as[index1] = c;
}
public static void main(String[] args) {
A o1 = new A(1);
B o2 = new B(2);
A o3 = new B(o1.getA() + o2.getA() + o2.getB());
swap(o1, o2);
swap(o2, o3);
A[] as = { o1, o2, o3 };
swap(as, 0, 1);
swap(as, 1, 2);
o1.add(o2);
o3.add(o2);
o2.add(o3);
o3.add();
System.out.println(print(o1));
System.out.println(print(o2));
System.out.println(print(o3));
A a1 = as[o1.getA() % as.length];
A a2 = as[o2.getA() % as.length];
A a3 = as[o3.getA() % as.length];
System.out.println(print(a1) + a1.getA());
System.out.println(print(a2) + a2.getA());
System.out.println(print(a3) + a3.getA());
}
}
public class B extends A{
private int b;
public B(int wert) {
super(wert);
}
public void add(B b) {
this.b += b.getA();
}
public void add() {
this.b += 2;
}
public int getB() {
return this.b;
}
public String toString() {
return "B" + this.getB();
}
}
public class A {
private int a;
public A(int wert) {
this.a = wert;
}
public void add(A a) {
this.a += a.getA();
}
public void add() {
this.a += 1;
}
public int getA() {
return this.a;
}
public String toString() {
return "A" + this.getA();
}
}
|
|
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
|
class C {
public static void main(String[] args) {
A o1 = new A(1); // o1.a=1
B o2 = new B(2); // o1.a=2
A o3 = new B(o1.getA() + o2.getA() + o2.getB()); //o3.a=o1.a+o2.a+o2.b = 1+2+0 = 3
swap(o1, o2); // bewirkt nichts, da in swap() nur referenzen der eigenen variablen ausgetauscht werden
swap(o2, o3);
A[] as = { o1, o2, o3 };
swap(as, 0, 1); // as = {o2,o1,o3}
swap(as, 1, 2); // as = {o2,o3,o1}
o1.add(o2); // o1.a= o1.a+o2.a=1+2=3
o3.add(o2); // o3.a= o3.a+o2.a=3+2=5
o2.add(o3); // o2.a=o2.a+o3.a=2+5=7
o3.add(); // o3.b=o3.b +2 = 2
System.out.println(print(o1)); // "A: A3" (o1.a)
System.out.println(print(o2)); // "B: B0" (o2.b)
System.out.println(print(o3)); // "A: B2" (o3.b)
A a1 = as[o1.getA() % as.length]; // A a1=as[3%3] = o2
A a2 = as[o2.getA() % as.length]; // A a2=as[7%3] = o3
A a3 = as[o3.getA() % as.length]; // A a3=as[5%3] = o1
System.out.println(print(a1) + a1.getA()); // "A: B"+o2.b+o2.a =>"A: B07"
System.out.println(print(a2) + a2.getA()); // "A: B"+o3.b+o3.a =>"A: B25"
System.out.println(print(a3) + a3.getA()); // "A: B"+o1.a+o1.a => "A: A33"
}
|
|
ich mich mit das thema nun verstärkt auseinander gesetzt und hoffe das passt jetzt |
|
|
