Klausuraufgabe Aufruflogik

[Guardi]

Hallo, ich schreibe demnächst meine erste Java-Klausur und mein Prof denkt sich sehr gerne möglichst unübersichtlichen Code aus den man dann lesen soll um dann die aufgerufenen Objekte/Attribute herauszufinden. Was das pragmatische Programmieren angeht schätze ich mich als nicht so schlecht ein, mit diesen teils für mich seltsamen Aufrufen weiß ich nicht immer was anzufangen. Wenn mir mal jemand erläutern könnte

Eine Aufgabe wäre z.B.

	class A {
		int i = 2;
		A() { System.out.println ("A"); }
		void f (A a ) { System.out . println ( i ); }
		}
		class B extends A {
		int j = 3;
		B () { System.out.println ("B"); }
		void f (A a ) { System.out . println ( j ); }
		void f (B a ) { System.out . println ( 2*j ); }
		}
		class Main1 {
		public static void main(String [] args ) {
		A a = new B();
		A b = new A();
		B c = new B();
		a. f (b );
		b. f (a );
		c. f (c );
		} }

Die Konstuktoraufrufe sind mir klar.
Was mir nicht so klar ist sind die Punktoperatoren. Das Ergebnis wäre hier 3,2,6. Wie muss ich vorgehen um auf dieses Ergebnis zu kommen, was wird wann aufgerufen etc.
Auch wenn ich mir ungefähr denken kann wie die Werte zustande kommen.

Eine andere Möglichkeit wäre dieses hier:

public class Attribute {
	
	public static void main(String[] args) {
	
	class A extends Attribute {
		
		public int i ;
		A(int i ) { this . i=i ; }
		void f(A a ) { i=a. i +1; }
		void g(A a ) { a. i=this . i +2; }
		void h(A a ) { a = new A(a.i +3); }
		}
	
	
		A x = new A(2), y = new A(3);{
			
		x.f(y);
		x.g(y); 
		x.h(y); 
		
		System.out.println(x.i);
		System.out.println(y.i);
		
		}
}
}

Hier weiß ich zwar auch durchs Kompilieren dass x.i = 4 und y.i 6 sind, aber wie zum Henker man darauf kommt weiß ich nicht. Wo muss ich hier bei den Punktoperatoren starten, wie geht es dann weiter?

Ich weiß natürlich generell wie Punktoperatoren Funktionieren: object.attribute/methode
Ich habe aber Probleme bei diesem Code genau herauszufinden wie das zu den bestimmten Ergebnissen führt.

Über ein bisschen Hilfe oder Tipps würde ich mich sehr freuen.

 

[mahe]

Erstmal solltest Du den Code ordentlich formatiert ansehen. Sonst verwirrt man sich nur (ich weiß, dass es bei der Klausur möglicherweise nicht geht, aber trotzdem!).

Eigentlich ist es sehr einfach. Du musst nur die Beziehungen der Objekte (Vererbung) berücksichtigen und wissen wie Polymorphie und überladene Methoden funktionieren.

Wenn das Objekt ein B ist und B von A abgeleitet ist, werden die Funktionen immer zuerst in B und dann in A gesucht. Unabhängig davon wie die Variable, in der die Referenz gespeichert ist, definiert ist. Dann musst Du genau darauf achten, welche Methoden überhaupt passen (Parametersignatur).

Wenn Du das Programm von oben nach unten durcharbeitest und die Werte immer mitnotierst, müsstest Du hinkommen :wink:

Ich finde solche Klausuren toll weil immer die Hälfte der Leute völlig die Nerven verliert

 

[0x7F800000]

Ich finde solche Klausuren toll weil immer die Hälfte der Leute völlig die Nerven verliert

ich find solche Klausuren sinnfrei und öde :?

 

[hdi]

Ja so eine Aufgabe kam bei uns damals auch dran und deswegen sind sehr viele Leute durchgefallen.

mahe hat schon gesagt, wie man sowas löst:

Ruhe bewahren, Schmierzettel zur Hand nehmen, und für jede Zeile überlegen:

1) Ist die Methode die hier aufgerufen wird, oder die Variable die gelesen/geschrieben wird in dieser
Klasse definiert?
2) Wenn ja, bezieht es sich auch auf genau diese MEthode/Variable in dieser Klasse.
3) Wenn nein, muss es eine Methode/Variable der OBerklasse sein, die geerbt wurde. Es wird dann also
die Methode bzw. Variable der Oberklasse genutzt.
Allerdings werden ja alle Dinge geerbt, sprich wenn du in der Oberklasse das Attribut "a" änderst, ist es auch
in der Unterklasse geändert, sofern es dort nicht überschrieben ist
4) Wenn diese Methode/Variable sowohl in der Oberklasse als auch in der Unterklasse definiert ist, dann
redet man von "Override", dabei gilt dann das gleiche wie bei 2)
5) Wenn explizit ein "super." vor etwas steht, bezieht sich das IMMER auf die Oberklasse, egal ob die Unterklasse
irgendwas überschrieben hat oder nicht
6) Bei Methoden muss man nicht nur auf den Namen achten, sondern auf die Paramter. Das nennt sich "Überladen":

public void überladeneMethode(int i){ 
       System.out.println(i);
}
public void überladeneMethode(String s){
       System.out.println(s);
}

Es wird also die Methode aufgerufen, die mit den Parametern matcht. Häufig wird hier sowas gemacht, dass
es in der Unterklasse eine Methode der Oberklasse gibt (vom Namen her) aber mit anderen Parametern.
Hier muss man dann halt aufpassen was nun passiert: 2) oder 3)

Und wenn man das alles so macht, kriegt man auch das richtige raus