Question

我将如何做这样的事情：

class SubClass extends SuperClass {
    List<String> text = [];

    factory SubClass(bool debug) {
        var func = (info) { if (debug) text.add(info); }
        return SubClass._internal(func);
    }

    SubClass._internal(func) : super(func);
}

我无法弄清楚如何实施它，有什么建议吗？

Answer 1

如果在另一个类中定义函数，则可以在工厂构造函数中进行连接，但只能在创建实例后进行。

（当一个类有一个调用函数时，它可以被视为一个函数 - 见AddDebug类）
这里将新的AddDebug类传递给构造函数，并在创建实例后传递对文本的引用。我使用抽象类TextHolder作为接口。

如果定义内联函数，则它是一个静态方法，不能引用实例成员。

这里有两个解决方案，你可以做到这一点。如果您注释掉// alternative行，则会获得第二个解决方案

library x;

class SuperClass {
  Function _f;
  SuperClass(this._f);
  Function get f => _f;

  void set f(Function f) { // alternative
    _f = f;                //
  }                        //
}

abstract class TextHolder {
  List<String> text;
}

class SubClass extends SuperClass implements TextHolder {
  List<String> text = [];

  factory SubClass([bool debug = false])  {
    var ad = new AddDebug(true);
    var nsc = new SubClass._internal(ad);
    ad.textHolder = nsc;

    nsc.f = new AddDebug2(nsc.text, true); // alternative
    return nsc;
  }

  SubClass._internal(func) : super(func);
}


void main(List<String> args) {
  var x = new SubClass(true);
  x.f("sometext");
  x.f("anothertext");
  x.text.forEach((e) => print(e));
}


class AddDebug implements Function {
  bool _debug;
  AddDebug([this._debug = false]);

  TextHolder textHolder;

  call(info) {
    if(_debug) {
      textHolder.text.add(info);
    }
  }
}

// alternative (entire class)
class AddDebug2 implements Function {
  bool _debug;
  AddDebug2(this._text, [this._debug = false]);

  List<String> _text;

  call(info) {
    if(_debug) {
      _text.add(info);
    }
  }
}

Answer 2

对我来说似乎是语法错误，试试这个，我添加了一个分号和new

class SubClass extends SuperClass {
  List<String> text = [];

  factory SubClass(bool debug) {
    var func = (info) { if (debug) text.add(info); };    
    return new SubClass._internal(func);
  }

  SubClass._internal(func) : super(func);
}

Answer 3

我认为最好的解决方案是实现类并使用委托来模拟函数。

class SubClass implements SuperClass {
  Function _f; // dummy variable
  SuperClass _delegate;

  f(text) => _delegate.f(text);

  List<String> text = [];

  SubClass(bool debug) {
    var func = (info) { if (debug) text.add(info); };

    _delegate = new SuperClass(func);
  }
}

class SuperClass {
  Function _f;
  f(text) => _f(text);

  SuperClass(this._f);
}

void main() {
  var x = new SubClass(true);
  x.f("info");
  x.f("more info");
  x.text.forEach((e) => print(e));
}

将函数传递给超级构造函数

3 个答案: