book

ActionScript 3.0 Design Patterns

Name: ActionScript 3.0 Design Patterns
ISBN: 9780596528461

by William Sanders, Chandima Cumaranatunge

July 2007

Intermediate to advanced

532 pages

14h 6m

English

O'Reilly Media, Inc.

Read now

Unlock full access

A Note Regarding Supplemental Files
Preface
Who this Book is forHow this Book is OrganizedWhat You Need to Use This BookSay It Again, SamUser’s GuideFlex 2 developersFlash Media Server 2 developersCompanion Tools You’ll WantConventions Used in This BookUsing Code ExamplesWe’d Like to Hear from YouAcknowledgmentsTechnical ReviewersEditorsAuthorsBill SandersChandima CumaranatungeDedication:
1. Object-Oriented Programming, Design Patterns, and ActionScript 3.0
The Pleasure of Doing Something WellSequential and Procedural ProgrammingTransition to OOPMovieClip and Button scriptsTimeline scriptsDocument classMovie clip and button classesOOP BasicsAbstractionAbstractions in ActionScript 3.0Why Abstractions Are ImportantEncapsulationHiding Your Data from Bad ConsequencesPrivate variablesThe many meanings of interfaceGetters and settersThe get and set methodsUsing Encapsulation and Design PatternsInheritanceLooking at the AncestorsWriting Classes for InheritanceUsing Interfaces and Abstract Classes in ActionScript 3.0Interface constructsAbstract classes and overriding inheritanceWhy use interfaces and abstract classes?PolymorphismGenerating Polymorphism Using An Abstract ClassImplementing Polymorphism with InterfacesPrinciples of Design Pattern DevelopmentImplementationStateClient and RequestProgram to Interfaces over ImplementationsManaging DependencyUsing Complex InterfacesFavor CompositionDoing CompositionUsing DelegationMaking Composition, Inheritance, and Instantiation Work TogetherMaintenance and Extensibility PlanningPlanning Only for MaintenanceAdding Extensibility to a Plan with GranularityYour Application Plan: It Ain’t You BabeUsing OOP and Design Patterns to Meet Client GoalsChoosing the Right Design PatternAchieving Better OOP Through Design Patterns
2. Factory Method Pattern
What is the Factory Method Pattern?Model of the Factory Method PatternAbstract Classes in ActionScript 3.0Minimalist ExampleProduct ClassesCreator ClassesClientsHiding the Product ClassesExample: Print ShopProduct Classes: Print JobsCreator Classes: Print CentersClientsPrint Shop ExtensionParameterized Factory MethodsExtended Example: Color PrintingNew Product ClassesNew Creator Classes: Integrating a Parameterized Factory MethodClientsParallel Class HierarchiesKey OOP Concepts Used in the Factory Method PatternExample: Sprite FactoryProduct Classes: Shape WidgetsCreator Classes: Shape CreatorsClientsExample: Vertical Shooter GameProduct ClassesProjectilesSpace shipsCreator ClassesWeaponShipCreatorConcrete Creator ClassesClientsSummary
3. Singleton Pattern
What is the Singleton Pattern?Key FeaturesThe Singleton ModelKey OOP Concepts Used with the Singleton PatternCreating and Using a Private Class ConstructorCreating a Private Class InstanceMinimalist Abstract SingletonInstantiation with a Private Class ParameterA Singleton Instantiation MethodOne Instance and Different ReferencesWhen to Use the Singleton PatternA Single Alert MessageJust One Tune at a TimeUsing Multiple References in a Shopping CartSummary
4. Decorator Pattern
What is the Decorator Pattern?Key FeaturesThe Decorator ModelKey OOP Concepts Used with the Decorator PatternUnwanted InheritanceWrapping ResponsibilitiesFlexibility and AdaptabilityMinimalist Abstract DecoratorAbstract Component ClassAbstract Decorator ClassConcrete DecorationsWrapping UpApplying a Simple Decorator Pattern in Flash: Paper DollSetting Up the Component ClassDecorator Class Dressing the DollsThe Concrete ClassesConcrete component classConcrete decorator classesImplementing the Paper Doll DecoratorDecorating with Deadly Sins and Heavenly VirtuesAdding Properties and MethodsMultiple Concrete ComponentsDecorating with Multiple PropertiesMultiple Method Concrete DecorationsThe Good and Evil Concrete DecoratorsHeavenly VirtuesDeadly SinsImplementing the Good and Evil DecoratorDual implementationCharting soulsDynamic Selection of Concrete Components and Decorations: a Hybrid Car DealershipSetting Up the Hybrid Car ComponentsAuto abstract componentHybrid car classes concrete componentUsing Auto Options as DecoratorsThe options abstract decoratorThe options concrete decoratorsSetting Up the User InterfaceCreating the document and setting the stageImplementing the concrete components and their decoratorsSummary
5. Adapter Pattern
What is the Adapter Pattern?A Design Pattern for Potty TrainingKey Features of the Adapter PatternObject and Class AdaptersObject AdaptersMinimalist example of an object adapterUsing a parameterized adapter classClass AdaptersMinimalist example of a class adapterKey OOP Concepts in the Adapter PatternObject and Class Adapters ComparedExample: Car Steering AdapterThe Existing ClassInterface ConversionThe original interfaceThe new contextThe new interfaceThe Adapter ClassThe ClientExtended Example: Steering the Car Using a MouseExample: List Display AdapterThe Existing ClassInterface ConversionThe Adapter ClassThe ClientExtended Example: Displaying the O’Reilly New Books ListSummary
6. Composite Pattern
What is the Composite Pattern?Key Features of the Composite PatternMinimalist Example of a Composite PatternAccessing Child NodesRemoving NodesCreating a parent referenceImplementing the remove methodBuilding and Manipulating a Composite StructureKey OOP Concepts in the Composite PatternExample: Music PlaylistsQueuing Songs to Play in SequenceBuilding Composite PlaylistsExample: Animating Composite Objects Using Inverse KinematicsUsing Inverse KinematicsCreating Component and Composite Nodes for the SnakeBuilding the Snake HeadControlling the SnakeMoving a Kinematic PairBuilding the Body and Tail SegmentsBuilding the Composite SnakeUsing Flash’s Built-in Composite Structure: the Display ListCreating a Composite AirplaneDeveloping the Component and Composite Classes for the AirplaneCreating the Fuselage, Wings, and EnginesBuilding the Composite StructureCalculating the Total Weight of the AirplaneModifying Components to Reflect DamageCalculating Total Damage to the AirplaneSummary
7. Command Pattern
What is the Command Pattern?Mom Needs to Issue Some CommandsKey Features of the Command PatternClass Diagram of the Command PatternMinimalist Example of a Command PatternThe Command InterfaceThe Concrete CommandThe ReceiverThe InvokerThe ClientSetting a Trigger to Invoke the CommandKey OOP Concepts in the Command PatternMinimalist Example: Macro CommandsThe Macro Command InterfaceTwo Concrete SubcommandsThe Concrete Macro CommandA Macro Command Object Created from the ClientExample: Number ManipulatorA Utility Button ClassTriggering an Invoker by Button ClicksThe Increment and Decrement CommandsThe ClientExtended Example: Sharing Command ObjectsTriggering an Invoker by Key PressesSharing Command Objects from the ClientExtended Example: Implementing UndoAn Abstract Interface for CommandsConcrete Commands that Implement UndoUndoable Commands Assigned from the ClientExample: Podcast RadioWhat is a Podcast?Creating a Package with Utility ClassesCreating a Command to Play a PodcastDeveloping the Radio ReceiverPush Button Invokers for the RadioThe Client Assigns Podcasts to Push ButtonsExtended Example: Dynamic Command Object AssignmentA Context Sensitive InvokerCommands to Dynamically Assign Command ObjectsDynamic Command Assignment Setup from the ClientSummary
8. Observer Pattern
What is the Observer Pattern?Key FeaturesThe Observer ModelKey OOP Concepts Used with the Observer PatternChoose the InterfaceObject CompositionMinimalist Abstract ObserverSubject InterfaceObserver InterfaceConcrete SubjectConcrete ObserverWorking the ObserverExample: Adding States and Identifying UsersMultiple StatesWho are You?Updated ObserverPlaying the BugleDynamically Changing StatesRecording a Space BattleGiving More Work to the Concrete ClassesLaunching the Space BattleSetting up the Flash documentBuilding the spaceshipsBuilding the weaponsBuilding the Android space station and beamWriting a Change HandlerExample: Working with Different Data DisplaysThe Output DesignerThe Concrete Classes and a Double ImplementationThe Data Design ClassesUIList componentBar chart displayThe line graphPulling All the Elements TogetherSummary

9. Template Method Pattern
What is the Template Method Pattern?Key FeaturesThe Template Method ModelKey OOP Concepts used with the Template MethodWhy Inheritance and Not Composition?Abstract Functions and Override FlexibilityConsider VariationThe Hollywood PrincipleMinimalist Example: Abstract Template MethodBare Bones Template MethodTesting TemplatesEmploying Flexibility in the Template MethodSelecting and Playing Sound and VideoSetting Up the FormatNot-So-Concrete Concrete ClassesThe Detail ClassesPlaying the MediaHooking It UpWhen to Hook?The Hook as a Lonely RepairmanBaja Flight with a HookSummary
10. State Design Pattern
Design Pattern to Create a State MachineKey FeaturesThe State ModelTransitionsTriggersState design structureKey OOP Concepts Used with the State PatternMinimalist Abstract State PatternManaging All Those States: Hardworking Context ClassCreating a context classCompleting and testing the abstract state machineVideo Player Concrete State ApplicationExpanding the State Design: Adding StatesAdding the Pause State to the StatechartAdding New BehaviorsAdding More States and Streaming CapabilitiesSetting Up Your ActionScript 3.0 Script for FMS2The Adaptable StatesSummary
11. Strategy Pattern
What is the Strategy Pattern?Key FeaturesThe Strategy ModelKey OOP Concepts Used with the Strategy PatternEncapsulating VariationUnencapsulated version (pseudocode)Encapsulated algorithms (pseudocode)Using Delegation and DelegatesMinimalist Abstract State PatternUsing Delegation with the ContextAdding a StrategyDetails of the StrategyMore Delegation in a Concrete ContextPulling All the Parts TogetherAdding More Concrete Strategies and Concrete ContextsThe ClownsThe Trick Interface and ImplementationsThe Skits Interface and ImplementationsHere Come the Clowns!Additional Clown FunctionalityAdding a new clownAdding a new trickRevising clown collegeTricks and Skits Reorganization: Clown PlanningWorking with String StrategiesContexts for String StrategiesString StrategiesChecking strategiesSort strategiesSupport ClassesString Strategy TestSummary
12. Model-View-Controller Pattern
What is the Model-View-Controller (MVC) Pattern?ModelViewControllerCommunication Between the MVC elementsEmbedded Patterns in the MVCMinimalist Example of an MVC PatternModel as a Concrete Subject in an Observer PatternThe EventDispatcher class in ActionScript 3.0The modelController as a Concrete Strategy in a Strategy PatternThe controllerView as a Concrete Observer in an Observer Pattern and context in a Strategy PatternBuilding the MVC TriadNested Views as Leaves and Nodes of a Composite PatternComponent and composite viewsCreating nested viewsBuilding the Nested View StructureKey Features of the MVC PatternKey OOP Concepts in the MVC PatternExample: Weather MapsThe ModelThe ControllerThe ViewsCombo box viewMap viewBuilding the MVC TriadSetting the Model to Self-UpdateExtended Example: Infrared Weather MapsAdding a New ModelAdding a New ControllerAdding a New ViewBuilding the MVC TriadExample: CarsThe ModelThe ControllerThe ViewsBuilding the CarCustom ViewsDirection Gauge ViewGPS ViewAdding the Custom ViewsAdding a Chase CarSummary
13. Symmetric Proxy Pattern
Simultaneous Game Moves and OutcomesThe PlayerThe RefereeThe Internet, Proxies, and PlayersThe Symmetric Proxy PatternKey FeaturesThe cellThe proxyKey OOP Concepts Used with the Symmetric ProxyCommunication FlexibilityGame FlexibilityThe Player InterfaceThe RefereeMethodsTemplate MethodRPS SubclassInformation Shared over the InternetPlayer-Proxy ClassesMove MakingEvent to moveDual movesProxy moveReferee objectPlayer 2 ChangesClasses and Document Files SupportDynamic Output Text FieldsButton ControlsThe Flash File and Connection Movie ClipSummary
About the Authors
Copyright

Overview

Now that ActionScript is reengineered from top to bottom as a true object-oriented programming (OOP) language, reusable design patterns are an ideal way to solve common problems in Flash and Flex applications. If you're an experienced Flash or Flex developer ready to tackle sophisticated programming techniques with ActionScript 3.0, this hands-on introduction to design patterns is the book you need.

ActionScript 3.0 Design Patterns takes you step by step through the process, first by explaining how design patterns provide a clear road map for structuring code that actually makes OOP languages easier to learn and use. You then learn about various types of design patterns and construct small abstract examples before trying your hand at building full-fledged working applications outlined in the book. Topics in ActionScript 3.0 Design Patterns include:

Key features of ActionScript 3.0 and why it became an OOP language
OOP characteristics, such as classes, abstraction, inheritance, and polymorphism
The benefits of using design patterns
Creational patterns, including Factory and Singleton patterns
Structural patterns, including Decorator, Adapter, and Composite patterns
Behavioral patterns, including Command, Observer, Strategy, and State patterns
Multiple design patterns, including Model-View-Controller and Symmetric Proxy designs

During the course of the book, you'll work with examples of increasing complexity, such as an e-business application with service options that users can select, an interface for selecting a class of products and individual products in each class, an action game application, a video record and playback application, and many more. Whether you're coming to Flash and Flex from Java or C++, or have experience with ActionScript 2.0, ActionScript 3.0 Design Patterns will have you constructing truly elegant solutions for your Flash and Flex applications in no time.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

AdvancED ActionScript 3.0: Design Patterns

Publisher Resources

ISBN: 9780596528461Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills