ActionScript 3.0 Design Patterns

Larger Cover

Object Oriented Programming Techniques

By William Sanders, Chandima Cumaranatunge

Publisher: O'Reilly Media / Adobe Dev Library

Released: July 2007

Pages: 544

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.

Chapter 1 Object-Oriented Programming, Design Patterns, and ActionScript 3.0
1. The Pleasure of Doing Something Well
  1. Sequential and Procedural Programming
  2. Transition to OOP
    1. MovieClip and Button scripts
    2. Timeline scripts
    3. Document class
    4. Movie clip and button classes
2. OOP Basics
3. Abstraction
  1. Abstractions in ActionScript 3.0
  2. Why Abstractions Are Important
4. Encapsulation
  1. Hiding Your Data from Bad Consequences
    1. Private variables
    2. The many meanings of interface
    3. Getters and setters
    4. The get and set methods
  2. Using Encapsulation and Design Patterns
5. Inheritance
  1. Looking at the Ancestors
  2. Writing Classes for Inheritance
  3. Using Interfaces and Abstract Classes in ActionScript 3.0
    1. Interface constructs
    2. Abstract classes and overriding inheritance
    3. Why use interfaces and abstract classes?
6. Polymorphism
  1. Generating Polymorphism Using An Abstract Class
  2. Implementing Polymorphism with Interfaces
7. Principles of Design Pattern Development
  1. Implementation
  2. State
  3. Client and Request
8. Program to Interfaces over Implementations
  1. Managing Dependency
  2. Using Complex Interfaces
9. Favor Composition
  1. Doing Composition
  2. Using Delegation
  3. Making Composition, Inheritance, and Instantiation Work Together
10. Maintenance and Extensibility Planning
  1. Planning Only for Maintenance
  2. Adding Extensibility to a Plan with Granularity
11. Your Application Plan: It Ain't You Babe
  1. Using OOP and Design Patterns to Meet Client Goals
  2. Choosing the Right Design Pattern
  3. Achieving Better OOP Through Design Patterns
Chapter 2 Factory Method Pattern
1. What is the Factory Method Pattern?
  1. Model of the Factory Method Pattern
2. Abstract Classes in ActionScript 3.0
3. Minimalist Example
  1. Product Classes
  2. Creator Classes
  3. Clients
4. Hiding the Product Classes
5. Example: Print Shop
  1. Product Classes: Print Jobs
  2. Creator Classes: Print Centers
  3. Clients
  4. Print Shop Extension
  5. Parameterized Factory Methods
6. Extended Example: Color Printing
  1. New Product Classes
  2. New Creator Classes: Integrating a Parameterized Factory Method
  3. Clients
  4. Parallel Class Hierarchies
7. Key OOP Concepts Used in the Factory Method Pattern
8. Example: Sprite Factory
  1. Product Classes: Shape Widgets
  2. Creator Classes: Shape Creators
  3. Clients
9. Example: Vertical Shooter Game
  1. Product Classes
    1. Projectiles
    2. Space ships
  2. Creator Classes
    1. Weapon
    2. ShipCreator
  3. Concrete Creator Classes
  4. Clients
10. Summary
Chapter 3 Singleton Pattern
1. What is the Singleton Pattern?
  1. Key Features
  2. The Singleton Model
2. Key OOP Concepts Used with the Singleton Pattern
  1. Creating and Using a Private Class Constructor
  2. Creating a Private Class Instance
3. Minimalist Abstract Singleton
  1. Instantiation with a Private Class Parameter
  2. A Singleton Instantiation Method
  3. One Instance and Different References
4. When to Use the Singleton Pattern
  1. A Single Alert Message
  2. Just One Tune at a Time
  3. Using Multiple References in a Shopping Cart
5. Summary
Chapter 4 Decorator Pattern
1. What is the Decorator Pattern?
  1. Key Features
  2. The Decorator Model
2. Key OOP Concepts Used with the Decorator Pattern
  1. Unwanted Inheritance
  2. Wrapping Responsibilities
  3. Flexibility and Adaptability
3. Minimalist Abstract Decorator
  1. Abstract Component Class
  2. Abstract Decorator Class
  3. Concrete Decorations
  4. Wrapping Up
4. Applying a Simple Decorator Pattern in Flash: Paper Doll
  1. Setting Up the Component Class
  2. Decorator Class Dressing the Dolls
  3. The Concrete Classes
    1. Concrete component class
    2. Concrete decorator classes
  4. Implementing the Paper Doll Decorator
5. Decorating with Deadly Sins and Heavenly Virtues
  1. Adding Properties and Methods
  2. Multiple Concrete Components
  3. Decorating with Multiple Properties
  4. Multiple Method Concrete Decorations
  5. The Good and Evil Concrete Decorators
    1. Heavenly Virtues
    2. Deadly Sins
  6. Implementing the Good and Evil Decorator
    1. Dual implementation
    2. Charting souls
6. Dynamic Selection of Concrete Components and Decorations: a Hybrid Car Dealership
  1. Setting Up the Hybrid Car Components
    1. Auto abstract component
    2. Hybrid car classes concrete component
  2. Using Auto Options as Decorators
    1. The options abstract decorator
    2. The options concrete decorators
  3. Setting Up the User Interface
    1. Creating the document and setting the stage
    2. Implementing the concrete components and their decorators
7. Summary
Chapter 5 Adapter Pattern
1. What is the Adapter Pattern?
  1. A Design Pattern for Potty Training
  2. Key Features of the Adapter Pattern
2. Object and Class Adapters
  1. Object Adapters
    1. Minimalist example of an object adapter
    2. Using a parameterized adapter class
  2. Class Adapters
    1. Minimalist example of a class adapter
3. Key OOP Concepts in the Adapter Pattern
  1. Object and Class Adapters Compared
4. Example: Car Steering Adapter
  1. The Existing Class
  2. Interface Conversion
    1. The original interface
    2. The new context
    3. The new interface
  3. The Adapter Class
  4. The Client
5. Extended Example: Steering the Car Using a Mouse
6. Example: List Display Adapter
  1. The Existing Class
  2. Interface Conversion
  3. The Adapter Class
  4. The Client
7. Extended Example: Displaying the O'Reilly New Books List
8. Summary
Chapter 6 Composite Pattern
1. What is the Composite Pattern?
  1. Key Features of the Composite Pattern
2. Minimalist Example of a Composite Pattern
  1. Accessing Child Nodes
  2. Removing Nodes
    1. Creating a parent reference
    2. Implementing the remove method
  3. Building and Manipulating a Composite Structure
3. Key OOP Concepts in the Composite Pattern
4. Example: Music Playlists
  1. Queuing Songs to Play in Sequence
  2. Building Composite Playlists
5. Example: Animating Composite Objects Using Inverse Kinematics
  1. Using Inverse Kinematics
  2. Creating Component and Composite Nodes for the Snake
  3. Building the Snake Head
  4. Controlling the Snake
  5. Moving a Kinematic Pair
  6. Building the Body and Tail Segments
  7. Building the Composite Snake
6. Using Flash's Built-in Composite Structure: the Display List
  1. Creating a Composite Airplane
  2. Developing the Component and Composite Classes for the Airplane
  3. Creating the Fuselage, Wings, and Engines
  4. Building the Composite Structure
  5. Calculating the Total Weight of the Airplane
  6. Modifying Components to Reflect Damage
  7. Calculating Total Damage to the Airplane
7. Summary
Chapter 7 Command Pattern
1. What is the Command Pattern?
  1. Mom Needs to Issue Some Commands
  2. Key Features of the Command Pattern
  3. Class Diagram of the Command Pattern
2. Minimalist Example of a Command Pattern
  1. The Command Interface
  2. The Concrete Command
  3. The Receiver
  4. The Invoker
  5. The Client
  6. Setting a Trigger to Invoke the Command
3. Key OOP Concepts in the Command Pattern
4. Minimalist Example: Macro Commands
  1. The Macro Command Interface
  2. Two Concrete Subcommands
  3. The Concrete Macro Command
  4. A Macro Command Object Created from the Client
5. Example: Number Manipulator
  1. A Utility Button Class
  2. Triggering an Invoker by Button Clicks
  3. The Increment and Decrement Commands
  4. The Client
6. Extended Example: Sharing Command Objects
  1. Triggering an Invoker by Key Presses
  2. Sharing Command Objects from the Client
7. Extended Example: Implementing Undo
  1. An Abstract Interface for Commands
  2. Concrete Commands that Implement Undo
  3. Undoable Commands Assigned from the Client
8. Example: Podcast Radio
  1. What is a Podcast?
  2. Creating a Package with Utility Classes
  3. Creating a Command to Play a Podcast
  4. Developing the Radio Receiver
  5. Push Button Invokers for the Radio
  6. The Client Assigns Podcasts to Push Buttons
9. Extended Example: Dynamic Command Object Assignment
  1. A Context Sensitive Invoker
  2. Commands to Dynamically Assign Command Objects
  3. Dynamic Command Assignment Setup from the Client
10. Summary
Chapter 8 Observer Pattern
1. What is the Observer Pattern?
  1. Key Features
  2. The Observer Model
2. Key OOP Concepts Used with the Observer Pattern
  1. Choose the Interface
  2. Object Composition
3. Minimalist Abstract Observer
  1. Subject Interface
  2. Observer Interface
  3. Concrete Subject
  4. Concrete Observer
  5. Working the Observer
4. Example: Adding States and Identifying Users
  1. Multiple States
  2. Who are You?
  3. Updated Observer
  4. Playing the Bugle
5. Dynamically Changing States
  1. Recording a Space Battle
  2. Giving More Work to the Concrete Classes
  3. Launching the Space Battle
    1. Setting up the Flash document
    2. Building the spaceships
    3. Building the weapons
    4. Building the Android space station and beam
    5. Writing a Change Handler
6. Example: Working with Different Data Displays
  1. The Output Designer
  2. The Concrete Classes and a Double Implementation
  3. The Data Design Classes
    1. UIList component
    2. Bar chart display
    3. The line graph
  4. Pulling All the Elements Together
7. Summary
Chapter 9 Template Method Pattern
1. What is the Template Method Pattern?
  1. Key Features
  2. The Template Method Model
2. Key OOP Concepts used with the Template Method
  1. Why Inheritance and Not Composition?
  2. Abstract Functions and Override Flexibility
  3. Consider Variation
  4. The Hollywood Principle
3. Minimalist Example: Abstract Template Method
  1. Bare Bones Template Method
  2. Testing Templates
4. Employing Flexibility in the Template Method
5. Selecting and Playing Sound and Video
  1. Setting Up the Format
  2. Not-So-Concrete Concrete Classes
  3. The Detail Classes
  4. Playing the Media
6. Hooking It Up
  1. When to Hook?
  2. The Hook as a Lonely Repairman
  3. Baja Flight with a Hook
7. Summary
Chapter 10 State Design Pattern
1. Design Pattern to Create a State Machine
  1. Key Features
  2. The State Model
    1. Transitions
    2. Triggers
    3. State design structure
2. Key OOP Concepts Used with the State Pattern
3. Minimalist Abstract State Pattern
  1. Managing All Those States: Hardworking Context Class
    1. Creating a context class
    2. Completing and testing the abstract state machine
4. Video Player Concrete State Application
5. Expanding the State Design: Adding States
  1. Adding the Pause State to the Statechart
  2. Adding New Behaviors
6. Adding More States and Streaming Capabilities
  1. Setting Up Your ActionScript 3.0 Script for FMS2
  2. The Adaptable States
7. Summary
Chapter 11 Strategy Pattern
1. What is the Strategy Pattern?
  1. Key Features
  2. The Strategy Model
2. Key OOP Concepts Used with the Strategy Pattern
  1. Encapsulating Variation
    1. Unencapsulated version (pseudocode)
    2. Encapsulated algorithms (pseudocode)
  2. Using Delegation and Delegates
3. Minimalist Abstract State Pattern
  1. Using Delegation with the Context
  2. Adding a Strategy
  3. Details of the Strategy
  4. More Delegation in a Concrete Context
  5. Pulling All the Parts Together
4. Adding More Concrete Strategies and Concrete Contexts
  1. The Clowns
  2. The Trick Interface and Implementations
  3. The Skits Interface and Implementations
  4. Here Come the Clowns!
  5. Additional Clown Functionality
    1. Adding a new clown
    2. Adding a new trick
    3. Revising clown college
  6. Tricks and Skits Reorganization: Clown Planning
5. Working with String Strategies
  1. Contexts for String Strategies
  2. String Strategies
    1. Checking strategies
    2. Sort strategies
  3. Support Classes
  4. String Strategy Test
6. Summary
Chapter 12 Model-View-Controller Pattern
1. What is the Model-View-Controller (MVC) Pattern?
  1. Model
  2. View
  3. Controller
2. Communication Between the MVC elements
3. Embedded Patterns in the MVC
4. Minimalist Example of an MVC Pattern
  1. Model as a Concrete Subject in an Observer Pattern
    1. The EventDispatcher class in ActionScript 3.0
    2. The model
  2. Controller as a Concrete Strategy in a Strategy Pattern
    1. The controller
  3. View as a Concrete Observer in an Observer Pattern and context in a Strategy Pattern
  4. Building the MVC Triad
  5. Nested Views as Leaves and Nodes of a Composite Pattern
    1. Component and composite views
    2. Creating nested views
  6. Building the Nested View Structure
  7. Key Features of the MVC Pattern
5. Key OOP Concepts in the MVC Pattern
6. Example: Weather Maps
  1. The Model
  2. The Controller
  3. The Views
    1. Combo box view
    2. Map view
  4. Building the MVC Triad
  5. Setting the Model to Self-Update
7. Extended Example: Infrared Weather Maps
  1. Adding a New Model
  2. Adding a New Controller
  3. Adding a New View
  4. Building the MVC Triad
8. Example: Cars
  1. The Model
  2. The Controller
  3. The Views
  4. Building the Car
9. Custom Views
  1. Direction Gauge View
  2. GPS View
  3. Adding the Custom Views
10. Adding a Chase Car
11. Summary
Chapter 13 Symmetric Proxy Pattern
1. Simultaneous Game Moves and Outcomes
  1. The Player
  2. The Referee
  3. The Internet, Proxies, and Players
2. The Symmetric Proxy Pattern
  1. Key Features
    1. The cell
    2. The proxy
3. Key OOP Concepts Used with the Symmetric Proxy
  1. Communication Flexibility
  2. Game Flexibility
4. The Player Interface
5. The Referee
  1. Methods
  2. Template Method
  3. RPS Subclass
6. Information Shared over the Internet
7. Player-Proxy Classes
  1. Move Making
    1. Event to move
    2. Dual moves
    3. Proxy move
    4. Referee object
  2. Player 2 Changes
8. Classes and Document Files Support
  1. Dynamic Output Text Fields
  2. Button Controls
  3. The Flash File and Connection Movie Clip
9. Summary

Title:

ActionScript 3.0 Design Patterns

By:

William Sanders, Chandima Cumaranatunge

Publisher:

O'Reilly Media / Adobe Dev Library

Formats:

Print
Ebook
Safari Books Online

Print:

July 2007

Ebook:

December 2008

Pages:

544

Print ISBN:

978-0-596-52846-1

| ISBN 10:

0-596-52846-9

Ebook ISBN:

978-0-596-15868-2

| ISBN 10:

0-596-15868-8

Description

Table of Contents

Product Details

About the Author

Recommended for You

Recently Viewed

Developing Bioinformatics Computer Skills

By Cynthia Gibas, Per Jambeck

April 2001

Print: $44.99

Customer Reviews

REVIEW SNAPSHOT®

by PowerReviews

oreilly ActionScript 3.0 Design Patterns

4.6

(based on 8 reviews)

100%

of respondents would recommend this to a friend.

Pros

Well-written (4)
Accurate (3)
Helpful examples (3)

Cons

Best Uses

Intermediate (3)

- Reviewer Profile:
- Developer (4)

Reviews

Reviewed by 8 customers

Sort by

Displaying reviews 1-8

7/8/2011

5.0

Great book for introduciong patterns!

By Userman

from Norway

About Me Developer

Pros

Accurate
Easy to understand
Well-written

Cons

Best Uses

Intermediate
Student

Comments about oreilly ActionScript 3.0 Design Patterns:

This book is a great book introdction to design patterns. It is one of very few programming books that uses AS3 as language, and I love that. This book gives a great introduction to every single pattern it describes and teaches you some AS3 as well. Great ook!

5/19/2011

5.0

Program Flash Like a Programmer

By ns_holmes

from St. Louis Mo

About Me Designer, Developer

Pros

Concise
Easy to understand
Helpful examples
Well-written

Cons

Best Uses

Intermediate
Novice
Student

Comments about oreilly ActionScript 3.0 Design Patterns:

Fun, useful, and easy to understand.

This book helps Actionscript 3.0 programmers program like a programmer. There are lots of examples with clear explanations. The Topic of Design Patterns is complex, but this book is a excellent ice breaker and reference.

I highly recommend it to designers that are brave enough to tackle the world of programming. If you can get a good grasp on you will become invaluable.

My only complaint: There are a about 5 editorial errors where example code is missing. However they have been corrected in errata files.

5/23/2010

5.0

Solid overview of major patterns for AS3

By Jeremy

from Houston, TX

About Me Developer

Pros

Accurate
Helpful examples
Well-written

Cons

Best Uses

Intermediate

Comments about oreilly ActionScript 3.0 Design Patterns:

The book is for people who have foundational knowledge in programming and Actionscript 3.0. Its a great book on how to harness the knowledge you already have and make it work in practical patterns. If you program regularly, this is a book you should read and patterns that you should be using in your projects.

10/25/2009

(3 of 5 customers found this review helpful)

4.0

Very useful book

By Cancerinform

from Davis, CA

About Me Developer

Pros

Accurate
Helpful examples
Well-written

Cons

Best Uses

Expert

Comments about oreilly ActionScript 3.0 Design Patterns:

This book is not simple for readers who do not have a programming/computer science background like me. Also one has to be very familiar (expert) in AS3. However, I don't think one can explain design patterns in an easier fashion as is done in the book. The great news about this book is that it actually now makes actionscript a real programming language equal to others. I personally learned a lot and implemented successfully several design patterns in applications. I read about a criticism that this book is not Flash-specific. However, I think that is not such an important issue. In fact the book now provides the basis to do it by oneself.
A negative point is that the exercises are not always well put together and sometimes one has to find out which class files belong to one exercise. However, if somebody is serious about programming in Flash I strongly recommend reading this book.

4/1/2009

(1 of 1 customers found this review helpful)

5.0

Awesome reading!

By Paul Milbourne

from Undisclosed

Comments about oreilly ActionScript 3.0 Design Patterns:

For any serious ActionScripter, there comes a point when you have to explore advance theory and programming methodology. All too often in our industry, developers are self taught with no formal training or programming education. This is an excellent book to bridge the gap. Learning to program with design patterns helps developers deliver more efficient and well-organized applications. Further, this book helps you determine the right tool for the job. And, because the authors are both college professors in the fields of programming and multimedia development, the book is logically delivered and easy to understand.

6/17/2008

(1 of 1 customers found this review helpful)

4.0

Book for Real Developers.

By Draco

from Undisclosed

Comments about oreilly ActionScript 3.0 Design Patterns:

If you want to build realy big apps in AS, you should definitly make friends with design patterns. And thats why this book was created. It covers all of most helpful design patterns you would need in developing AS applications.

Patterns are grouped, depending on their type, and this is very good move, cause we can very easy find pattern which we need.

Groups used in book:

Creational PatternFactory Method Pattern Singleton PatternStructural PatternsDecorator Pattern Adapter Pattern Coposite Pattern Behavioral Patterns Command Pattern Observer Pattern Template Metod Pattern State Pattern Strategy Pattern Multiple Patterns MVC Pattern Symetric Proxy Pattern

All patterns are realy good described. This is not theorycrafting book, apart from theory, there are always one or two examples.

For me the best thing is that you can go throught the book, read (and understand!) introduction of every pattern, maybe some examples, and when you will be developing this BIG_APP, and when you will find a place for one of the patterns, you can easily find it and include in your project.

Of course this book is not perfect - sometimes provided examples are too easy to fully show potential of pattern, and reader can misunderstand benefits of using it.

Even so, this book is must have for people who don't know design patterns, and want to develop realy good applications in ActionScript 3.0

Best Regards

Michał Czaicki

4/19/2008

(1 of 1 customers found this review helpful)

5.0

Patterns are not owned by a language

By williebegoode

from Undisclosed

Comments about oreilly ActionScript 3.0 Design Patterns:

This is a response to the idea that somehow the book "borrowed" design patterns from C++ and Java. Actually, C++, Java, C# and ActionScript 3.0 "borrowed" the patterns from SmallTalk, the programming language that was used in the original design pattern book by Gamma and his associates. All of the examples in this book are for Flash/ActionScript 3.0 programmers and the authors looked at design patterns in lots of different programming languages to help them understand the key relationships between classes and interfaces that make up the bulk of what design patterns are all about. So, the most accurate language of origin would be SmallTalk, but even that isn't quite right. By examining how different languages made the connections between classes, the authors were better able to make examples that used ActionScript 3.0 in ways unique to the language and the programming environment of Flash.

In the chapter on Model View Controller, one of the parts that make up the MVC uses built-in design patterns in ActionScript 3.0 itself. However, those built-in patterns were originally derived from the language in the original Design Pattern book by the Gang of Four.

11/13/2007

(0 of 1 customers found this review helpful)

4.0

ActionScript 3.0 Design Patterns: Thinking in Patterns

By Anonymous

from Undisclosed

Comments about oreilly ActionScript 3.0 Design Patterns:

The book basically got the design patterns from Java and C++. Since ActionScript is an object oriented language, sure enough the book gave really good examples on how to implement those patterns. There is a lot of code examples in the book.

The examples in the book are really interesting specially the vertical shooting game example.

If you use ActionScript a lot, this will help design better and write better codes by example.

Displaying reviews 1-8

Save a Tree - Go Digital what is this?

Ebook: $35.99

Formats: DAISY, ePub, Mobi, PDF

Print & Ebook: $49.49

Print: $44.99

Safari Books Online - Read now >

Chapter 1 Object-Oriented Programming, Design Patterns, and ActionScript 3.0

The Pleasure of Doing Something Well

OOP Basics

Abstraction

Encapsulation

Inheritance

Polymorphism

Principles of Design Pattern Development

Program to Interfaces over Implementations

Favor Composition

Maintenance and Extensibility Planning

Your Application Plan: It Ain't You Babe

Chapter 2 Factory Method Pattern

What is the Factory Method Pattern?

Abstract Classes in ActionScript 3.0

Minimalist Example

Hiding the Product Classes

Example: Print Shop

Extended Example: Color Printing

Key OOP Concepts Used in the Factory Method Pattern

Example: Sprite Factory

Example: Vertical Shooter Game

Summary

Chapter 3 Singleton Pattern

What is the Singleton Pattern?

Key OOP Concepts Used with the Singleton Pattern

Minimalist Abstract Singleton

When to Use the Singleton Pattern

Summary

Chapter 4 Decorator Pattern

What is the Decorator Pattern?

Key OOP Concepts Used with the Decorator Pattern

Minimalist Abstract Decorator

Applying a Simple Decorator Pattern in Flash: Paper Doll

Decorating with Deadly Sins and Heavenly Virtues

Dynamic Selection of Concrete Components and Decorations: a Hybrid Car Dealership

Summary

Chapter 5 Adapter Pattern

What is the Adapter Pattern?

Object and Class Adapters

Key OOP Concepts in the Adapter Pattern

Example: Car Steering Adapter

Extended Example: Steering the Car Using a Mouse

Example: List Display Adapter

Extended Example: Displaying the O'Reilly New Books List

Summary

Chapter 6 Composite Pattern

What is the Composite Pattern?

Minimalist Example of a Composite Pattern

Key OOP Concepts in the Composite Pattern

Example: Music Playlists

Example: Animating Composite Objects Using Inverse Kinematics

Using Flash's Built-in Composite Structure: the Display List

Summary

Chapter 7 Command Pattern

What is the Command Pattern?

Minimalist Example of a Command Pattern

Key OOP Concepts in the Command Pattern

Minimalist Example: Macro Commands

Example: Number Manipulator

Extended Example: Sharing Command Objects

Extended Example: Implementing Undo

Example: Podcast Radio

Extended Example: Dynamic Command Object Assignment

Summary

Chapter 8 Observer Pattern

What is the Observer Pattern?

Key OOP Concepts Used with the Observer Pattern

Minimalist Abstract Observer

Example: Adding States and Identifying Users

Dynamically Changing States

Example: Working with Different Data Displays

Summary

Chapter 9 Template Method Pattern

What is the Template Method Pattern?

Key OOP Concepts used with the Template Method

Minimalist Example: Abstract Template Method

Employing Flexibility in the Template Method

Selecting and Playing Sound and Video

Hooking It Up