# Interfaces

qooxdoo supports Java-like interfaces.

Interface definitions look very similar to normal class definitions.

Example:

    qx.Interface.define("qx.test.ISample",
     {
       extend: [SuperInterfaces],

       properties: {"color": {}, "name": {} },

       members:
       {
         meth1: function() {},
         meth2: function(a, b) {
           this.assertArgumentsCount(arguments, 2, 2);
         },
         meth3: function(c) {
           this.assertInterface(c, qx.some.IInterface);
         }
       },

       statics:
       {
         PI : 3.14
       },

       events :
       {
         keydown : "qx.event.type.KeyEvent"
       }
    });

## Definition


Interfaces are declared using `qx.Interface.define`. Interface names start by
convention with an `I` (uppercase "i"). They can inherit from other interfaces
using the `extend` key. Multiple inheritance of interfaces is supported.

### Properties

Properties in interfaces state that each class implementing this
interface must have a property of the given name. The property
definition (defining_properties) is not evaluated and may be empty.

### Members

The member section of the interface lists all member functions which
must be implemented. The function body is used as a precondition of the
implementation. By implementing an interface the qooxdoo class definition
automatically wraps all methods required by the interface. Before the
actual implementation is called, the precondition of the interface
is called with the same arguments. The precondition should raise an
exception if the arguments are don't meet the expectations. Usually the
methods defined in [qx.core.MAssert](apps://apiviewer/#qx.core.MAssert)
are used to check the incoming parameters.

### Statics

Statics behave exactly like statics defined in mixins and qooxdoo
classes, with the different that only constants are allowed.
They are accessible through their fully-qualified name. For
example, the static variable `PI` could be used like this:

```
    var a = 2 * qx.test.ISample.PI * (r*r);
```

### Events

Each event defined in the interface must be declared in the implementing
classes. The syntax matches the `events` key of the class declaration.

## Implementation


With `implement` key of the class declaration, a list of
interfaces can be listed, which the class implements. The class
must implement all properties, members and events declared
in the interfaces. Otherwise a runtime error will be thrown.

Example:

```
    qx.Class.define("qx.test.Sample",
     {
       implement: [qx.test.ISample],

       properties: {
         "color": { check: "color"},
         "name": { check: "String"}
       },

       members:
       {
         meth1: function() { return 42; },
         meth2: function(a, b) { return a+b },
         meth3: function(c) { c.foo() }
       }

       events :
       {
         keydown : "qx.event.type.KeyEvent"
       }

    });
```

## Validation


`qx.Class` contains several static methods to check,
whether a class or an object implements an interface:

-   `qx.Class.hasInterface()`: Whether a given class
or any of its superclasses includes a given interface.
 
-   `qx.Class.implementsInterface()`: Checks whether all methods
defined in the interface are implemented in the class. The
class does not need to implement the interface explicitly.

It is further possible to use interfaces as property checks.

## Summary

### Configuration

### References

-   [a syntax quick reference for interfaces](interface_quickref.md)
-   [API Documentation for Interface](apps://apiviewer/#qx.Interface)

