Verebung |
neuling96 unregistriert
|
|
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
|
|
30.12.2014 04:06 |
|
|
Karlito
Kaiser
Dabei seit: 11.04.2011
Beiträge: 1.461
|
|
Ich zweifel an Zeile 8 der Kommentare! Habe es mir aber noch nicht genau angeschaut...
Gruß,
Karlito
|
|
30.12.2014 14:41 |
|
|
|
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.
__________________ Syntax Highlighting fürs Board (Link)
|
|
30.12.2014 14:49 |
|
|
Karlito
Kaiser
Dabei seit: 11.04.2011
Beiträge: 1.461
|
|
Ah, jo, supi, danke Dir!
Gruß,
Karlito
|
|
30.12.2014 20:23 |
|
|
Tim0 unregistriert
|
|
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?
|
|
30.12.2014 22:42 |
|
|
Tim0 unregistriert
|
|
was macht die Funktion o1.setA(3)?
die gibt es doch gar nicht?
|
|
30.12.2014 22:50 |
|
|
|
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.
__________________ Syntax Highlighting fürs Board (Link)
|
|
31.12.2014 07:10 |
|
|
neuling96 unregistriert
|
|
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?
|
|
31.12.2014 08:30 |
|
|
|
Die Prüfung der Methodenaufrufe zur Laufzeit ist richtig. Den anderen Teil kann ich dir leider nicht beantworten, dazu reicht mein Wissen nicht aus.
__________________ Syntax Highlighting fürs Board (Link)
|
|
31.12.2014 15:34 |
|
|
|