ActionScript 3 0 design patterns object oriented programming techniques 1st Edition by William Sanders, Chandima Cumaranatunge ISBN 0596528469 9780596528461

ActionScript 3 0 design patterns object oriented programming techniques 1st Edition by William Sanders, Chandima Cumaranatunge – Ebook PDF Instant Download/Delivery: 0596528469, 9780596528461 
Full download ActionScript 3 0 design patterns object oriented programming techniques 1st Edition after payment

Product details:

ISBN 10: 0596528469 
ISBN 13: 9780596528461
Author:  William Sanders, Chandima Cumaranatunge

ActionScript 3 0 design patterns object oriented programming techniques 1st Table of contents:

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

People also search for ActionScript 3 0 design patterns object oriented programming techniques 1st:

    
actionscript 3 0 design patterns object oriented
    
action design pattern
    
action pattern programming
    
actionscript 3 classes
    
actionscript 3 documentation

Tags: William Sanders, Chandima Cumaranatunge, ActionScript, patterns object, programming techniques