diff --git a/generics2.md b/generics2.md
index b1507a7..8db33e5 100644
--- a/generics2.md
+++ b/generics2.md
@@ -12,7 +12,7 @@ footer: Henri Burau
 
 # Grundlagen
 
-Durch Generizität können wir Typen, Klasse und Methode parametrisieren. Der
+Durch Generizität können wir Typen, Klasse und Methoden parametrisieren. Der
 genutzte Typ wird dann zur Laufzeit übergeben. 
 
 Genutzt wird dieses Sprachkonzept z.B. im Collection Framework.
@@ -36,7 +36,7 @@ String result = test.gibHer(test);
 
 Der Java-Compiler entfernt alle generischen Parameter und arbeitet dann auf den
 **Raw Types**. Dieser Vorgang wird **Type Erasure** genannt. Das führt zu
-Beschränkungen zur Laufzeit:
+Einschränkungen zur Laufzeit:
 
 * Generische Klassen können keine statischen Felder haben
 * Es können keine Instanzen aus generischen Typen erzeugt werden
@@ -80,6 +80,8 @@ class ListenSchreiber {
 }
 ```
 
+Warum wird hier nicht der Parameter-Typ ``List<Object>`` genutzt?
+
 --- 
 
 ## Lower Bounds
@@ -96,6 +98,9 @@ class IntegerSammler {
     }
 }
 ```
+
+Welche Typen akzeptiert der Compiler für den Parameter ``liste``?
+
 ---
 
 ## Upper Bounds
@@ -113,6 +118,13 @@ class Sortierer {
 }
 ```
 
+Welche Typen akzeptiert der Compiler für den Parameter ``liste``?
+
 ---
 
 # Aufgaben
+
+1) Wann benutzt man ``super`` und wann ``extends`` ?
+    * "Producers Extend, Consumers Super". [Java Guidelines](https://docs.oracle.com/javase/tutorial/java/generics/wildcardGuidelines.html)
+    * ``extends`` erlaubt das Aufrufen von Gettern, ``super`` von Settern
+
diff --git a/reflections.md b/reflections.md
index 8c816ca..23fd210 100644
--- a/reflections.md
+++ b/reflections.md
@@ -10,4 +10,51 @@ footer: Henri Burau
 
 ---
 
- 
+# Grundlagen
+
+Ermöglichen das Abfragen von Metainformationen zur Laufzeit. Dazu gehört der
+dynamische Typ eines Objekts, dessen Felder (private und öffentliche) und
+Methoden. Benutzt werden Reflections vor allem beim Datenaustausch in
+verteilten Systemen.
+
+---
+
+# Java Reflection API
+Die wichtigsten Klassen aus den Java Reflections sind:
+
+* ``Class``
+* ``Field``
+* ``Constructor``
+* ``Method``
+* etc. (siehe [Reflection API](<!-- TODO -->))
+
+---
+
+# Anwendung
+
+```java
+Dreieck dreieck = new Dreieck();
+Class<?> dreieckKklasse = dreieck.getClass();
+
+System.out.println(dreieckKlasse.getSimpleName());
+// Konsole: Dreieck
+```
+
+---
+
+# Benutzung
+
+Reflections sollten nur genutzt werden wenn es gar nicht anders geht. Man kann
+sonst schnell die schönen Objektstrukturen zerstören die ein Software-Architekt
+entwickelt hat.
+
+---
+
+# Aufgaben
+
+1) Schreibe eine statische Methode ``schreibKonstruktoren(Object object)``
+    welche die Parameter aller Konstruktoren von ``object`` auf die Konsole
+    schreibt (``System.out.println(...)``).
+    
+2) Schreibe eine statische Methode `schreibPrivateFelder(Object object)` welche
+    die Namen und Typen aller **privaten** und **statischen** Felder von `object` auf die Konsole schreibt.