Interface 在Haxe中，当子类中没有定义方法声明时，如何在子类中强制方法声明'；s"；“摘要”；超类？

我试图以这样一种方式编写类定义：当在函数或var声明中使用时（例如

函数实例化main（mainCls:class）

），它应该强制子类具有所需的方法规范。例如，一个

init（）

方法

所以

有没有一种方法可以以抽象的方式编写一个类，这样它就可以在编译时检查它的子类（调用

…extends MyAbstractClass

）来声明一个特定的方法，并且能够扩展另一个现有的类（例如：

AbstractSprite extends Sprite

，或者

AbstractMC extends MovieClip

）

或者，类是否可以列出多个约束类型（类和接口）

例如，

Class

-虽然已经尝试过了，但可能我的语法不正确

编辑： 为了给这个问题添加更多的上下文，下面是我正在尝试使用的代码：

package;

import flash.display.DisplayObject;
import flash.display.MovieClip;
import flash.display.Sprite;
import flash.display.Stage;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
import flash.Lib;

class MyInitializer {
    public static var INSTANCE:MyInitializer;
    public static var STAGE:Stage;

    public static function init(clazz:Class<DisplayObject, InterfaceMain>) {
        if (INSTANCE != null) return INSTANCE;

        //Create a new instance of this global class:
        INSTANCE = new MyInitializer();

        //Add the 'Main' class to the stage:
        STAGE.addChild( Type.createInstance( clazz, [] ) );

        return INSTANCE;
    }
}

class SpriteMain extends Sprite implements InterfaceMain {

}

class MovieClipMain extends MovieClip implements InterfaceMain {

}

interface InterfaceMain {
    function init():Void;
}

包；
导入flash.display.DisplayObject；
导入flash.display.MovieClip；
导入flash.display.Sprite；
导入flash.display.Stage；
导入flash.display.StageAlign；
导入flash.display.StageScaleMode；
导入flash.Lib；
类初始值设定项{
公共静态变量实例：MyInitializer；
公共静态var阶段：阶段；
公共静态函数init（clazz:Class）{
如果（INSTANCE！=null）返回实例；
//创建此全局类的新实例：
实例=新的MyInitializer（）；
//将“Main”类添加到阶段：
STAGE.addChild（Type.createInstance（clazz，[]）；
返回实例；
}
}
类SpriteMain扩展了Sprite实现InterfaceMain{
}
类MovieClipMain扩展了MovieClip实现InterfaceMain{
}
接口主要{
函数init（）：Void；
}

您可以使用实现接口的基类，子类必须覆盖方法实现，我自己也遇到过这个问题，但没有完美的解决方案

---

您还可以在基类的方法中抛出异常，以强制子类需要重写它们。

您可以将类型定义为具有：

typedef可测量={
公共变量长度（默认值，null）：Int；
}
类约束{
静态公共函数main（）{
微量（试验（[]）；
跟踪（测试（[“bar”，“foo”））；
//字符串应该是可编辑的
//测试（“foo”）；
}
静态函数
测试（a:T）{
如果（a.length==0）返回“空”；
返回a.iterator（）.next（）；
}
}

啊！括号内的角括号，从来没有想过！这似乎对于将

ConcreteClass和Interface

约束在一起特别有用。我假设参数

a

不知道它的上下文是什么（我的意思是，对于自动完成）？或者它真的会在它的自动完成列表中混搭两种类型约束方法/属性吗？是的，这是一种混搭。或者，每个约束类型参数中定义的字段类型的并集。

typedef Measurable = {
  public var length(default, null):Int;
}

class Constraints {
  static public function main() {
    trace(test([]));
    trace(test(["bar", "foo"]));
    // String should be Iterable<String>
    //test("foo");
  }

  static function
  test<T:(Iterable<String>, Measurable)>(a:T) {
    if (a.length == 0) return "empty";
    return a.iterator().next();
  }
}