Please do feel to mention if this idea is flawed, however I’ll be implementing it in a bit

—
Class pseudo-abstract{

private var implementedmethods:IUnimplementedmethods;

public function constructor(implementedClass:IUnimplementedmethods){

this.implementedmethods = implementedClass;

}

public function implementedfunction(){

…code…

}

public function unimplementedmethod(){

implementedmethods.unimplementedmethods();

}

}
—

I’m not an actionscript user, so please excuse my syntax …
Note that you could even emulate overriding by “try{implementedmethods.implementedfunction()}
catch(error){…code…}”
if there’s anything similar available in AS.

So all the support in Flex Builder and MXML for easy creation of event handlers and style properties fails if your MXML class has a member that is defined by just an interface.

For detection of a direct instantiation, I don’t use a self parameter. I rather compare the class name of the current this pointer with the static class name:

if( flash.utils.getQualifiedClassName(this).substring(2+flash.utils.getQualifiedClassName(this).indexOf(“::”))==”myClassName”) { throw Error…};

Some of my abstract classes contain a static function that instantiates the proper descendant based on additional parameters.

Things would be much easier if you could simply declare the constructor of the base class as protected. All that is to for implementing this is to remove the error check for a non-public constructor from the compiler and it should work as expected. I’m sure the compiler would do the right thing (and throw the right errors) if you only could get past the ‘constructors must be public’ check.

Even a private constructor could be useful, when designing a managed class.

var methods:XMLList = describeType(this).method;
for (var m in methods){
	if ((methods[m].@name.substr(0,2) == "__") && (methods[m].@declaredBy == "MyAbstractClass" )){
	throw Error(methods[m].@name + " is an abstract method, not implemented in subclass:" + Object(this).constructor);					
	}
}

In constructor of MyAbstractClass add:

if (Object(this).constructor == MyAbstractClass)
     throw new Error("MyAbstractClass is an abstract class");

In the constructor:

if(getClass(this)==CommonParserBase)
    throw new Error("This class is abstract only instantiate sub-classes.");

It results in a string comparison and requires no changes to the constructor of the abstract or concrete sub classes. I still have no good solution for finding un-implemented methods, the best I can think of is to break apart the interfaces and have the sub-classes implement a secondary interface which essentially contains what you would consider the unimplemented methods of the abstract class (in essence achieving the goal but with more files than should be necessary and possibility for confusion where abstract classes would make this clear). Also @Zeljko I think there’s a decent explanation of why you would do this above, if you ever use abstract classes in another language such as Java (among other things I miss from Java like overloading) you’d be able to more easily understand why this is really nice to have.
http://download.oracle.com/javase/tutorial/java/IandI/abstract.html
http://www.javacoffeebreak.com/faq/faq0084.html
What it comes down to is the abstract class acts much like an interface requiring certain implementations to be handled by the implementing class, however unlike interfaces, abstract classes can contain some of the functionality. As an alternative to my suggestion of breaking down the interface you could also just create a test case that calls all the methods and in the “abstract” version have it throw an error, create an instance of each concrete class in the test then call all methods of the “abstract” class that require concrete implementation. This avoids the overhead of the run time solution and would help catch errors early, the only caveat is having to use a test framework like flex unit to execute the test class.

There’s a bit simpler way of faking an abstract class.

package
{
    public class AbstractClass
    {
        public function AbstractClass()
        {
            if(String(super) == "[object AbstractClass]") throw new Error("This class is abstract and it cannot be instantiated");
        }
     }
}

Cheers.