Comprehensive Object-Oriented ActionScript 3.0 (5 days)

Comprehensive Object-Oriented ActionScript 3.0 Course Overview

This course is for Flash developers who wish to learn to create sophisticated scalable Flash applications using ActionScript 3.0. It focuses on using object-oriented programming rather than using procedural programming, which was typical of ActionScript 1.0 application. The ActionScript 3.0 course assumes some programming experience. It is less hands-on and more high-level than most of Webucator's courses.

Comprehensive Object-Oriented ActionScript 3.0 Course Goals

• Learn the major differences between procedural programming and object-oriented programming
• Learn to work with datatypes in ActionScript 3.0
• Learn to define classes in ActionScript 3.0
• Learn to work with inheritance, interfaces, and packages
• Learn to handle exceptions appropriately
• Learn to work within the OOP Application Framework
• Learn to develop using design patterns

Comprehensive Object-Oriented ActionScript 3.0 Course Prerequisites

Experience in the following areas is required:

• Flash
• Some programming experience

Comprehensive Object-Oriented ActionScript 3.0 Course Outline

1. Core Concepts
   1. Tools for Writing ActionScript Code
   2. Flash Client Runtime Environments
   3. Compilation
   4. Quick Review
   5. Classes and Objects
   6. Creating a Program
   7. Packages
   8. Defining a Class
   9. Virtual Zoo Review
   10. Constructor Methods
   11. Creating Objects
   12. Variables and Values
   13. Constructor Parameters and Arguments
   14. Expressions
   15. Assigning One Variable's Value to Another
   16. An Instance Variable for Our Pet
   17. Instance Methods
   18. Members and Properties
   19. Virtual Zoo Review
   20. Break Time!
2. Conditionals and Loops
   1. Conditionals
   2. Loops
   3. Boolean Logic
   4. Back to Classes and Objects
3. Instance Methods Revisited
   1. Omitting the this Keyword
   2. Bound Methods
   3. Using Methods to Examine and Modify an Object's State
   4. Get and Set Methods
   5. Handling an Unknown Number of Parameters
   6. Up Next: Class-Level Information and Behavior
4. Static Variables and Static Methods
   1. Static Variables
   2. Constants
   3. Static Methods
   4. Class Objects
   5. C++ and Java Terminology Comparison
   6. On to Functions
5. Functions
   1. Package-Level Functions
   2. Nested Functions
   3. Source-File-Level Functions
   4. Accessing Definitions from Within a Function
   5. Functions as Values
   6. Function Literal Syntax
   7. Recursive Functions
   8. Using Functions in the Virtual Zoo Program
   9. Back to Classes
6. Inheritance
   1. A Primer on Inheritance
   2. Overriding Instance Methods
   3. Constructor Methods in Subclasses
   4. Preventing Classes from Being Extended and Methods from Being Overridden
   5. Subclassing Built-in Classes
   6. The Theory of Inheritance
   7. Abstract Not Supported
   8. Using Inheritance in the Virtual Zoo Program
   9. Virtual Zoo Program Code
   10. It's Runtime!
7. Compiling and Running a Program
   1. Compiling with the Flash Authoring Tool
   2. Compiling with Flex Builder 2
   3. Compiling with mxmlc
   4. Compiler Restrictions
   5. The Compilation Process and the Classpath
   6. Strict-Mode Versus Standard-Mode Compilation
   7. The Fun's Not Over
8. Datatypes and Type Checking
   1. Datatypes and Type Annotations
   2. Untyped Variables, Parameters, Return Values, and Expressions
   3. Strict Mode's Three Special Cases
   4. Warnings for Missing Type Annotations
   5. Detecting Reference Errors at Compile Time
   6. Casting
   7. Conversion to Primitive Types
   8. Default Variable Values
   9. null and undefined
   10. Datatypes in the Virtual Zoo
   11. More Datatype Study Coming Up
9. Interfaces
   1. The Case for Interfaces
   2. Interfaces and Multidatatype Classes
   3. Interface Syntax and Use
   4. Another Multiple-Type Example
   5. More Essentials Coming
10. Statements and Operators
    1. Statements
    2. Operators
    3. Up Next: Managing Lists of Information
11. Arrays
    1. What Is an Array?
    2. The Anatomy of an Array
    3. Creating Arrays
    4. Referencing Array Elements
    5. Determining the Size of an Array
    6. Adding Elements to an Array
    7. Removing Elements from an Array
    8. Checking the Contents of an Array with the toString( ) Method
    9. Multidimensional Arrays
    10. On to Events
12. Events and Event Handling
    1. ActionScript Event Basics
    2. Accessing the Target Object
    3. Accessing the Object That Registered the Listener
    4. Preventing Default Event Behavior
    5. Event Listener Priority
    6. Event Listeners and Memory Management
    7. Custom Events
    8. Type Weakness in ActionScript's Event Architecture
    9. Handling Events Across Security Boundaries
    10. What's Next?
13. Exceptions and Error Handling
    1. The Exception-Handling Cycle
    2. Handling Multiple Types of Exceptions
    3. Exception Bubbling
    4. The finally Block
    5. Nested Exceptions
    6. Control-Flow Changes in try/catch/finally
    7. Handling a Built-in Exception
    8. More Gritty Work Ahead
14. Garbage Collection
    1. Eligibility for Garbage Collection
    2. Incremental Mark and Sweep
    3. Disposing of Objects Intentionally
    4. Deactivating Objects
    5. Garbage Collection Demonstration
    6. On to ActionScript Backcountry
15. Dynamic ActionScript
    1. Dynamic Instance Variables
    2. Dynamically Adding New Behavior to an Instance
    3. Dynamic References to Variables and Methods
    4. Using Dynamic Instance Variables to Create Lookup Tables
    5. Using Functions to Create Objects
    6. Using Prototype Objects to Augment Classes
    7. The Prototype Chain
    8. Onward!
16. Scope
    1. Global Scope
    2. Class Scope
    3. Static Method Scope
    4. Instance Method Scope
    5. Function Scope
    6. Scope Summary
    7. The Internal Details
    8. Expanding the Scope Chain via the with Statement
    9. On to Namespaces
17. Namespaces
    1. Namespace Vocabulary
    2. ActionScript Namespaces
    3. Creating Namespaces
    4. Using a Namespace to Qualify Variable and Method Definitions
    5. Qualified Identifiers
    6. A Functional Namespace Example
    7. Namespace Accessibility
    8. Qualified-Identifier Visibility
    9. Comparing Qualified Identifiers
    10. Assigning and Passing Namespace Values
    11. Open Namespaces and the use namespace Directive
    12. Namespaces for Access-Control Modifiers
    13. Applied Namespace Examples
    14. Final Core Topics
18. XML and E4X
    1. Understanding XML Data as a Hierarchy
    2. Representing XML Data in E4X
    3. Creating XML Data with E4X
    4. Accessing XML Data
    5. Processing XML with for-each-in and for-in
    6. Accessing Descendants
    7. Filtering XML Data
    8. Traversing XML Trees
    9. Changing or Creating New XML Content
    10. Loading XML Data
    11. Working with XML Namespaces
    12. Converting XML and XMLList to a String
    13. Determining Equality in E4X
    14. More to Learn
19. Flash Player Security Restrictions
    1. What's Not in This Chapter
    2. The Local Realm, the Remote Realm, and Remote Regions
    3. Security-Sandbox-Types
    4. Security Generalizations Considered Harmful
    5. Restrictions on Loading Content, Accessing Content as Data, Cross-Scripting, and Loading Data
    6. Socket Security
    7. Example Security Scenarios
    8. Choosing a Local Security-Sandbox-Type
    9. Distributor Permissions (Policy Files)
    10. Creator Permissions (allowDomain( ))
    11. Import Loading
    12. Handling Security Violations
    13. Security Domains
    14. Two Common Security-Related Development Issues
    15. On to !
20. The Display API and the Display List
    1. Display API Overview
    2. The Display List
    3. Containment Events
    4. Custom Graphical Classes
    5. Go with the Event Flow
21. Events and Display Hierarchies
    1. Hierarchical Event Dispatch
    2. Event Dispatch Phases
    3. Event Listeners and the Event Flow
    4. Using the Event Flow to Centralize Code
    5. Determining the Current Event Phase
    6. Distinguishing Events Targeted at an Object from Events Targeted at That Object's Descendants
    7. Stopping an Event Dispatch
    8. Event Priority and the Event Flow
    9. Display-Hierarchy Mutation and the Event Flow
    10. Custom Events and the Event Flow
    11. On to Input Events
22. Interactivity
    1. Mouse-Input Events
    2. Focus Events
    3. Keyboard-Input Events
    4. Text-Input Events
    5. Flash Player-Level Input Events
    6. From the Program to the Screen
23. Screen Updates
    1. Scheduled Screen Updates
    2. Post-Event Screen Updates
    3. Redraw Region
    4. Optimization with the Event.RENDER Event
    5. Let's Make It Move!
24. Programmatic Animation
    1. No Loops
    2. Animating with the ENTER_FRAME Event
    3. Animating with the TimerEvent.TIMER Event
    4. Choosing Between Timer and Event.ENTER_FRAME
    5. A Generalized Animator
    6. Velocity-Based Animation
    7. Moving On to Strokes 'n' Fills
25. Drawing with Vectors
    1. Graphics Class Overview
    2. Drawing Lines
    3. Drawing Curves
    4. Drawing Shapes
    5. Removing Vector Content
    6. Example: An Object-Oriented Shape Library
    7. From Lines to Pixels
26. Bitmap Programming
    1. The BitmapData and Bitmap Classes
    2. Pixel Color Values
    3. Creating a New Bitmap Image
    4. Loading an External Bitmap Image
    5. Examining a Bitmap
    6. Modifying a Bitmap
    7. Copying Graphics to a BitmapData Object
    8. Applying Filters and Effects
    9. Freeing Memory Used by Bitmaps
    10. Words, Words, Words
27. Text Display and Input
    1. Creating and Displaying Text
    2. Modifying a Text Field's Content
    3. Formatting Text Fields
    4. Fonts and Text Rendering
    5. Missing Fonts and Glyphs
    6. Determining Font Availability
    7. Determining Glyph Availability
    8. Embedded-Text Rendering
    9. Text Field Input
    10. Text Fields and the Flash Authoring Tool
    11. Loading . . . Please Wait . . .
28. Loading External Display Assets
    1. Using Loader to Load Display Assets at Runtime
    2. Compile-Time Type-Checking for Runtime-Loaded Assets
    3. Accessing Assets in Multiframe .swf Files
    4. Instantiating a Runtime-Loaded Asset
    5. Using Socket to Load Display Assets at Runtime
    6. Removing Runtime Loaded .swf Assets
    7. Embedding Display Assets at Compile Time
    8. On to
29. ActionScript and the Flash Authoring Tool
    1. The Flash Document
    2. Timelines and Frames
    3. Timeline Scripting
    4. The Document Class
    5. Symbols and Instances
    6. Linked Classes for Movie Clip Symbols
    7. Accessing Manually Created Symbol Instances
    8. Accessing Manually Created Text
    9. Programmatic Timeline Control
    10. Instantiating Flash Authoring Symbols via ActionScript
    11. Instance Names for Programmatically Created Display Objects
    12. Linking Multiple Symbols to a Single Superclass
    13. The Composition-Based Alternative to Linked Classes
    14. Preloading Classes
    15. Up Next: Using the Flex Framework
30. A Minimal MXML Application
    1. The General Approach
    2. A Real UI Component Example
    3. Sharing with Your Friends
31. Distributing a Class Library
    1. Sharing Class Source Files
    2. Distributing a Class Library as a .swc File
    3. Distributing a Class Library as a .swf File

Comprehensive Object-Oriented ActionScript 3.0 Course Materials

Each student will receive a copy of Essential ActionScript 3.0 by Colin Moock, which will serve as a guide for the class.

Each student will also receive a one-year subscription to Webucator's online reference library, which contains hundreds of the most current electronic technology books - a $149.95 per student value.

Comprehensive Object-Oriented ActionScript 3.0 Course Technical Requirements and Setup Instructions

Click here for technical requirements and setup instructions