---
title: 'Eine Sich-Selbst-Implementierung'
url: 'https://tutego.de/blog/javainsel/2013/09/eine-sich-selbst-implementierung'
markdown: 'https://tutego.de/blog/javainsel/2013/09/eine-sich-selbst-implementierung.md'
date: '2013-09-24'
description: 'Der Zusammenhang zwischen inneren Klassen und äußeren Klassen und wie sie sich gegenseitig implementieren können. Eine Klasse kann entweder von einer Klasse erben oder eine Schnittstelle erweitern. Es ergibt sich ein Sonderfall, wenn wir eine Schnittstelle implementieren, die innerhalb der eigenen …'
taxonomy:
  category:
    - Allgemein
---

# Eine Sich-Selbst-Implementierung

![Illustration einer tropischen Insel mit Palmen und einem hohen Berg](https://tutego.de/blog/javainsel/user/themes/tutego/images/insel-cover.jpg)# Java Blog für Programmierer

[Java Blog für Programmierer](https://tutego.de/blog/javainsel/)

## Eine Sich-Selbst-Implementierung

24.09.2013 · [Christian Ullenboom](https://tutego.de/blog/javainsel/author/admin/)

*Der Zusammenhang zwischen inneren Klassen und äußeren Klassen und wie sie sich gegenseitig implementieren können.*

Eine Klasse kann entweder von einer Klasse erben oder eine Schnittstelle erweitern. Es ergibt sich ein Sonderfall, wenn wir eine Schnittstelle implementieren, die innerhalb der eigenen Klasse liegt, die die Schnittstelle deklariert. Das sieht etwa so aus:

```java
class Outer implements Outer.InterfaceInner
{
  interface InterfaceInner
  {
  void knexDirDeineWelt();
  }

  public void knexDirDeineWelt()
  {
  }
}
```

Prinzipiell spricht erst einmal nichts gegen diese Implementierung. Innere Klassen, wie **`InterfaceInner`** eine ist, werden auf eine extra Klassendateien abgebildet, da es innerer Klassen beziehungsweise Schnittstellen sowieso nicht für die Laufzeitumgebung gibt. In unserem Fall könnte der Compiler die Datei *Outer$InterfaceInner* erzeugen. Im nächsten Schritt würde dann **`Outer`**diese Schnittstelle erweitern und wie im Beispiel eine Methode überschreiben.

So schön dies auch aussieht: Es funktioniert nicht. Frühe Compiler erlaubten diese Schreibeweise, aber sie führt zu zirkulären Abhängigkeiten.

```text
cyclic inheritance involving Outer
```

Wenn **`InterfaceInner`** zuerst übersetzt würde und dann **`Outer`**, wäre es noch zu verstehen, doch das Problem machen zum Beispiel Deklarationen in der inneren Klasse, die abhängig sind von der Äußeren. Wir könnten etwa den Rückgabewert von **`knexDirDeineWelt()`** ändern, dass es ein `Outer` Objekt zurückliefert.

```java
class Outer implements Outer.InterfaceInner
{
  interface InterfaceInner
  {
    Outer knexDirDeineWelt();
  }

  public void knexDirDeineWelt()
  {
  }
}
```

Jetzt sehen wir: Ohne **`InterfaceInner`** kein **`Outer`**, da dies **`knexDirDeineWelt()`** vorschreibt und ohne **`Outer`** kein **`InterfaceInner`**, da sonst der Rückgabewert nicht bekannt ist. Mitunter wäre das Problem noch lösbar, aber hier lässt der Compiler lieber die Finger von.

**Innere Klasse vor der äußeren**

Dass es nicht unmöglich ist, eine innere Klasse von der äußeren Abzuleiten zeigt folgendes Beispiel:

```java
interface I
{
  void boo();
  interface J extends I
  {
  }

  J foo();
}
```

Es ist problemlos möglich, dass die innere Schnittstelle die äußere erweitert. Im Gegensatz zum vorherigen Beispiel ist in diesem Fall die Problematik genau umgekehrt. Es ist auch möglich, dass eine innere Klasse eine äußere erweitert.

```java
class O
{
  class I extends O
  {
    void bar()
    {
    }
  }

  void bar() { }
}
```

Kategorien: [Allgemein](https://tutego.de/blog/javainsel/category/allgemein/)

[← Alle Beiträge](https://tutego.de/blog/javainsel/)

---

## Navigation

- Previous: [Automatisches Neuladen von Servlet-Seiten](https://tutego.de/blog/javainsel/2013/09/automatisches-neuladen-von-servlet-seiten.md)
- Next: [Session-Verwaltung in Servlets mit HttpSession](https://tutego.de/blog/javainsel/2013/09/session-verwaltung-in-servlets-mit-httpsession.md)