不提倡使用抽象类的原因是因为你一旦继承了这个类就是这个类型了（被定义了一种语义），就像前面我举的关于内核的例子，你继承了AbstractBrowserCore，那么它就代表了一种浏览器的内核。因为不管java还是as它们都是单继承的，也就是只有一个父类，父类的定义显然是很宝贵的，不能随随便便的来定义。
我在前面的例子上再举个例子：
像FF和IE都提供了很多不错的插件（ActiveX），这么好的资源不能浪费啊！！！我决定不只是利用其它浏览器的内核，它们的插件我也要！还有其它功能（如书签什么的），我准备把它作成服务。
这些服务包括：
使用其它浏览器的内核，使用浏览器插件，得到浏览器书签等等。

上面每个功能我都用接口来定义：

[code:php]

interface IBrowse

{

function browse(url:String):String;

function back():void;

function forward():void;

function home():void;

}

interface IPlugin

{

function getPlugins():Array;

function invoke(plugin:Object):Boolean;

}

interface IBookmark

{

function addBookmark(b:Object):void;
function getBookmarks():Array;

}

我用一个FFBrowserService来实现前面定义的所有接口（只用FF来举例）：

public class FFBrowserService implements IBrowse, IPlugin, IBookmark

{

public ovarride function browse(url:String):String

{

// 调用FF的api

}

.........

// 实现的所有接口方法

..........

}

使用 FFBrowserService类：

public class BrowserApp

{

private var _browserService:Object;

private var _bookmark:Array;

public function set browserService(bs:Object):void

{this._browserService = bs;}

public function init()

{

if(this._browser is IBookmark)

{

var bm:IBookmark = this._browserService as IBookmark;

this._bookmark = bm.getBookmarks();

}

}

public function onBackBtRelease():void

{

if(this._browserService is IBrowse == false) return;

var b:IBrowse = this._browserService as IBrowse;

b.back();

}

public function onEnterRelease():void

{

if(this._browserService is IBrowse == false) return;

var b:IBroser = this._browserService as IBrowse;

checkStatus(b.browse(inputText.text)); //检查http状态

}

public function pluginOnRelease(pl:Object):void

{

if(this._browserService is IPlugin == false) return;

var p:IPlugin = this._browserService as IPlugin;

p.invoke(pl);

}

}

[/code]

像这样用接口而不是用抽象类是不是觉得更加的灵活呢？假设一种浏览器不支持插件，那么可以不用实现IPlugin这个接口。而从语义上来讲，FFBrowserService这个类代表了整个第三方浏览器所提供的服务，而不仅仅是内核而已。

希望我的理解对你有所帮助:)

// IE实现类
public class IEBrowserCore extends AbstractBrowserCore
{
override public function browse(url:String):String
{
// 调用IE的api
}
}

// FF实现类
public class FFBrowserCore extends AbstractBrowserCore
{
override public function browse(url:String):String
{
// 调用FF的api
}
}

// 未来浏览器内核的实现类
public class SomeOtherBrowserCore extends AbstractBrowserCore
{
override public function browse(url:String):String
{
// 调用其它浏览器内核的api
}
}

// 调用这些类
public class RunApp
{
private var bcore:AbstractBrowserCore;
public function set broswerCore(core:AbstractBrowserCore):void
{
this.bcore = core;
}

public function onKeyDownEvent(e:Event)
{
var code:String = this.bcore.browse(this.inputText.text);
if(code == 404) outputText.text(”文件未找到”);
else if…..
}
}
[/code]
用户只要设置了他喜欢的内核就可以了，这就是多态的力量！可以随意更换实现，但是主程序更本就不需要有什么改变，就像FF的插件一样，非常灵活，来去自由，容易扩展。
其实像http就是一个非常抽象的协议，我们根本就不关心服务器的后台到底是什么，管它是jsp,php,asp，我们只要能看到我们想看到的就可以了。
不知道有没有解释清楚，呵呵:-)

看了下他关于用AS3实现的Abstract Class，个人感觉这个实现有点麻烦而且有效率的损失。我试着自己写了一个Abstract Class实现：

抽象类：

[code:php]

package jeff.abstract
{
import flash.errors.IllegalOperationError;

public class MyAbstractClass
{

public function MyAbstractClass(self:MyAbstractClass)
{
if(self != this)
{
throw new IllegalOperationError("Abstract class did not receive reference to self. MyAbstractClass cannot be instantiated directly.");
}
}

public function mustBeOverriden1(param:String):void
{
throw new IllegalOperationError("abstract function must be overriden");
}

public function mustBeOverriden2(param:String):void
{
throw new IllegalOperationError("abstract function must be overriden");
}

}
}

实现类：

package jeff.abstract
{
public class MyImplementClass extends MyAbstractClass
{
public function MyImplementClass()
{
super(this);
}

public override function mustBeOverriden1(param:String):void
{
trace("From or1 "+param);
}

public override function mustBeOverriden2(param:String):void
{
trace("From or2 " + param);
}
}
}

未实现抽象类中的方法的实现类：

package jeff.abstract
{
public class NotImplementAbstract extends MyAbstractClass
{
public function NotImplementAbstract()
{
super(this);
}
}
}

运行类：

package {
import flash.display.Sprite;
import jeff.abstract.MyAbstractClass;
import jeff.abstract.MyImplementClass;
import jeff.abstract.NoImplementAbstract;

public class AbstractTest extends Sprite
{
public function AbstractTest()
{
var a:MyAbstractClass = new MyImplementClass();
a.mustBeOverriden1("hi");
a.mustBeOverriden2("world");

// output: From or1 hi

From or2 world

var b:MyAbstractClass = new NotImplementAbstract();
b.mustBeOverriden1("hi");
b.mustBeOverriden2("world");

// throw exceptions

}
}
}

[/code]
我只是在抽象类中要被抽象的方法中写了个异常抛出语句，意思就是如果你没有覆盖它的话，那么在运行的时候调用这个方法就会抛出异常（并不是像他那样在new的时候就检查是否覆盖了抽象方法）。如果对我这个实现有其它看法的话欢迎评论:)