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

Example 9-1. AbstractClass.as (continued)
}
fromTemplate( );
}
protected function primitiveA( ):void
{
//Awaiting instructions
}
protected function primitiveB( ):void
{
//Awaiting instructions
}
private final function fromTemplate( ):void
{
trace("Hello everybody!");
}
};
Example 9-2. ConcreteClass.as
package
{
//Any concrete class
public class ConcreteClass extends AbstractClass
{
trace("Concrete class");
override protected function primitiveA( ):void
{
trace("Special A");
}
override protected function primitiveB( ):void
{
trace("Special B");
}
}
}
Looking at the AbstractClass you can see that the main algorithm is encapsulated in
the templateMethod( ) function. The final statement indicates that the method is
locked up and cannot be changed by the subclasses. However, all that really means is
that the order cannot be changed by the subclasses. Both the primitiveA( ) and
primitiveB( ) functions, which make up the templateMethod( ), are abstract. They
are awaiting the details from the subclasses. So while the templateMethod( ) is locked,
the operations that go into it don’t have to be, and can be changed by the subclasses.
At the same time, if you want any of the operations that make up the template
method to be locked, you can do that as well. The function fromTemplate( ) is locked
in the same way as the main template method. As part of the templateMethod( ) function,
the fromTemplate( ) operation cannot be changed by an override statement as
the two abstract function can. So you can have the best of both worlds. Those opera-
Minimalist Example: Abstract Template Method | 339