PreviousNext

Creating subclasses

In object-oriented programming, a subclass can inherit the properties and methods of another class, called the superclass. To create this kind of relationship between two classes, you use the class statement's extends clause. To specify a superclass, use the following syntax: 

class SubClass extends SuperClass {}

The class you specify in SubClass inherits all the properties and methods defined by the superclass. For example, you might create a Mammal class that defines properties and methods common to all mammals. To create a variation of the Mammal class, such as a Marsupial class, you would extend the Mammal class—that is, create a subclass of the Mammal class.

class Marsupial extends Mammal {}

The subclass inherits all the properties and methods of the superclass, including any properties or methods that you have declared to be private using the private keyword. (For more information on private variables, see Controlling member access.)

You can extend your own custom classes, as well as any of the built-in ActionScript classes, such as the XML, Sound, or MovieClip class. When you extend a built-in ActionScript class, your custom class inherits all the methods and properties of the built-in class.

For example, the following code defines the class JukeBox, which extends the built-in Sound class. It defines an array called songList and a method called playSong() that plays a song and invokes the loadSound() method, which it inherits from the Sound class.

class JukeBox extends Sound {
  var songList:Array = new Array("beethoven.mp3", "bach.mp3", "mozart.mp3");
  function playSong(songID:Number) {
    this.loadSound(songList[songID]);
  }
}

If you don't place a call to super() in the constructor function of a subclass, the compiler automatically generates a call to the constructor of its immediate superclass with no parameters as the first statement of the function. If the superclass doesn't have a constructor, the compiler creates an empty constructor function and then generates a call to it from the subclass. However, if the superclass takes parameters in its definition, you must create a constructor in the subclass and call the superclass with the required parameters.

Multiple inheritance, or inheriting from more than one class, is not allowed. However, classes can effectively inherit from multiple classes if you use individual extends statements:

// not allowed
class C extends A, B {}
// allowed
class B extends A {}
class C extends B {}

You can also use the extends keyword to create subclasses of an interface:

interface iA extends interface iB {}
PreviousNext