这是一个简单的例子，我希望能解释清楚：
从两个变量和一个常量开始。

var foo = [10,11];
var bar = const [20,21];
const baz = [30,31];

尝试修改foo并成功。

foo.add(12); // [10,11,12]

尝试类似地修改bar，会出现错误，因为即使bar是一个变量，它的 value 也被声明为常量，因此是不可变的。

bar.add(22); // ERROR!

尝试为bar重新分配一个不同的值。这是可行的，因为bar本身没有声明为常量。

bar = [40,41];

现在，尝试再次修改bar的值，这一次它可以工作，因为它的新值不是常量。

bar.add(42)  // [40,41,42]

尝试修改baz会出现错误，因为baz本身被声明为常量，其值本质上是不可变的。

baz.add(32); // ERROR!

尝试将baz重新分配为新值，但失败了，因为baz是一个常量，不能重新分配为新值。

baz = [50,51]; // ERROR!

void main() {
  simpleUse();
  finalUse();
  constUse();
}

simpleUse() {
  print("\nsimple declaration");
  var x = [10];
  print('before: $x');
  x = [5];//changing reference allowed
  x.add(10);//changing content allowed
  print('after: $x');
}

finalUse() {
  print("\nfinal declaration");
  final x = [10];
  print('before: $x');

  // x = [10,20]; //nope changing reference is not allowed for final declaration

  x.add(20); //changing content is allowed
  print('after: $x');
}

constUse() {
  print("\nconst declaration");
  const x = [10];
  print('before: $x');

  // x = [10,20]; //nope -> changing reference is not allowed for final declaration

  // x.add(20);//nope -> changing content is not allowed
  print('after: $x');
}

此外，变量是简单值，如x = 10;
值是枚举、列表、Map、类等的示例。

我想补充的是，const的另一点是保证每次使用相同的参数构造对象时，都能获得相同的对象示例：

class Test {
  final int value; 
  const Test(this.value);
}

void main() {
  print(Test(5).hashCode == Test(5).hashCode); // false
  print((const Test(5)).hashCode == (const Test(5)).hashCode); // true
}

这就是为什么const构造函数很难为所有对象创建的原因，因为你需要确保对象可以在编译时构造。同样，为什么在创建对象之后，内部状态不能改变，正如前面的答案所示。