\item[innere Klasse:] in \texttt{Outer} enthaltene, nicht statische Klasse \texttt{Inner}
\end{description}
\begin{enumerate}
\item flache Hierarchie durch Verschieben der inneren Klasse außerhalb der umgebenden Klasse(n): \texttt{Outer.Inner}$\rightarrow$\texttt{Outer\$Inner}
\item Konstruktor der inneren Klasse um Parameter ggf. erzeugen und um Parameter \texttt{Outer this\$i} ergänzen (mit $i$ als Schachtelungstiefe von \texttt{Outer}), zusätzlich gleichnamige Instanzvariable einfügen
\item Zugriffen auf Instanzvariablen von \texttt{Outer} ein \texttt{this\$i.} voranstellen
\item Hilfsmethoden für Zugriff auf private Instanzvariablen von \texttt{Outer} in \texttt{Outer} einfügen (mit aktueller Java-Version durch spezielles Attribut in Klassendatei nicht mehr notwendig)
\item Alle Auftreten von \texttt{Inner} durch \texttt{Outer\$Inner} ersetzen
\item Bei von \texttt{Inner} erbenden Klassen \texttt{(new Outer()).super();} im Konstruktor ergänzen, damit \text{Outer}-Instanz erzeugt wird
\item Bei in Blöcken deklarierten inneren Klassen wird der Zugriff auf finale (oder \enquote{effectively-final}) Variablen durch Ergänzen des Konstruktors um diese Variablen ermöglicht
\item Brückenmethoden einfügen, die \texttt{Object} zu \texttt{A} casten und dann eigentliche Implementierung aufrufen
\item Wenn Typparameter \texttt{A} einer Methode nicht aus den Argumenten ableitbar ist, Verwendung des abgeleiteten Typs \texttt{*}, der Untertyp aller Typen ist
\item code(\texttt{while e do st od}) $\rightarrow$$\texttt{jmp L}_\texttt{cond}$; $\texttt{L}_\texttt{true}$: code(\texttt{st}); $\texttt{L}_\texttt{cond}$: code(\texttt{e}, $\texttt{L}_\texttt{true}$, $\texttt{L}_\texttt{false}$); $\texttt{L}_\texttt{false}$:
\item\texttt{switch-case}: \begin{itemize}
\item\texttt{if}-Kaskade
\item\texttt{lookupswitch}: Tabelle aus $(c_i, \texttt{L}_i)$-Tupel von Konstante $c_i$ und Sprungziel $\texttt{L}_i$ wird durchsucht
\item\texttt{tableswitch}: Konstante wird als Index in Tabelle mit Sprungzielen (\enquote{jump table}) gewählt
\item Aufruf der geschachtelte Funktion mit Zeiger auf Aktivierungsrahmen der umschließenden Funktion (sog. statischer Vorgängerverweis SV)
\item bei Aufruf aus tieferer Schachtelungstiefe SV des Aufrufers ggf. bis zum relevanten Aktivierungsrahmen verfolgen
\end{itemize}
\item mit Display (gesondertes, globales Array) zur Speicherung der SV: \begin{itemize}
\item Bei Betreten von Funktion der Schachtelungstiefe $t$, ihren FP an Index $t$ im Display speichern und ggf. bereits bestehenden Wert einer Schwesterfunktion im eigenen Aktivierungsrahmen sichern
\item Durch statisch bekannte Schachtelungstiefe Größe des Displays zur Übersetzungszeit bekannt und Zugriff auf lokale Variablen aus umschließenden Kontext durch Dereferenzieren des SV aus statisch bekannter Position im Display
\end{itemize}
\item Funktionszeiger: auch Argumentwerte müssen mit Zeiger gespeichert werden
\item Attribute aus Oberklasse \texttt{O} liegen auch in Unterklasse \texttt{U} am selben statischen Offset zum Objektanfang $\rightarrow$ einfacher, statischer Zugriff
\item Objekt enthält Zeiger auf Klassendeskriptor
\item Klassendeskriptor enthält:\begin{itemize}
\item V-Table mit Adressen der Funktionen(Indizes in Tabelle wie Attribute)
\item Verweis auf Klassendeskriptor der Elternklasse
\item Verfolgung des Zeigers zum Klassendeskriptor
\item Index in V-Table im Klassendeskriptor ist für auszuführende Methode bereits vom Compiler bekannt
\item Indirekter Sprung
\end{enumerate}
\item Casts: \begin{itemize}
\item Upcasts können vom Übersetzer verifiziert werden
\item Downcasts müssen zur Laufzeit überprüft werden:\begin{itemize}
\item ohne Display: \begin{enumerate}
\item Verfolgung des Zeigers zum Klassendeskriptor
\item Vergleich des Klassendeskriptors des Objekts mit Klassendeskriptor der Zielklasse
\item Solange keine Übereinstimmung, Vergleich mit Klassendeskriptor der Elternklasse
\item Beim Erreichen von gesuchtem Klassendeskriptor ist Casts erlaubt, ansonsten Laufzeitfehler
\end{enumerate}
\item mit Display: \begin{enumerate}
\item (maximale) Vererbungstiefe statisch feststellbar $\rightarrow$ pro Klasse kann Array aus Oberklassen angelegt werden
\item Zur Überprüfung in Array vergleichen, ob an (statisch aus der Schachtelungstiefe bekannter) Position der Zielklasse wirklich Zielklasse eingetragen ist