Jeder echte Beispiel für die Verwendung der Schnittstelle mit mehreren Vererbung

Schreibe ich ein video-Spiel. In diesem video-Spiel, das ich für die verschiedenen Kräfte, um Objekte im Spiel. Schub Kräfte, Kräfte, Gravitationskräfte. Sie werden zwar unterschiedlich berechnet, Sie haben alle den gleichen grundlegenden Elementen. Muss ich anrufen eine update-Funktion, die wird die Bewertung der Kraft, und fügen Sie die Kraft auf das Objekt, das es angefügt wurde.

So, was ich getan habe ist, erstellen Sie ein IForce-interface, das eine update-Funktion für seine Unterschrift. Alle meine Kräfte, die diese Schnittstelle implementieren:

public interface IForce
{
    void Update(Particle particle, GameTime gameTime);
}

Hier ist eine Beispiel-Implementierung.

public class Spring : IForce
{
    private Particle ThisParticle;
    private Particle ThatParticle;

    private float K;

    public Spring(Particle thisParticle, Particle thatParticle, float k)
    {
        ThisParticle = thisParticle;
        ThatParticle = thatParticle;
    }

    public void Update(Particle particle, GameTime gameTime)
    {            
        float X = Vector3.Length(ThisParticle - ThatParticle);

        ThisParticle.Forces.Add(K * X);
    }
}

Die update-Funktion hat eine vereinfachte spring force update zu machen, es leichter zu verstehen.

Hilft dies in ein paar Möglichkeiten.

Ich kann völlig verändern die Art und Weise wird eine Kraft berechnet, ohne Einfluss auf andere Teile von meinem code. Ich Mach das die ganze Zeit. Entlang den gleichen Linien, ist es rediculously einfach für mich, um neue Kräfte. Solange es implementiert die IForce-interface, ich weiß, es wird Masche auch mit meinem vorhandenen code.

Anderen Weg, es hilft bei der Handhabung einer großen Anzahl von Kräften. Ich habe eine Kraft, die Registrierung, die eine Liste von IForce. Da alle Kräfte implementieren, die Schnittstelle und haben eine Update-Funktion ist es sehr einfach zu aktualisieren, alle Kräfte in meinem Spiel. Wenn ich die Kraft, die ich zur Liste hinzufügen. Dann habe ich eine Schleife durch die Liste und rufen Sie die einzelnen Elemente update-Funktion, ohne sich Gedanken über welche Art von Kraft es ist, und alle meine Kräfte update.

Ich die Verwendung von Schnittstellen, die jeden Tag in vielen verschiedenen Situationen. Sie sind fantastisch!

Schnittstellen definieren Sie einfach eine Vertrag der öffentlichen Elemente (z.B. Eigenschaften, Methoden, Ereignisse) für das Objekt, nicht Verhalten.

interface IDog
{
    void WagTail();    //notice no implementation
    ISound Speak();    //notice no implementation
}

class Spaniel : IDog
{
    public void WagTail()
    {
        Console.WriteLine("Shook my long, hairy tail");
    }

    public ISound Speak()
    {
        return new BarkSound("yip");
    }

}

class Terrier : IDog
{
    public void WagTail()
    {
        Console.WriteLine("Shook my short tail");
    }

    public ISound Speak()
    {
        return new BarkSound("woof");
    }
}

UPDATE

In der "realen Beispiele" verwende ich interfaces mit:
- Unit Testing
- GENERIKA (z.B. Repository -, Gateway-Einstellungen)

interface Repository<T>{
    T Find(Predicate<T>);
    List<T> ListAll();
}

interface Gateway<T>{
    T GetFrom(IQuery query);
    void AddToDatabase(IEntity entityItem);
}

interface Settings<T>{
    string Name { get; set; }
    T Value { get; set; }
    T Default { get; }
}

Mehrfache Vererbung ist über eine Klasse verwendbar, in mehreren Situationen: [pseudo-code]

interface Shape {
    //shape methods like draw, move, getboundingrect, whatever.
}

interface Serializable {
    //methods like read and write
}

class Circle : public Shape, public Serializable {
    //TODO: implement Shape methods
    //TODO: implement Serializable methods
}

//somewhere later
{
    Circle circle;
    //...
    deserializer.deserialize(circle);
    //...
    graphicsurface.draw(circle);
    //...
    serializer.serialize(circle);
}

Die Idee ist, dass Sie Ihre Circle-Klasse implementiert zwei verschiedene Schnittstellen, die verwendet werden, in sehr unterschiedlichen Situationen.

Die einfache Antwort, meiner Meinung nach, und etwas neues zu interfaces selbst ist, die Implementierung einer Schnittstelle in einer Klasse bedeutet im wesentlichen: "Diese Klasse definieren MÜSSEN, die Funktionen (und die Parameter) in die Schnittstelle".

Aus, dass, folgt, dass, wenn eine bestimmte Klasse, die die Schnittstelle implementiert, können Sie sicher sein, Sie sind in der Lage, die Funktionen aufgerufen.

Wenn mehrere Klassen, die sonst anders implementieren die gleiche Schnittstelle, können Sie 'Stimmen' Sie alle in die Schnittstelle, und rufen Sie alle interface-Funktionen auf Sie, die könnte verschiedene Auswirkungen haben, da jede Klasse eine andere Implementierung der Funktionen.

Zum Beispiel, ich habe ein Programm erstellt, welches es ermöglicht, einen Benutzer zu generieren 4 verschiedene Arten von Karten. Für die, die ich angelegt habe 4 verschiedene Art von generator-Klassen. Sie alle implementieren das "IGenerator" - Schnittstelle wenn:

public interface IGenerator {
    public void generateNow(int period);
}

Erzählt, die Sie zum definieren von mindestens einem "öffentlichen generateNow(int Zeit)" - Funktion.

Was auch immer-generator, die ich ursprünglich hatte, nachdem ich warf es auf ein "IGenerator", die ich anrufen kann "generateNow(4)" auf. Ich will nicht, um sicher zu sein, welche Art von generator kehrte ich zurück, was im wesentlichen bedeutet, nicht mehr "variable instanceof-Class1", "variable instanceof Class2" etc. in eine gigantische if-Anweisung nicht mehr.