Programming Flex 3

Inheritance

You can create new classes (called subclasses) that inherit from existing classes (called superclasses). You achieve this using the extends keyword when declaring the class. The extends keyword should follow the class name and be followed by the class from which you want to inherit. The following defines class B, so it inherits from a fictional class, A:

package com.example {
  import com.example.A;
  public class B extends A {
  }
}

ActionScript 3.0 allows a class to inherit from just one superclass. The subclass inherits the entire implementation of the superclass, but it can access only properties and methods declared as public or protected. Properties that are declared as private and methods are never accessible outside a class—not even to subclasses. Classes in the same package can access properties declared as internal. Consider the class A and class B example, if A is defined as follows:

package com.example {
  public class A {
    private var _one:String;
    protected var _two:String;
    public function A() {
      initialize();
    }
    private function initialize():void {
      _one = "one";
      _two = "two";
    }
    public function run():void {
      trace("A");
    }
  }
}

In this example, B (which is defined as a subclass of A) can access _two and run(), but it cannot access _one or initialize().

If a subclass wants to create its own implementation for a method that it inherits from a superclass, it can do so by overriding it. Normally, a subclass blindly inherits all of the superclass implementation. However, when you override a method, you tell the subclass that it should disregard the inherited implementation and use the overridden implementation instead. To override a method, you must use the override keyword in the method declaration. The following overrides the run() method:

package com.example {
  import com.example.A;
  public class B extends A {
    override public function run():void {
      trace("B");
    }
  }
}

When a subclass overrides a superclass method, the subclass method’s signature must be identical to the superclass method’s signature, that is, the parameters, return type, and access modifier must be the same.