User Guide

Creating and using interfaces 59
Interfaces cannot contain any variable declarations or assignments. Functions declared in an
interface cannot contain curly braces. For example, the following interface won’t compile:
interface BadInterface{
// Compiler error. Variable declarations not allowed in interfaces.
var illegalVar;
// Compiler error. Function bodies not allowed in interfaces.
function illegalMethod(){
}
}
You can also use the extends keyword to create subclasses of an interface:
interface iA extends interface iB {}
The rules for naming interfaces and storing them in packages are the same as those for classes; see
“Creating and using classes” on page 51 and “Using packages” on page 57.
Interfaces as data types
Like a class, an interface defines a new data type. Any class that implements an interface can be
considered to be of the type defined by the interface. This is useful for determining if a given
object implements a given interface. For example, consider the following interface:
interface Movable {
function moveUp():Void;
function moveDown():Void;
}
Now consider the class Box, which implements the Movable interface.
class Box implements Movable {
var xpos:Number;
var ypos:Number;
function moveUp():Void {
trace("moving up");
// method definition
}
function moveDown():Void {
trace("moving down");
// method definition
}
}
In another script, such as the following code, where you create an instance of the Box class, you
could declare a variable to be of the Movable type:
import Box;
var newBox:Movable = new Box();
At runtime, you can cast an expression to an interface type. Unlike Java interfaces, ActionScript
interfaces exist at runtime, which allows type casting. If the expression is an object that
implements the interface or has a superclass that implements the interface, the object is returned.
Otherwise,
null is returned. This is useful if you want to make sure that a particular object
implements a certain interface.