Advanced ActionScript 3 with Design Patterns

Enhanced descriptions from Syndetics:

Flash-based applications have increased in both size and scope, leaving developers searching for flexible and scalable applications. ActionsScript provides the capability of developing patterns, and this handbook starts with the basics but moves beyond class syntax to help developers determine what should be part of a class and explains the relatio

Table of contents provided by Syndetics

• Introduction (p. xv)
• Part I Successful Projects (p. 1)
• Chapter 1 Designing Applications (p. 3)
• The Analysis Phase (p. 4)
• Introducing Use Cases (p. 5)
• Writing Formal Use Cases (p. 5)
• Forming Use Cases (p. 7)
• Using UML in Analysis (p. 7)
• The Design Phase (p. 8)
• Introducing CRC Cards (p. 9)
• Determining Classes (p. 9)
• Determining Class Responsibilities (p. 10)
• Determining Collaborators (p. 11)
• Elaborating on Relationships Between Classes (p. 11)
• Formalizing Public APIs (p. 13)
• Using UML for Design (p. 13)
• The Implementation Phase (p. 14)
• Coding Conventions (p. 15)
• Encapsulation (p. 17)
• Inheritance and Composition (p. 21)
• Coupling (p. 25)
• Testing (p. 25)
• Creating Basic Unit Tests (p. 27)
• Creating Asynchronous Unit Tests (p. 30)
• Summary (p. 32)
• Chapter 2 Programming to Interfaces (p. 33)
• Defining Interfaces (p. 34)
• Interfaces Defined by Interface Constructs (p. 35)
• Interfaces Defined by Inheritance (p. 37)
• Deciding How to Define an Interface (p. 37)
• Using Polymorphism (p. 38)
• Differentiating Between Type and Class (p. 39)
• Making Runtime Decisions (p. 40)
• Summary (p. 42)
• Part II Patterns (p. 43)
• Chapter 3 Model View Controller Pattern (p. 45)
• Understanding MVC Elements (p. 46)
• The Model (p. 46)
• The View (p. 47)
• The Controller (p. 47)
• The Relationships between Elements (p. 47)
• Building a Simple Example (p. 48)
• Clock Data Model (p. 48)
• Analog Clock View (p. 50)
• Testing the Analog Clock (p. 52)
• Digital Clock View (p. 54)
• Testing the Digital Clock (p. 55)
• Enabling Multiple Views for One Model (p. 56)
• Modifying Model Implementation (p. 57)
• Adding A Controller (p. 59)
• Summary (p. 63)
• Chapter 4 Singleton Pattern (p. 65)
• Object Instantiation (p. 66)
• Restricting Instantiation (p. 66)
• Single Instance and Global Access (p. 67)
• Singleton Versus Static Members (p. 69)
• Building a Simple Singleton (p. 69)
• Creating the Singleton (p. 69)
• Invoking the Singleton (p. 70)
• Building a Settings Framework (p. 71)
• Creating the XML Document (p. 71)
• Creating the Settings Class (p. 71)
• Invoking the Settings Class (p. 74)
• Summary (p. 74)
• Chapter 5 Factory and Template Method Patterns (p. 75)
• Abstract Classes (p. 75)
• Template Method (p. 76)
• Factory Method (p. 78)
• Summary (p. 81)
• Chapter 6 Proxy Pattern (p. 83)
• Virtual Proxy (p. 83)
• Image Loader Example (p. 84)
• Lazy Serialization Example (p. 85)
• Remote Proxy (p. 89)
• Flickr Search Proxy Example (p. 89)
• The flash.utils.Proxy (p. 91)
• Adapter and Facade Patterns (p. 94)
• Summary (p. 94)
• Chapter 7 Iterator Pattern (p. 95)
• Understanding the Problems with Iteration (p. 95)
• Understanding Iterator Elements (p. 97)
• The Iterator Interface (p. 98)
• The Concrete Iterator (p. 98)
• The Collection Interface (p. 100)
• The Concrete Collection (p. 100)
• Using Iterators (p. 101)
• Using Null Iterators (p. 102)
• Summary (p. 102)
• Chapter 8 Composite Pattern (p. 103)
• Understanding the Element Interface (p. 103)
• Understanding Leaf Elements (p. 106)
• Understanding Composite Elements (p. 107)
• Building a File System Example (p. 108)
• Summary (p. 112)
• Chapter 9 Decorator Pattern (p. 113)
• Understanding the Decorator Pattern (p. 114)
• Decorator/Decorated Interface (p. 114)
• Concrete Decorated Class (p. 115)
• Abstract Decorator Class (p. 115)
• Concrete Decorator Class(es) (p. 116)
• Building Reader Decorators (p. 117)
• Creating the Decorator/Decorated Interface (p. 117)
• Defining an Abstract Reader Class (p. 118)
• Defining the Concrete Decorated Class (p. 119)
• Creating the Abstract Decorator Class (p. 120)
• Defining the First Concrete Decorator Class (p. 121)
• Testing the Decorator (p. 122)
• Defining an Additional Concrete Decorator Class (p. 123)
• Defining a New Decorated Type (p. 124)
• Decorating Decorators (p. 126)
• Building Visual and Commutative Decorators (p. 128)
• Defining the Common Interface (p. 129)
• Defining Concrete Decorated Classes (p. 129)
• Defining Decorator Classes (p. 130)
• Adding Non-Commutative Decorators (p. 132)
• Summary (p. 136)
• Chapter 10 Command Pattern (p. 137)
• Understanding the Command Pattern (p. 137)
• The Interface (p. 138)
• The Concrete Command and Receiver (p. 139)
• The Client and Invoker (p. 139)
• Building a Simple Command Application (p. 139)
• Creating the Commands (p. 140)
• Creating a Receiver Type (p. 142)
• Creating a Button (p. 142)
• Creating the Command Containers (p. 143)
• Testing the Application (p. 145)
• Making Commands Undoable and Keeping Command Histories (p. 146)
• Building an Undoable Application (p. 148)
• Making Undoable Commands (p. 149)
• Recording Command History (p. 151)
• Adding an Undo Button (p. 151)
• Building a Redoable Application (p. 153)
• Implementing IRedoableCommand (p. 153)
• Adding the Redo Button (p. 154)
• Using Commands to Build a Proximity Game (p. 154)
• Defining the Player Data Class (p. 155)
• Defining a Collection Class for the Game Players (p. 155)
• Defining Game Pieces (p. 156)
• Defining the Game Board Data Class (p. 158)
• Defining the Game Play Command Class (p. 161)
• Defining the Game Factory Class (p. 162)
• Defining the Game Piece View and Controller Class (p. 163)
• Defining the Game Board View and Controller (p. 165)
• Defining the Main Class (p. 166)
• Summary (p. 168)
• Chapter 11 Memento Pattern (p. 169)
• Using Mementos to Make Actions Undoable in the Proximity Game (p. 173)
• Defining the Memento Type (p. 174)
• Creating the Originator (p. 174)
• Defining the Undoable Command Type (p. 175)
• Updating the Command Factory (p. 176)
• Updating the Main Class (p. 176)
• Using Mementos to Make Actions Redoable in the Proximity Game (p. 177)
• Defining the Redoable Command (p. 177)
• Editing the Factory Class (p. 179)
• Editing the Main Class (p. 179)
• Summary (p. 180)
• Chapter 12 State Pattern (p. 181)
• Simple State Example (p. 181)
• Create the Simple Shooter Class (p. 182)
• Create the Main Example Class (p. 183)
• Problems with This Example (p. 184)
• Encapsulating the States (p. 184)
• The Shooter State Interface (p. 185)
• State Objects (p. 185)
• The Shooter State Machine Class (p. 186)
• Creating the Main Example Class (p. 188)
• Using Abstract Classes (p. 188)
• The Abstract Shooter State (p. 189)
• State Objects (p. 190)
• The Shooter State Machine (p. 191)
• Creating the Main Example Class (p. 192)
• Transitions (p. 193)
• Transitions Defined in the State Machine (p. 193)
• Transitions Defined in the State Objects (p. 195)
• Summary (p. 198)
• Part III Advanced ActionScript Topics (p. 199)
• Chapter 13 Working with Events (p. 201)
• Understanding Events (p. 201)
• Using Events (p. 203)
• Understanding Event Elements (p. 203)
• Registering Listeners (p. 203)
• Removing Event Listeners (p. 205)
• Understanding Event Phases (p. 205)
• The Target Phase (p. 207)
• The Bubble Phase (p. 207)
• Creating Event Dispatchers (p. 210)
• Understanding Event Objects (p. 210)
• Understanding Event Target Properties (p. 211)
• Default Behavior of Events (p. 211)
• Stopping Propagation (p. 211)
• Dispatching Events Through Inheritance (p. 211)
• The IEventDispatcher Interface (p. 212)
• An Example Working with Events (p. 213)
• Creating the IconButton Class (p. 213)
• Creating the Main Class (p. 215)
• Summary (p. 216)
• Chapter 14 Sending and Loading Data (p. 217)
• Loading Text (p. 218)
• Creating the LimerickData Class (p. 219)
• Creating the LimerickView Class (p. 220)
• Creating the Main Class (p. 221)
• Sending and Loading Variables (p. 222)
• Sending Variables (p. 222)
• Loading Variables (p. 224)
• Sending and Loading XML (p. 226)
• Sending XML (p. 226)
• Loading XML (p. 227)
• Using Web Services (p. 227)
• Using Flash Remoting (p. 228)
• Understanding Flash Remoting Basics (p. 229)
• Making Flash Remoting Calls (p. 229)
• Optimizing Data Communication (p. 231)
• Caching Data (p. 231)
• Queuing and Pooling Requests (p. 234)
• Summary (p. 235)
• Chapter 15 E4X (XML) (p. 237)
• Creating XML Objects (p. 239)
• Property Accessors (p. 240)
• XML Filtering (p. 241)
• Iterating Through an XMLList (p. 242)
• Namespaces (p. 243)
• Sending and Loading XML Data (p. 243)
• Simple Soap Example (p. 243)
• Building the Custom Event (p. 245)
• Building the Web Service Class (p. 246)
• Creating the Main Class (p. 247)
• Summary (p. 249)
• Chapter 16 Regular Expressions (p. 251)
• Introducing the RegExp Class (p. 252)
• Working with Regular Expressions (p. 252)
• Boolean Testing Regular Expressions (p. 253)
• Finding Matching Substring Indices (p. 253)
• Retrieving Matching Substrings (p. 253)
• Replacing Substrings Using Regular Expressions (p. 254)
• Using Regular Expression Flags (p. 255)
• The Global Flag (p. 256)
• The Ignore Case Flag (p. 256)
• The Multiline Flag (p. 257)
• The Dot Matches Newline Flag (p. 257)
• The Extended Flag (p. 257)
• Understanding Metacharacters and Metasequences (p. 258)
• Using Character Classes (p. 259)
• Working with Quantifiers (p. 260)
• Using Regular Expression Groups (p. 261)
• Building a Mad Libs Application Using Regular Expressions (p. 263)
• Creating the Data Model Classes (p. 264)
• Creating the Input Control (p. 268)
• Creating the View Classes (p. 269)
• Defining the Main Class (p. 271)
• Summary (p. 272)
• Index (p. 273)

Author notes provided by Syndetics

Joey Lott works with ActionScript during the day and by night he's a super-secret international man of mystery, rescuing animals and children from harms way, righting wrongs, and working for global peace, the rights of all living beings, and environmental responsibility. Joey is the author (or co-author) of a veritable arsenal of ActionScript and Flash-related titles, including the ActionScript Cookbook, Programming Flash Communication Server, and the Flash 8 Cookbook. In his free time he likes to write poetry, pursue competitive origami, and train in the art of aikido. Danny Patterson is a Consultant specializing in Flash and Web technologies. He also works with Schematic as a Senior Flash Architect. He is an Adobe Community Expert and has contributed over 40 articles to Community MX and the MX Developers Journal. He is also the co-author of the Flash 8 ActionScript: Training from the Source book by Adobe Press. He has spoken at many conferences and user groups including Flash in the Can and Flash Belt. Danny is certified in both Flash and ColdFusion and has worked on web projects for many large companies including Microsoft, IBM, Dell, Adobe and Starz. You can check out his blog at DannyPatterson.com.