The previous two components both implement the IAutomobile interface, but have nothing else in common. One is simply a class that implements the interface, the other is an MXML component that implements the interface. The MXML component example extends the mx:Canvas component (the same thing could be done by creating an AS class that extends mx.containers.Canvas). Now, let's look at a function similar to the "race" function from earlier:

public function race( auto1 : IAutomobile, auto2 : IAutomobile ) : void
{
     auto1.accellerate();
     auto2.accellerate();
}

This example will work with either object that I have created because both objects implement the IAutomobile interface. The do not rely upon functions in the class hierarchy, just those that were implemented for this interface. You can also use multiple interfaces on classes that you create. Implementing multiple interfaces basically means that you are adding more required method signatures to your class, and you will have to implement these methods to satisfy each interface. On the other hand, you cannot inherit from multiple classes. Some programming languages allow for multiple inheritance (http://en.wikipedia.org/wiki/Multiple_inheritance). ActionScript 3.0 does not support multiple inheritance (so I'll stop there).

Enough of this rambling...what does this have to do with Flex?

Inheritance and interfaces are used extensively in AS3 to create the Flex framework. Just look at the Flex documentation for the mx:Canvas component (http://livedocs.macromedia.com/flex/2/langref/mx/containers/Canvas.html) and you can see inheritance in action (http://livedocs.macromedia.com/flex/2/langref/mx/containers/Canvas.html).

Canvas
-->
Container
-->
UIComponent
-->
FlexSprite
-->
Sprite
-->
DisplayObjectContainer
-->
InteractiveObject
-->
DisplayObject
-->
EventDispatcher
-->

All Flex framework components that are rendered to the screen extend from the UIComponent class. All combo boxes and lists implement the IList interface, an AbstractService, DataService or EventDispatcher object implements the IEventDispatcher Interface. You may be using these concepts every day, but weren't aware of it, and how you can use it to your own benefit. Inheritance seems easier to take advantage of at first. Let's say that you want to create several objects, all of which will have identical functions and variables. It is easy to see that you can create a base class that encapsulates all of the common functionality. You can then create sub-classes that implement the differing functionality for each class.

When putting these concepts into real-world Flex applications, you'll need to get familiar with the following keywords: