类的静态和实例侧之间的区别

Question

我有一个＆＃34;汇编＆＃34;在这种情况下的问题：

interface IDataObjectConstructor {
    new (objJSON?: any): myDataObject;
}

class myDataObject implements IDataObjectConstructor {
    constructor(objJSON: any = null) {
        for (var prop in objJSON) {
            this[prop] = objJSON[prop];
        }
    }
}

它说：

class＆＃39; myDataObject＆＃39;错误地实现了界面＆＃39; IDataObjectConstructor＆＃39;。

输入＆＃39; myDataObject＆＃39;不提供签名匹配＆＃39; new（objJSON？：any）：myDataObject＆＃39;

最后我想像这样使用这个对象：

class viewModelList<T extends myDataObject>{
    item: T;
    constructor(itemType: T) { this.item = itemType; }

    itemBuilder(json?) { return new this.item(json); }
}

class derivedDataObject extends myDataObject{
    constructor(objJSON: any = null) { super(objJSON); }
}

class derivedViewModelList extends viewModelList<derivedDataObject>{

    constructor() { super(derivedDataObject); }
}

let oManager = new derivedViewModelList();

Answer 1

类的静态和实例侧之间的区别

在使用类和接口时，请记住一个类有两种类型：静态端的类型和实例端的类型。您可能会注意到，如果使用构造体签名创建接口并尝试创建实现该接口的类，则会出现错误：

interface ClockConstructor {
    new (hour: number, minute: number);
}

class Clock implements ClockConstructor { // error
    constructor(h: number, m: number) { } 
}

这是因为当类实现接口时，仅检查类的实例端。由于构造函数位于静态端，因此此检查中不包含该构造函数。

相反，您将需要直接使用类的静态方面。在此示例中，我们定义了两个接口，用于构造函数的ClockConstructor 和用于实例方法的 ClockInterface 。然后，为方便起见，我们定义了一个构造函数createClock，该函数创建传递给它的类型的实例。

interface ClockConstructor {
    new (hour: number, minute: number): ClockInterface;
}
interface ClockInterface {
    tick();
}

function createClock(ctor: ClockConstructor, hour: number, minute: number): ClockInterface {
    return new ctor(hour, minute);
}

class DigitalClock implements ClockInterface {
    constructor(h: number, m: number) { }
    tick() {
        console.log("beep beep");
    }
}
class AnalogClock implements ClockInterface {
    constructor(h: number, m: number) { }
    tick() {
        console.log("tick tock");
    }
}

let digital = createClock(DigitalClock, 12, 17);
let analog = createClock(AnalogClock, 7, 32);

由于createClock的第一个参数的类型为ClockConstructor，因此在createClock(AnalogClock, 7, 32)中，它检查AnalogClock的构造函数签名是否正确。

See the documentation for more.

Answer 2

您不需要您的类来实现自动发生的构造函数接口。

例如：

export JAVA_LIBRARY_PATH=/opt/hadoop-2.5.0-cdh5.3.3/lib/native
export LD_LIBRARY_PATH=/opt/hadoop-2.5.0-cdh5.3.3/lib/native
export HADOOP_HOME=/opt/hadoop-2.5.0-cdh5.3.3
export M2_HOME="/opt/maven/"
export MAVEN_OPTS="-Xms1024m -Xmx3000m -XX:MaxPermSize=228m -Dmaven.surefire.debug=-Xmx3000m"
export JAVA_HOME="/Library/Java/JavaVirtualMachines/jdk1.7.0_72.jdk/Contents/Home"
export PATH=${JAVA_HOME}/bin:${HADOOP_HOME}/bin:${HADOOP_HOME}/sbin:${HCAT_HOME}/bin:${M2_HOME}/bin:${PATH}

（code in playground）

interface IDataObjectConstructor { new (objJSON?: any): myDataObject; } class myDataObject { constructor(objJSON: any = null) { for (var prop in objJSON) { this[prop] = objJSON[prop]; } } } function factory(ctor: IDataObjectConstructor) { return new ctor(); } let o = factory(myDataObject);函数需要factory，我们正在传递类本身，即使未声明您的类实现它，也不会出现任何编译错误。

构造函数不提供签名new的匹配项

2 个答案:

类的静态和实例侧之间的区别