Interfaces

InterfaceDeclaration:
	interface Identifier InterfaceBody
	interface Identifier : SuperInterfaces InterfaceBody

SuperInterfaces
	Identifier
	Identifier , SuperInterfaces

InterfaceBody:
	{ DeclDefs }

Interfaces descrevem uma lista de funções que uma classe qua herda dela deve implementar. Uma classe qua implementa uma interface pode ser convertida para uma referência para aquela interface. Interfaces correspondem à interface exposta por objetos do sistema operacional, como COM/OLE/ActiveX para Win32.

Interfaces não podem derivar de classes; somente de outras interfaces. Classes não podem derivar de uma interface interface múltiplas vezes.

interface D
{
    void foo();
}

class A : D, D	// erro, interface duplicada
{
}

Uma instância de uma intrerface não pode ser criada.

interface D
{
    void foo();
}

...

D d = new D();		// erro, não pode criar instância de interface

Funções membro de interfaces não tem implementação.

interface D
{
    void bar() { }	// erro, implementação não permitida
}

Todas as funções da interface devem ser definidas em uma classe que herda daquela interface:

interface D
{
    void foo();
}

class A : D
{
    void foo() { }	// ok, provê implementação
}

class B : D
{
    int foo() { }	// erro, nenhuma implementação de void foo()
}

Interfaces podem ser herdadas e funções anuladas:

interface D
{
    int foo();
}

class A : D
{
    int foo() { return 1; }
}

class B : A
{
    int foo() { return 2; }
}

...

B b = new B();
b.foo();		// retorna 2
D d = cast(D) b;	// ok já que B herda a implementação D de A
d.foo();		// retorna 2;

Interfaces podem ser re-implementadas em classes derivadas:

interface D
{
    int foo();
}

class A : D
{
    int foo() { return 1; }
}

class B : A, D
{
    int foo() { return 2; }
}

...

B b = new B();
b.foo();		// retorna 2
D d = cast(D) b;
d.foo();		// retorna 2
A a = cast(A) b;
D d2 = cast(D) a;
d2.foo();		// retorna 2, embora seja o D de A, não o D de B

Uma interface re-implementada deve implementar todas as funções da interface, ela não herda elas de uma super classe:

interface D
{
    int foo();
}

class A : D
{
    int foo() { return 1; }
}

class B : A, D
{
}		// erro, nenhum foo() para a interface D

Interfaces COM

Uma variante nas interfaces é a interface COM. Uma interface COM é projetada para mapear diretamente sobre um objeto COM do Windows. Qualquer objeto COM pode ser representado por uma interface COM, e qualquer objeto D com uma interface COM pode ser usado por clientes COM externos.

Uma interface COM é definida como uma que deriva da interface std.c.windows.com.IUnknown. Uma interface COM se difere de uma interface D regular em que:

Ela deriva da interface interface std.c.windows.com.IUnknown.
Ela não pode ser argumento de uma DeleteExpression.
Referências não podem ser sobrelançadas para o objeto de classe envolvendo, nem podem ser sublançados para uma interface derivada. Para realizar isso, uma QueryInterface() apropriada teria que ser implementada para aquela interface em moda COM padrão.