The first thing to address with the ButtonDisabler class is the issue of making it versatile enough to handle different kinds of buttons: Buttons, MovieClips, or Sprites. To do this, we just need to think about what all those symbols have in common. They are all descended from more basic classes. So let's go back and choose a common ancestor that is low enough to encompass them all, but high enough to give us the functionality we need. So what we should do is study the inheritance chain for these classes, and to do that we just consult the help files, and look up each class. In the help system, find and expand "ActionScript 3.0 Language and Components Reference," then expand "All Classes," then find the listing for MovieClip. It will have an inheritance chain like this:

MovieClip -> Sprite -> DisplayObjectContainer -> InteractiveObject -> DisplayObject -> EventDispatcher -> Object

and the inheritance chain for SimpleButton looks like this:

SimpleButton -> InteractiveObject -> DisplayObject -> EventDispatcher -> Object

Notice that MovieClip is descended from Sprite, so MovieClip is just a more specialized kind of Sprite. So we don't need to also look up Sprite. You can see that both are descended from DisplayObjectContainer, so either one can serve as a container for other display objects. The next basic type going up the chain is InteractiveObject, and it is here that they first share common ancestry with SimpleButton, as SimpleButton is immediately descended from InteractiveObject. Therefore, we've found the first common denominator! In our class, we will no longer give the buttons a type of MovieClip, or even SimpleButton or Sprite. If we always type them as being of the "InteractiveObject" type instead, then that will encompass all of them, and we can treat them all equally. By the way, this is polymorphism! The idea that "...an instance of a subclass can be used anywhere an instance of its superclass is expected." --Colin Moock, "Essential Actionscript 3.0", page 115.

Now, in the variable list, the variables for currentButton and lastClicked can be changed to this more generic type instead:
private var currentButton:InteractiveObject;
private var lastClicked:InteractiveObject;

Inside the clickHandler function, the local variable clickedButton can have its type changed too:
var clickedButton:InteractiveObject = InteractiveObject(event.currentTarget);


By making these changes, we are making our class way more useful. Someone can now send the class an array of buttons that are of any of the three types, or even a mixture! We do need to allow for at least one difference, though: SimpleButtons differ from MovieClips and Sprites, in that, whereas you need to set buttonMode to true to get a hand cursor for MovieClips and Sprites, a SimpleButton instance will automatically already have a hand cursor. In fact, the SimpleButton class doesn't even have a buttonMode property. It's already a button, so a buttonMode property wouldn't make any sense--it's not going to be used any other way than as a button. So to allow for that difference, in the addListeners() method, as we loop through the buttons, we need to test whether a button in the array is a MovieClip or a Sprite, and only set buttonMode to true if that's the case:
if(buttons[i] is MovieClip || buttons[i] is Sprite) {
    buttons[i].buttonMode = true;
}

This code works just fine; you just need to make sure that both the MovieClip and Sprite classes are being imported. However, notice that the inheritance chain revealed that MovieClip and Sprite are both DisplayObjectContainers. Therefore, if something is a DisplayObjectContainer, it has to be either a MovieClip or a Sprite! That means that the above code could also be written like this:
if(buttons[i] is DisplayObjectContainer) {

    buttons[i].buttonMode = true;

}

And now the only class that must be imported is DisplayObjectContainer. So now the import statement block can be modified to look like this:
import flash.events.MouseEvent;
import flash.display.InteractiveObject;
import flash.display.DisplayObjectContainer;

Here's the complete class listing as it stands so far:
package com.mysite.utils {
   
    import flash.events.MouseEvent;
    import flash.display.InteractiveObject
    import flash.display.DisplayObjectContainer;
   
    public class ButtonDisabler {
       
        private var buttons:Array = new Array();
        private var currentButton:InteractiveObject;
        private var lastClicked:InteractiveObject;
       
        public function ButtonDisabler (theButtons:Array) {
            buttons = theButtons;
            addListeners();
        }
        private function addListeners():void {
            for(var i:int = 0; i < buttons.length; i++) {
                buttons[i].addEventListener(MouseEvent.CLICK, clickHandler);
                if(buttons[i] is DisplayObjectContainer) {
                    buttons[i].buttonMode = true;
                }
            }
        }
        private function clickHandler(event:MouseEvent):void {
            if(lastClicked != null) {
                lastClicked.mouseEnabled = true;
                lastClicked.alpha = 1;
            }
            var clickedButton:InteractiveObject = InteractiveObject(event.currentTarget);
            currentButton = buttons[buttons.indexOf(clickedButton)];
            currentButton.mouseEnabled = false;
            currentButton.alpha = 0.5;
            lastClicked = currentButton;
        }
    }
}

Save this new version. The class looks a bit different than it's former incarnation, and if you test the fla file at this point, you'll find that it runs and behaves identically. However, now it will also handle a group of buttons that are actual SimpleButtons or Sprites, not just MovieClips. As an exercise, you can prove it to yourself by right-clicking the "Btn" symbol in the library. Choose "properties," then select "Button" as the type. Click on each button instance on the stage, and in the properties inspector, pull down the dropdown that says "MovieClip" and change it to "Button." Now all of the instances on the stage are Buttons rather than MovieClips. Now you can test the movie, and you'll see it behaves identically.

On the next page, we'll take on that next issue: moving the alpha-changing effect to the outside of the class.