行。这不是最漂亮的解决方案，但它会起作用。基本上，对于每个接口“AbstractX”（用其他东西替换“X”），您需要创建两个包装类：“ImportX”和“ExportX”。ExportX 的目标是通过包装 AbstractX 成功地将 AbstractX 扩展为 Object 类型，提供与 AbstractX 类型相同的所有方法，但仅使用内置/预定义数据类型或在其签名中属于 flash 的数据类型。ImportX 的目标是缩小动态加载的对象，该对象具有与 AbstractX 类型相同的特征（但不能强制转换为 AbstractX 类型且不被识别为 AbstractX 类型），但属于 AbstractX 接口的 Object 类型。ExportX 和 ImportX 都使用 ImportY、ImportZ 等；但是，ExportX 使用 ImportY、ImportZ 等。包装参数，它委托给 AbstractX 类型的对象，而 ImportX 使用它们来包装返回值，这些返回值来自委托给 Object 类型的对象。为了使这更容易理解，我提供以下示例：
公共接口 AbstractX
{
// 导出/导入函数是必需的
// 对于所有此类接口。他们允许
// 正确操作包装器。
函数导出（）：对象；
函数原始（）：对象；
// 接口功能不同
// 接口到接口。他们能
// 被称为更合适的东西。
函数接口Function1（参数：AbstractY）：AbstractZ；
函数接口Function2（参数：AbstractA）：AbstractB；
}
// Import_ 类型的类总是实现 Abstract_
公共类 ImportX 实现 AbstractX
{
// Import_ 对象的构造函数
// 始终是 Object 类型。
公共函数 ImportX(obj : Object) : void {
_loadedobj = 对象；
_exportobj = obj.export();
}
// 每个 Import_ 类都必须实现类似的“包装”功能：
公共静态函数包装（obj：对象）：AbstractX {
变量结果：AbstractX = null;
如果（对象！= null）{
if ( obj is AbstractX ){ // 如果可转换，则不直接换行。
结果 = obj as AbstractX;
}else if ( obj.original() is AbstractX ){ // 不要双重换行
结果 = obj.original() as AbstractX;
}别的{
// 需要包装。
结果 = 新 ImportX(obj);
}
}
返回结果；
}
公共函数导出（）：对象{
返回_exportobj；
}
公共函数原始（）：对象{
返回_loadedobj；
}
// 对于接口函数，我们委托给 _exportobj
// 我们包装返回值，但不包装参数。
公共函数interfaceFunction1（参数：AbstractY）：AbstractZ {
返回 AbstractZ.wrap(_exportobj.interfaceFunction1(param));
}
公共函数interfaceFunction2（参数：AbstractA）：AbstractB {
返回 AbstractB.wrap(_exportobj.interfaceFunction2(param));
}
私有变量_loadedobj：对象；
私有变量 _exportobj ：对象；
}
// 虽然 Export_ 对象提供了类似的方法来键入 Abstract_，
// 需要更改签名，以便只有内置/预定义类型
// 出现。因此 Export_ 从不实现 Abstract_。
公共类ExportX
{
// Export_ 的构造函数总是采用 Abstract_ 类型的对象
公共函数ExportX（obj：AbstractX）：无效{
_obj = 对象；
}
公共函数原始（）：对象{
返回_obj；
}
公共函数导出（）：对象{
返回这个；
}
// 对于接口函数，我们委托给 _obj
// 我们包装参数，而不是返回值。
// 还要注意签名的变化。
公共函数interfaceFunction1（参数：对象）：对象{
return _obj.interfaceFunction1(AbstractY.wrap(param));
}
公共函数interfaceFunction2（参数：对象）：对象{
return _obj.interfaceFunction2(AbstractA.wrap(param));
}
私有变量_obj：AbstractX = null；
}
// X 类的定义可以出现在任何模块中并被任何模块加载。
公共类 X 实现 AbstractX
{
公共函数 X( /* ... */ ) : void {
//...
}
公共函数导出（）：对象{
如果（！_export）{
_export = new ExportX(this);
}
返回_出口；
}
公共函数原始（）：对象{
返回这个；
}
公共函数interfaceFunction1（参数：AbstractY）：AbstractZ {
// ...
}
公共函数interfaceFunction2（参数：AbstractA）：AbstractB {
// ...
}
私有 var _export : 对象 = null;
}
// 行。所以这就是你如何使用它......
var classx : Class = dynamicLoadClassFromModule("X","module.swf");
var untypedx : Object = new classx();
var typedx : AbstractX = ImportX.wrap(untypedx);
// 使用 typedx ...