Verebung

Neue Frage »

Auf diesen Beitrag antworten »
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
 
Auf diesen Beitrag antworten »
eulerscheZahl

Glückwunsch, die Kommentare stimmen alle Daumen hoch
Auf diesen Beitrag antworten »
Karlito

Ich zweifel an Zeile 8 der Kommentare! Habe es mir aber noch nicht genau angeschaut...

Gruß,

Karlito
Auf diesen Beitrag antworten »
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.
 
Auf diesen Beitrag antworten »
Karlito

Ah, jo, supi, danke Dir!

Gruß,

Karlito
Auf diesen Beitrag antworten »
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?
Auf diesen Beitrag antworten »
Tim0

was macht die Funktion o1.setA(3)?
die gibt es doch gar nicht?
Auf diesen Beitrag antworten »
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.
Auf diesen Beitrag antworten »
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?
Auf diesen Beitrag antworten »
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.
 
Neue Frage »
Antworten »


Verwandte Themen

Die Beliebtesten »
Die Größten »
Die Neuesten »