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.