Can we change the type of a variable after declaring it?

I was reading this sentence in the Dart tutorial and didn't really understand it:

It said that "but you can change that type by specifying it." What does it mean? Can we change the type of a variable after declaring it?

"If an object isn't restricted to a single type, specify the Object type (or dynamic if necessary)" I didn't understand the sentence either. Does it mean that if we might change the type of an object, we'd better give it an Object or dynamic type?

A related question:

What does "change a variable" here mean? Is "value" the only attribute of a variable (I was wondering if we can change the type of a variable, whether it might also be counted as an attribute), so that "change a variable" simply means to change the value of it?

Thank you a lot!

This is a feature of Dart known as "type inference". When you declare a variable without explicitly giving it a type, the compiler will guess the type for you based on the context:

// The type of this variable isn't explicitly set, but the compiler 
// can tell it's supposed to be a String.
var foo = 'abc';

This is convenient in many cases, but sometimes it leads to undesirable behavior, especially when dealing with types related by inheritance:

// Example Flutter code
Widget build(BuildContext context) {
  // Let the compiler infer the type of this variable
  var child = Text('Hello World!');

  if (widget.padding != null) {
    // This throws an error because the child variable has been inferred 
    // to be of type Text, but Padding is not a Text.
    child = Padding(
      padding: widget.padding,
      child: child,
    );
  }

  return widget;
}

What the documentation is saying is that you can "change" (i.e. override) the inferred type of the variable by explicitly specifying a type:

Widget build(BuildContext context) {
  // Explicitly set child to be of type Widget
  Widget child = Text('Hello World!');

  if (widget.padding != null) {
    // The error has gone away because both Text and Padding are subtypes
    // of Widget
    child = Padding(
      padding: widget.padding,
      child: child,
    );
  }

  return widget;
}

Re: the related question

Changing a variable in this way means whether you want to be able to change the value of a variable after it's been declared. This is referred to as a variable's "mutability" - a mutable variable can be changed as many times as you want, but an immutable variable cannot be changed.

You can create immutable variables with final or const*:

final x = 0;
const y = 0;

// The variables are immutable, so trying to change their values will cause an error
x = 1;
y = 1;

And you can create mutable variables with var (or by simply specifying the type without final):

var x = 0;
int y = 0;

// The variables are mutable, so changing their values is fine
x = 1;
y = 1;

Immutable variables are often desired because a compiler can more aggressively optimize a variable's usage if it knows it will never be changed, so it's a good rule of thumb to mark a variable as final if you know you won't be changing it after creating it. (Enforced immutability is also a desirable trait in many development ideologies, but that's a topic for another time.)

*: Note that referring to variables declared with const as "variables" isn't actually accurate. Values declared with const are not variables, they are constants, and they differ from final variables in several notable ways. You can consult the Dart documentation on this difference, as well as my other answer for a somewhat more technical explanation of the difference between variables and constants in Dart.