| **Navigation:**  [[introduction.htm|Language Reference]] > 4 - Entity Declarations > Complex Data Structures >====== INTERFACE (class behavior definition) ====== | [[class  object declaration .htm#selfparent|{{btn_prev_n.gif|Previous page}}]][[introduction.htm|{{btn_home_n.gif|Return to chapter overview}}]][[file structures.htm|{{btn_next_n.gif|Next page}}]] |
|  ||

| label | **INTERFACE** **(** [ //parentinterface// ] **)** | [, **TYPE**] [, **COM**] |
|  | [//methods //] |  |
|  | **END** |  |

{{blk2blue.jpg|blk2blue.jpg}}

| **INTERFACE** | A collection of methods to be used by the class that implements the interface. |
| //parentinterface// | The label of a previously declared INTERFACE structure whose methods are inherited by the new INTERFACE. This may be an INTERFACE with the TYPE attribute. |
| **TYPE** | Specify the INTERFACE is only a type definition. TYPE is implicit on an INTERFACE but may be explicitly specified. |
| **COM** | Specify that all methods defined in the interface use a [[c  pascal  parameter passing conventions .htm|PASCAL]] calling convention. Used for COM implementation. |
| //methods// | PROCEDURE prototypes |

An **INTERFACE** is a structure, which contains the //methods// (PROCEDUREs) that define the behavior to be implemented by a CLASS. It cannot contain any property declarations. All methods defined within the INTERFACE are implicitly virtual. A period or the END statement must terminate an INTERFACE structure.

**Derived INTERFACEs (Inheritance)**

An INTERFACE declared with the //parentinterface// parameter creates a //derived interface// that inherits all the //methods //of the named //parentinterface//. The //derived interface// may also contain its own //methods//.

Any //method// prototyped in the //derived interface //with the same name as a //method// in the //parentinterface// overrides the inherited //method// if both have the same parameter lists. If the two //methods// have different parameter lists, they create polymorphic functions in the //derived interface// that must follow the rules of Procedure Overloading.

See also the [[implements inheritance.htm|Implementing INTERFACEs in Derived Classes]] topic for more detailed information regarding this section.

**VIRTUAL Methods (Polymorphism**__**)**__

All methods in an INTERFACE are implicitly virtual, although the virtual attribute may be explicitly specified for clarity.

**Method Definition**

The PROCEDURE definition of a //method// (its executable code, not its prototype) is defined by the CLASS that is implementing the INTERFACE. All methods for an interface must be defined in the IMPLEMENTING class.

**Referencing INTERFACE methods in your code**

You must call the //methods //of an INTERFACE by using dot notation syntax (by prepending the label of the CLASS to the label of the INTERFACE to the label of the //method//).

For example, using the following INTERFACE and CLASS declaration:

<code>
MyInterface INTERFACE
MyProc         PROCEDURE
           END
MyClass    CLASS,IMPLEMENTS(MyInterface)
           END
</code>

You may call the MyProc PROCEDURE as:

<code>
  CODE
  MyClass.MyInterface.MyProc
</code>

**See Also:**

[[implements add methods to a class .htm|IMPLEMENTS]]

[[implements inheritance.htm|Implementing INTERFACEs in Derived Classes]]