What we want to do is stick all the properties and power of a MovieClip onto it. So how do we do that? We use the new AS2 keyword "extends" which means to incorporate into our class all the attributes and methods of the MovieClip class. The technical term for it, in OOP terms, is Inheritance. Or the way that some people describe it - Box is a subclass of its superClass MovieClip. I will go into more detail in a further tutorial in a later lesson. (http://www.video-animation.com/flash_16.shtml)

In our Box class we will have a MovieClip(box_mc) as a class variable. The reason for this will be apparent as we go on. Let's do that then:

class Box extends MovieClip{
// declare class members
var box_mc:MovieClip;
}

Interfaces are devices that allow unrelated classes to interact with each other. An interface defines a set of methods but does not implement them. A class that implements the interface agrees to implement all the methods defined in the interface. Let's do an example to see what we mean. Write this in a script file and call it Moving.as:

interface Moving{
function moveUp(py:Number);
function moveDown(py:Number);
function moveLeft(px:Number);
function moveRight(px:Number);
}

Notice that to declare an interface we write :
interface InterfaceName in the declaration section.
Then in the body , between the brackets, we simple declare the name and arguments of the methods of the interface. There is no bracketed section. That gets done in the impementing class.
So, lets make a class that implements an interface.

class Enemy implements Moving {
var x:Number;
// constructor
function Enemy(px:Number) {
x = px;
}
function moveLeft(lx:Number) {
x -= lx;
trace("moveLeft = " + x);
}
function moveRight(rx:Number) {
x += rx;
trace("moveRight = " + x);
}
function moveUp(uy:Number) {
// leave it empty , dont need it
// but must implement it.
}
function moveDown(dy:Number) {
// empty again
}
}

Notice the keyword "implements". (class Enemy implements Moving). By saying we implement an interface, we are agreeing to use all the methods declared in our interface. We dont have to use them all, we just leave the ones empty that we dont want to use. In the Enemy class, we only want to move left and right. So we provide code for those methods and leave the move up and down methods empty. But we must write them down. Try leaving out moveUp or moveDown and see what happens. Double dare you!

Create another separate class. It will be our Ship class. This class we want to only move left and right.

class Ship implements Moving{
var y;
// constructor
function Ship(py:Number){
y = py;
}
function moveUp(uy:Number){
y *= uy;
trace("moveUp = "+y);
}
function moveDown(dy:Number){
y *= dy;
trace("moveDown = "+y);
}
function moveLeft(lx:Number){
// empty
}
function moveRight(rx:Number){
// empty
}
}

This time we only put code in move up and down and leave left and right empty.

Put the following code in our fla.

var ship:Moving = new Ship(200);
var enemy:Moving = new Enemy(56);
ship.moveDown(0.5);
ship.moveUp(0.2);
enemy.moveRight(230);
enemy.moveLeft(100);

We have used our datatype for ship as our interface "Moving" (var ship:Moving = new Ship(200).
This allows us to make use of our interface. When you define a new interface, you are defining a new datatype. Only an instance of a class that implements the interface can be assigned to a variable whose datatype is an interface name.

Go on to the next tutorial: Flash ActionScript 2.0 - Class Inheritance