· Lexical · Modules · Declarations · Types · Properties · Attributes · Pragmas · Expressions · Statements · Arrays · Structs & Unions · Classes · Interfaces · Enums · Functions · Operator Overloading · Templates · Mixins · Contracts · Conditional Compilation · Handling errors · Garbage Collection · Memory Management · Floating Point · Inline Assembler · Documentation Comments · Interfacing To C · Portability Guide · Embedding D in HTML · Named Character Entities · Application Binary Interface |
InterfacesInterfaceDeclaration: interface Identifier InterfaceBody interface Identifier : SuperInterfaces InterfaceBody SuperInterfaces Identifier Identifier , SuperInterfaces InterfaceBody: { DeclDefs }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. Interfaces correspond to the interface exposed by operating system objects, like COM/OLE/ActiveX for Win32. 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 interfaceInterface 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 DA 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 InterfacesA 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:
|