Question

From what I read, interfaces are basically classes for methods, right? If two classes implements the same interface, then they should both have methods described in the interface.

Now, how is this useful? Let’s say I want to call foo();.

public interface IExample {
    function foo(om:String):void;
}

class HungryClass implements IExample{
    public function foo(om:String):void{
        trace("OM NOM NOM!!! Thank you for feeding me" + om);
    }
}

class FullClass implements IExample{
    public function foo(om:String):void{
        trace("No thanks, I don't want to eat" + om);
    }
}

//somewhere..
instanceOfEitherClass.foo("cake");

How does interfacing help? Wouldn’t this work without interfacing?

Thanks

Answer 1

Lets say you have a concrete class that inherits from an abstract class. In that case you would simply do the following:

public class ConcreteClass extends AbstractClass

Now how about if you need the concrete class to also inherit from the EventDispatcher class? You can’t do the following:

public class ConcreteClass extends AbstractClass, EventDispatcher

However you can implement the EventDispatcher class’s IEventDispatcher interface and then use an EventDispatcher object like the following:

internal class ConcreteClass extends AbstractClass implements IEventDispatcher
{
    private var _eventDispatcher:EventDispatcher;

    public function ConcreteClass()
    {
        _eventDispatcher = new EventDispatcher(this);

    }// end function

    public function addEventListener(type:String, 
                                     listener:Function, 
                                     useCapture:Boolean = false, 
                                     priority:int = 0, 
                                     useWeakReference:Boolean = false):void
    {
        _eventDispatcher.addEventListener(type, listener, useCapture, priority, useWeakReference);

    }// end function

    public function dispatchEvent(event:Event):Boolean
    {
        return _eventDispatcher.dispatchEvent(event);

    }// end function

    public function hasEventListener(type:String):Boolean
    {
        return _eventDispatcher.hasEventListener(type);

    }// end function

    public function removeEventListener(type:String, 
                                        listener:Function, 
                                        useCapture:Boolean = false):void
    {
        _eventDispatcher.removeEventListener(type, listener, useCapture);

    }// end function

    public function willTrigger(type:String):Boolean
    {
        return _eventDispatcher.willTrigger(type);

    }// end function

}// end class

Using this combination of composition and interfaces you can use the concrete class as both an AbstractClass and EventDispatcher object.

Interfaces are great for allowing “unrelated objects to communicate with one another”. You can find more information on interfaces here.