如何在构造函数中初始化最终类属性？

Question

在 Java 中你可以这样做：

class A {    
    private final int x;

    public A() {
        x = 5;
    }
}

在 Dart 中，我尝试过：

class A {    
    final int x;

    A() {
        this.x = 5;
    }
}

我得到两个编译错误：

必须初始化最终变量“x”。

和

'x' 不能用作 setter，因为它是 final。

有没有办法在 Dart 的构造函数中设置最终属性？

Answer 1

您不能在构造函数主体中实例化最终字段。有一个特殊的语法：

class Point {
  final num x;
  final num y;
  final num distanceFromOrigin;

  // Old syntax
  // Point(x, y) :
  //   x = x,
  //   y = y,
  //   distanceFromOrigin = sqrt(pow(x, 2) + pow(y, 2));

  // New syntax
  Point(this.x, this.y) :
    distanceFromOrigin = sqrt(pow(x, 2) + pow(y, 2));
}

Answer 2

您可以使用构造函数中的this. 语法使其更短（在https://www.dartlang.org/guides/language/language-tour#constructors 中描述）：

class Point {
  final num x;
  final num y;
  final num distanceFromOrigin;

  Point(this.x, this.y)
      : distanceFromOrigin = sqrt(pow(x, 2) + pow(y, 2));
}

如果你有一些更复杂的初始化你应该使用工厂构造函数，代码变成：

class Point {
  final num x;
  final num y;
  final num distanceFromOrigin;

  Point._(this.x, this.y, this.distanceFromOrigin);

  factory Point(num x, num y) {
    num distance = distanceFromOrigin = sqrt(pow(x, 2) + pow(y, 2));
    return new Point._(x, y, distance);
  }
}

Answer 3

这里是对最终类变量的初始化方法的简化总结。

class MyClass {
  final int x; //     <-- initialize this
}

初始化值

class MyClass {
  final int x = 'hello'.length;
}

如果初始化只能在运行时完成，您只能使用final。否则，static const 更好：

class MyClass {
  static const int x = 0;
}

初始化程序正式

class MyClass {
  MyClass(this.x);
  final int x;
}

这是最常用的方法。

初始化列表

class MyClass {
  MyClass(int x) 
    : _x = x;
  final int _x;
}

当您想保持字段私有时，这很有用。

默认参数值

对于未命名的参数，您可以用方括号 ([]) 将参数括起来，对于已命名的参数，您可以使用大括号 ({}) 括起来，然后给它一个默认值。

class MyClass {
  MyClass({this.x = 0});
  final int x;
}

如果您想使参数可选，这很有用。

你也可以用初始化列表来完成同样的事情：

class MyClass {
  MyClass({int? x}) 
    : _x = x ?? 0;
  final int _x;
}

延迟初始化

class MyClass {
  MyClass(String? a) {
    x = a?.length ?? 0;
  }
  late final int x;
}

如果您需要进行比初始化列表中允许的更复杂的初始化，这很有用。例如，我在 Flutter 中初始化手势识别器时就这样做了。

延迟初始化

使用late 的另一个优点是它在您访问该值之前不会初始化该值。

class MyClass {
  late final int x = _doHeavyTask();
  int _doHeavyTask() {
    var sum = 0;
    for (var i = 0; i < 100000000; i++) {
      sum += 1;
    }
    return sum;
  }
}

如果您有一个繁重的计算，而您只想在绝对需要时调用它，这将非常有用。

这不会初始化x：

final myClass = MyClass();

但这确实会初始化x:

final myClass = MyClass();
final value = myClass.x;

Answer 4

我遇到了类似的问题：我试图从构造函数初始化一个final 字段，同时调用一个超级构造函数。你可以想到下面的例子

class Point2d {
  final int x;
  final int y;

  Point2d.fromCoordinates(Coordinates coordinates)
      : this.x = coordinates.x,
        this.y = coordinates.y;
}

class Point3d extends Point2d {
  final int z;

  Point3d.fromCoordinates(Coordinates coordinates)
      :this.z = coordinates.z,
        super.fromCoordinates(coordinates);
}

/// Demo class, to simulate constructing an object
/// from another object.
class Coordinates {
  final int x;
  final int y;
  final int z;
}

显然这行得通。您可以使用上述语法初始化您的最终字段（检查 Point3d 的构造函数），它工作得很好！

像这样运行一个小程序来检查：

void main() {
  var coordinates = Coordinates(1, 2, 3);
  var point3d = Point3d.fromCoordinates(coordinates);
  print("x: ${point3d.x}, y: ${point3d.y}, z: ${point3d.z}");
}

应该打印x: 1, y: 2, z: 3

Answer 5

我在这里遇到了一个难题，我想初始化一个没有项目的最终 List，并在构造函数中定义一个 Stream（如本例中的 distanceFromOrigin）。

我无法用以下任何答案做到这一点，但我将它们混合在一起并且它起作用了。

例子：

class MyBloc {
  final BehaviorSubject<List<String>> itemsStream;
  final List<String> items = [];

  MyBloc() : this.itemsStream = BehaviorSubject<List<String>>.seeded([]) {
    items.addAll(List.generate(20, (index) => "Hola! I'm number $index"));
    itemsStream.add(items);
  }
}

Answer 6

class A{
  final int x;
  
  A(this.x){
  }
  
}