Zusatzaufgabe: Polymorphie mit parametrisierten Klassen (Generics)

Die Java-Dateien der Polymorphie-Aufgaben aus dem Crashkurs findest du hier.
Die unkommentierte Lösung zu dieser Aufgabe findest du hier, ein Objektdiagramm hier.

public class GenericPoly {
   static class A<T extends B> {
      protected T e;
      public void set(T elem) { e = elem; }
      void f(B b) { System.out.println("A.f(B)"); }
      void f(C<E> c) { System.out.println("A.f(C)"); e.f(e); c.f(e); }
      void g(F f) { System.out.println("A.g(F)"); }
   }
   static class B extends A<B> {
      public B() { set(this); }
      void f(C<E> c) { System.out.println("B.f(C)"); }
      void f(F f) { System.out.println("B.f(F)"); this.g(f); }
   }
   static class C<R extends E> extends B {
      public R e;
      public C(R r) { this.e = r; }
      void f(B b) { System.out.println("C.f(B)"); }
      void f(A<C<E>> a) { System.out.println("C.f(A)"); a.f(this); }
      void g(F f) { System.out.println("C.g(F)"); e.g(f); }
   }
   static class D extends A<C<E>> implements E {
      protected A<B> e;
      public D() { e = new C<D>(this); }
      public void f(D d) { System.out.println("D.f(D)"); e.f(super.e); }
      public void g(F f) { System.out.println("D.g(F)"); }
      public void g(E e) { System.out.println("D.g(E)"); }
   }
   interface E {
      void g(E e);
   }
   static class F extends D {
      void f(A<C<F>> a) { System.out.println("F.f(A)"); this.f(a.e); }
      public void f(D d) { System.out.println("F.f(D)"); super.f(this); }
   }
   public static void main(String[] args) {
      A<C<F>> a = new A<>();
      C<F> c = new C<>(new F());
      a.set(c);
      D d = c.e;
      d.f(c);       // Aufruf 1
      c.f(a.e);     // Aufruf 2
      d.f(a);       // Aufruf 3
      d.f(d);       // Aufruf 4
      c.f(d);       // Aufruf 5
      d.e.f(c);     // Aufruf 6
      ((F)d).f(a);  // Aufruf 7
      c.f((F)d);    // Aufruf 8
      a.f(((A<C<E>>)d).e);  // Aufruf 9
   }
}

Es geht um den Aufruf a.f(this): a ist dynamisch nicht C sondern A!

• thisist statisch C, weil wir in der Klasse C sind, und dynamisch ebenfalls C, weil beim vorherigen Aufruf  (c.f((C)c)) ein C-Objekt vor dem Punkt stand, d. h. wir operieren auf einem C-Objekt.
• Nachdem wir also auf einem C-Objekt operieren, handelt es sich bei a um das Attribut a des C-Objekts, das ursprünglich durch A a = new A() innerhalb des A-Kontruktors mit new C(this) erzeugt wurde . Dort wird this (also während der Erzeugung von A das A-Objekt selbst) übergeben. Das C-Objekt speichert sich genau dieses A-Objekt in seinem Attribut a ab (mittels this.a = a), d. h. das hier verwendete a hat den dynamischen Typ A (und zwar genau das A-Objekt, das auch in der main-Methode gespeichert wird).

Daher suchen wir in A eine Methode f(C), finden statisch f(B) und führen diese Methode auch aus.

Der Aufruf 8 kommt ja irgendwann zu e.g(f). Der statische Typ von e ist hier jedoch nicht F sondern E. Grund dafür ist Type Erasure, weil der Aufruf innerhalb von C<?> stattfindet. Der Compiler weiß nicht, dass wir hier fix in C<F> sind (wir könnten irgendwann ja auch mal in C<D> sein). Der statische Typ muss für einen bestimmten Kontext aber immer fix sein. Deshalb wird für e der allgemeinste mögliche Typ genommen und das ist E (wegen C<R extends E>). Dann suchen wir g(F) in E, finden dort g(E) und überschreiben es anschließend in F.

Das Attribut bestimmten wir immer über den statischen Typ, also den Typ der Variable, von der wir auf ein Attribut zugreifen bzw. von der Klasse, in der wir uns befinden. Bei d.e ist der statische Typ von d bspw. D (dynamisch F), also wollen wir im F-Objekt die Variable e. Dort gibt es zwei, weil F das e Attribut aus D und A erbt. Wir wählen das aus D geerbte e, weil der statische Typ von d D ist, also besteht nur Zugriff auf die Variablen aus D und Oberklassen von D.