ActionScript 3.0 Design Patterns.pdf - VideoTutorials-bg.com

Abstract classes and overriding inheritance
As you become familiar with design patterns, you’ll see more and more use of interfaces
and its close cousin the abstract class. In ActionScript 3.0 the abstract class is a
little problematic because no class can be actually defined as abstract. While you can
use the public statement to make a class public, ActionScript 3.0 (and ECMAScript)
chose not to include abstract classes in the language, as does Java.
However, you can create an abstract class in ActionScript 3.0. All you have to do is
create a regular class and treat it as an abstract class. Like interfaces, abstract classes
can have abstract methods that are not directly implemented. Rather, abstract classes
are subclassed and any abstract methods are overridden and implemented very much
like methods are in using interfaces. However, abstract classes can have implemented
methods as well; so when you need both abstract and implemented methods, abstract
classes are key to such design patterns as the Factory Method (Chapter 2), Decorator
(Chapter 4), and the Composite (Chapter 6), as well as others.
You know from inheritance that when one class subclasses another, the subclass
inherits the methods of the superclass. With an abstract class, you do not implement
the class but instead subclass it, and then implement the subclass and its methods.
Because of the abstract nature of at least some of the methods in the abstract class,
you must override them. Using the override statement, an overridden class maintains
its signature but can have its own unique details. You must be sure that the
name, number, type of parameters, and the return type are the same. In other words,
when you override a method from an abstract class, you treat the method exactly the
same as an interface method.
Example 1-21 through Example 1-23 make up an application that illustrates how an
abstract class works. The abstract class has two methods; a concrete one and an
abstract one.
Example 1-21. AbstractClass.as
package
{
//Abstract class
public class AbstractClass
{
function abstractMethod( ):void {}
function concreteMethod( ):void
{
trace("I'm a concrete method from an abstract class")
}
}
}
The subclass inherits the methods and interface from the abstract class, and it provides
details for the abstract method by overriding it. However, the subclass leaves
the concrete class as is and does not attempt to instantiate the superclass.
Inheritance | 31