Eine Schnittstelle (englisch interface oder protocol) definiert in der objektorientierten Programmierung, welche Methoden in den unterschiedlichen Klassen u. Ä. vorhanden sind oder vorhanden sein müssen. Sie legt die Namen und die Signatur der Methoden, also die Parametertypen und den Rückgabetyp, fest.

Technische Details

Eine Schnittstelle gibt an, welche Methoden vorhanden sind oder vorhanden sein müssen. Zusätzlich zu dieser syntaktischen Definition sollte ein so genannter Kontrakt über die Bedeutung (Semantik) definiert werden, festgelegt als Vorbedingungen und Nachbedingungen der verschiedenen Methoden. Der Kontrakt wird meist nur informell in der Dokumentation oder einer externen Spezifikation der Schnittstelle festgelegt. Es stehen auch formelle Spezifikationssprachen wie z. B. die OCL zur Verfügung. Einige Programmiersprachen, z. B. Eiffel, bieten auch unmittelbar syntaktische Möglichkeiten zur Festlegung eines Kontrakts.

Schnittstellen stellen eine Garantie über die in einer Klasse vorhandenen Methoden dar. Sie geben an, dass alle Objekte, die diese Schnittstelle besitzen, gleich behandelt werden können.

In einigen Programmiersprachen, die keine Mehrfachvererbung unterstützen, z. B. Java, können Schnittstellen verwendet werden, um Kompatibilitäten zwischen Klassen zu definieren, die nicht voneinander erben: Die Schnittstellenbeziehungen sind nicht an den strengen Klassenbaum gebunden. Dazu werden Schnittstellendeklarationen häufig explizit als solche markiert (etwa mit dem Schlüsselwort interface). Als Ersatz für Mehrfachvererbung eignen sich Schnittstellen allerdings nur eingeschränkt, da sie lediglich Methoden und deren Parameter definieren und keine direkte Vererbung von Funktionalität ermöglichen.

In Java gibt es mittlerweile die Möglichkeit, in Schnittstellen Methoden tatsächlich zu implementieren und als Standard (default) zu markieren. Dies ermöglicht die Definition von Funktionalität, die Klassen „erben“, die das Interface nutzen. Java-Interfaces entwickeln sich dadurch etwas näher in Richtung der Mehrfachvererbung.

Beispiele

public interface Face
{
	void Move(float x, float y);
	void Turn(float x, float y, double angle);
	void Scale(float factor);
	double GetArea();
	void SetColor(Color color);
	Color GetColor();
}



public class Polygon : Face
{
	private List<PointF> points;
	private Color color;
	
	public Polygon(List<PointF> points, Color color)
	{
		this.points = points;
		this.color = color;
	}
	
	public void Move(float x, float y)
	{
		for (int i = 0; i < points.Count; i++)
		{
			PointF point = points[i];
			points[i] = new PointF(point.X + x, point.Y + y);
		}
	}
	
	public void Turn(float x, float y, double angleInDegrees)
	{
		double angleInRadians = angleInDegrees * (Math.PI / 180);
		double cosine = Math.Cos(angleInRadians);
		double sine = Math.Sin(angleInRadians);
		for (int i = 0; i < points.Count; i++)
		{
			PointF point = points[i];
			points[i] = new PointF((float) (cosine * (point.X - x) - sine * (point.Y - y) + x), (float) (sine * (point.X - x) + cosine * (point.Y - y) + y));
		}
	}
	
	public void Scale(float factor)
	{
		for (int i = 0; i < points.Count; i++)
		{
			PointF point = points[i];
			points[i] = new PointF(factor * point.X, factor * point.Y);
		}
	}
	
	public double GetArea()
	{
		double area = 0.0;
		for (int i = 0; i < points.Count; i++)
		{
			PointF point1 = points[i];
			PointF point2 = points[(i + 1) % points.Count];
			area += (point1.Y + point2.Y) * (point1.X - point2.X);
		}
		return Math.Abs(area / 2.0);
	}
	
	public void SetColor(Color color)
	{
		this.color = color;
	}
	
	public Color GetColor()
	{
		return color;
	}
}

public interface Konto
{
    int getKontostand(); // abstrakte Signatur-Definition
}

public class SparKonto implements Konto
{
    private int kontostand;
    // Implementierung der durch Konto definierten Methode
    public int getKontostand()
    {
        return kontostand;
    }
    …
}

public Konto erstelleKonto()
{
    return new Konto()
    { //Beginn der anonymen inneren Klasse
        // Implementierung der durch Konto definierten Methode
        public int getKontostand()
        {
            return 0;
        }
    }; //Ende der anonymen inneren Klasse
}

Namenskonventionen

In einigen Programmiersprachen ist es üblich, Schnittstellen durch besondere Präfixe oder Suffixe erkennbar zu machen (Ungarische Notation). So wird häufig ein „I“ (für Interface) vorangestellt oder ein „IF“ beziehungsweise „Interface“ angehängt. Die oben angeführte Beispielschnittstelle Konto hieße dann IKonto, KontoInterface oder KontoIF.

Vorteile

• Schnittstellen sind am Namen als solche erkennbar.
• Implementierende Klassen können einen einfacheren Namen haben.

Nachteile

• Schnittstellen sollten nicht am Namen als solche erkannt werden, da man als Verwender anderer Objekte immer nur deren Schnittstelle (also öffentliche Methoden) bedenken sollte.
• Schnittstellen können als das wesentliche Element der Programmierung betrachtet werden. Daher ist es sinnvoller, die Namen der Implementierungen mit Präfixen oder Suffixen zu ergänzen.
• Schnittstellen sind besonders dann sinnvoll, wenn es mehr als eine Implementierung gibt, sodass die implementierenden Klassen ohnehin mit Präfixen und Suffixen benannt werden.

Siehe auch

• Schnittstelle
• Programmierschnittstelle
• Schnittstelle (UML)
• Klasse (Objektorientierung)
• Vererbung (Programmierung)

Einzelnachweise

1. ↑ Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides: Design Patterns. Elements of Reusable Object-Oriented Software. Addison-Wesley, 1995, ISBN 0-201-63361-2, Seite 18