ActionScript 3.0 Design Patterns. Object Oriented Programming Techniques

Spis treści książki

• ActionScript 3.0 Design Patterns
  • SPECIAL OFFER: Upgrade this ebook with OReilly
  • A Note Regarding Supplemental Files
  • Preface
    • Who this Book is for
    • How this Book is Organized
    • What You Need to Use This Book
      • Say It Again, Sam
      • Users Guide
        • Flex 2 developers
        • Flash Media Server 2 developers
    • Companion Tools You'll Want
    • Conventions Used in This Book
    • Using Code Examples
    • We'd Like to Hear from You
    • Acknowledgments
    • Technical Reviewers
    • Editors
    • Authors
      • Bill Sanders
      • Chandima Cumaranatunge
    • Dedication:
  • 1. 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
  • 2. 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
  • 3. 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
  • 4. 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
  • 5. 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
  • 6. 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
  • 7. 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
  • 8. 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
  • 9. 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
  • 10. State Design 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
  • 11. 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
  • 12. 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
  • 13. 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
    • Summary
  • About the Authors
  • SPECIAL OFFER: Upgrade this ebook with OReilly

pokaż cały spis treści

ukryj recenzje