www.digitalmars.com

D Programming Language 1.0


Last update Fri Jan 4 22:23:50 2013

Interfaces

InterfaceDeclaration:
        interface Identifier BaseInterfaceListopt InterfaceBody
        InterfaceTemplateDeclaration

BaseInterfaceList:
        : InterfaceClasses

InterfaceBody:
        { DeclDefsopt }

Interfaces describe a list of functions that a class that inherits from the interface must implement. A class that implements an interface can be converted to a reference to that interface.

Some operating system objects, like COM/OLE/ActiveX for Win32, have specialized interfaces. D interfaces that are compatible with COM/OLE/ActiveX are called COM Interfaces.

Interfaces cannot derive from classes; only from other interfaces. Classes cannot derive from an interface multiple times.

interface D
{
    void foo();
}

class A : D, D  // error, duplicate interface
{
}
An instance of an interface cannot be created.
interface D
{
    void foo();
}

...

D d = new D();          // error, cannot create instance of interface

Interface member functions do not have implementations.

interface D
{
    void bar() { }      // error, implementation not allowed
}

All interface functions must be defined in a class that inherits from that interface:

interface D
{
    void foo();
}

class A : D
{
    void foo() { }      // ok, provides implementation
}

class B : D
{
    int foo() { }       // error, no void foo() implementation
}
Interfaces can be inherited and functions overridden:
interface D
{
    int foo();
}

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

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

...

B b = new B();
b.foo();                // returns 2
D d = cast(D) b;        // ok since B inherits A's D implementation
d.foo();                // returns 2;

Interfaces can be reimplemented in derived classes:

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();                // returns 2
D d = cast(D) b;
d.foo();                // returns 2
A a = cast(A) b;
D d2 = cast(D) a;
d2.foo();               // returns 2, even though it is A's D, not B's D

A reimplemented interface must implement all the interface functions, it does not inherit them from a super class:

interface D
{
    int foo();
}

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

class B : A, D
{
}               // error, no foo() for interface D

COM Interfaces

A variant on interfaces is the COM interface. A COM interface is designed to map directly onto a Windows COM object. Any COM object can be represented by a COM interface, and any D object with a COM interface can be used by external COM clients.

A COM interface is defined as one that derives from the interface std.c.windows.com.IUnknown. A COM interface differs from a regular D interface in that:





Forums | Comments |  D  | Search | Downloads | Home