Indie 2D-Game-Maker (Arbeitstitel: Brickwork)

[Whiz-zarD]

Man könnte natürlich die klassische Vererbung von alt bekannten Programmiersprachen einführen und erlauben, dass ein Typ einen anderen Typen erweitert. Das sollte in diesem Fall sogar mit Mehrfach-Vererbung funktionieren.

...

Du weißt aber hoffentlich auch, was das Problem bei Mehrfachvererbung ist, und wieso dies auch fast keine Programmiersprache unterstützt, oder?
Das Implementieren von Interfaces ist nur ein Workaround, um so was ähnliches, wie eine Mehrfachvererbung realisieren zu können. Auch wenn man immer wieder Interfaces mit Mehrfachvererbung in Verbindung bringt (besonders in der deutschen Literatur), haben Interfaces primär nichts mit Mehrfachvererbung zu tun. Sie dienen dafür, Klassen klar zu definieren. Angenommen wir möchten Klassen entwickeln, die Daten in unterschiedliche Dateiformate speichert. Eine Klasse speichert die Daten ins XML-Format und eine andere Klasse ins CSV-Format. Mit einem Interface legen wir dann die Methoden fest, die beide Klassen implementieren sollen, damit wir beide Klassen auf die selbe Art und Weise ansprechen können. Klar kann dabei eine Klasse mehrere Interfaces implementieren, aber selbst das hat so seine Tücken. Angenommen wir haben zwei Interfaces, die den selben Methodenamen definieren, aber beide Methoden was anderes machen. In der Klasse selber steht uns aber nur eine einzige Methode zur Verfügung. Um der Sache noch eine Krone aufzusetzen, geht man noch einen kleinen Schritt weiter, und nennt dies das Diamond-Problem.

Es ist also falsch, ein Java-Beispiel für Mehrfachvererbung zu zeigen, weil Java so was überhaupt nicht kann, und auch kein Konzept dafür vorsieht. Wie gesagt, das Implementieren von Interfaces ist nur ein Workaround, und führt sogar zu Codeverdoppelung, die man aufgrund von Objektorientierung vermeiden möchte. Im Schlimmsten Fall führt diese Art von Mehrfachvererbung sogar zu Inkonsistenzen, wenn man anfängt die Methoden zu ändern. Dann müssen diese Methoden wieder überall geradegebogen werden, was je nach Komplexität schwierig werden kann.

Wenn ich sowas wie Mehrfachvererbung brauche (was aber bis jetzt noch nie vorgekommen ist), würde ich es wohl so realisieren:

Code:

public interface A
{
    void MethodeA();
}

public interface B
{
    void MethodeB();
}

public class AImpl implements A
{
    public void MethodeA()
    {
        ...
    }
}

public class BImpl implements B
{
    public void MethodeB()
    {
        ...
    }
}

public class C implements A, B
{
    private AImpl a = new AImpl();
    private BImpl b = new BImpl(); 

    public void MethodeA()
    {
       this.a.MethodeA();
    }

    public void MethodeB()
    {
       this.b.MethodeB();
    }
}

So kann ich wenigstens sicher sein, dass eine Methodenänderung in AImpl oder BImpl auch in C greift, da C hauptsächlich nur noch aus Wrapper-Methoden besteht. Das Diamond-Problem besteht aber weiterhin.

Ich bin mal gespannt, wie du diese Probleme lösen willst.

Edit:
Wenn man mein Beispiel für eine Mehrfachvererbung nun fortführt, dann kann man für C auch ein Interface bauen. In Java ist es z.B. möglich Interfaces zu erweitern:

Code:

public interface C extends A, B
{
    void MethodeC();
}

public class CImpl implements C
{
    private AImpl a = new AImpl();
    private BImpl b = new BImpl(); 

    public void MethodeA()
    {
       this.a.MethodeA();
    }

    public void MethodeB()
    {
       this.b.MethodeB();
    }

    public void MethodeC()
    {
       // tu was
    }
}

Wenn du deine Typen und Komponenten so implementierst, wie in meinen Code-Schnipseln, dann wirst du erkennen, dass die Typen und Komponenten das selbe sind. Beide haben ein Interface und eine Klasse, die das Interface implementieren, und du fügst die Klassen mittels Wrapper-Methoden zusammen.