1.本篇简介

这一篇我们主要介绍Dart中变量声明的关键字，总共有以下几个关键字：var,final,const,Object,dynamic。下面我们会通过示例来介绍每个关键字的使用和特点。

2.var

2.1 示例

我们先通过以下代码，来看看var是怎么使用的：

    ```

    var a =1;// ==> 等价与 int a = 1;

    print(a);//1

    print(a is int);//true is 关键字用来判断 变量是否某类型，此段代码中 判断a是否为int类型

    var b = "ss";

    print(b);//ss

    print(b is int);//false

    ```

上面代码可以看出，var能用于声明任何一种的变量类型，但是，根据后面print函数打印的结果（is关键字处），dart 好像能推断出变量的实际类型，我们接着往下看。

    ```

    var a = 1;

    a = "ss";//报错：A value of type 'String' can't be assigned to a variable of type 'int'.

    //类型'String'的值不能赋给类型'int'的变量

    ```

明显，dart给我们报错了，String类型的值不能赋给int类型的变量（在写出代码时，as 已经标红）。

上面的代码等价于java中：

    ``

    int a = 1;

    a = "ss";

    ``` 

这样操作变量，明显是错的，dart本身也是一个强类型语言，var只是dart提供的一个语法糖，当var变量在进行编译的时候，会自动匹配到对应的实际类型，并用实际类型来替换该类型的声明。

2.2 总结

通过上面的示例，我们可以总结出var使用方法与需要注意的地方。

1.var 可以接受任何变量类型。

2.var声明的变量一旦赋值，类型确定，不能再改变量类型。

3.final 和 const

3.1示例

这里我们将 final 和 const 放在一起进行说明，因为这两个关键字有一定的异同点，首先我们通过代码来了解final和const的相同点。

```dart

final a;//错误 The final variable ';' must be initialized. 必须初始化final变量

const b;// 错误 同上

final a1 ="ss";// ==>等价于 final String a1 = "ss";

const b1 ="ss"; // ==> 等价于 const String b1 = "ss";

a1 = "sss";//错误  a final variable ,can only be set once； final变量只能设置一次

b1 = "sss";//错误 同上

final String a2 ="ss"; // ==> 等价于 final a2 = "ss"

const String b2 ="ss"; // ==> 等价于 const b2 = "ss";

final var a3 ="ss";//错误 Members can't be declared to be both 'final' and 'var'.Try removing the keyword 'var'.

  //成员不能同时被声明为“final”和“var”。尝试删除关键字“var”。

const var b3 ="ss";//错误  同上

```

通过上面的示例可以看出，final和const的相同点有：

1.final 和 const 声明变量的时候必须初始化，而且初始化后不允许修改。

2.使用final或const修饰变量时，可以省略变量具体类型如：上面的String。

3.final或const 不能与var同用。

我们再次通过代码，来看看final和const的不同点：

```dart

 // 示例1

  final finalTime =DateTime.now();//获取当前时间

  const constTime =DateTime.now();//Cannot invoke a non-'const' constructor where a const expression is expected. 不能在需要const表达式的地方调用非'const'构造函数。

//      示例2

  final finalList = [1,2,3];

  finalList[0] =3;

  print(finalList);//3,2,3

  const constList = [1,2,3];

  constList[0] =3;

  print(constList);//Cannot modify an unmodifiable list 无法修改无法修改的列表

//      示例3

  final finalList1 = [1,2,3];

  final finalList2 = [1,2,3];

  const constList1 = [1,2,3];

  const constList2 = [1,2,3];

  print(identical(finalList1, finalList2));//false  identical 用于判断两个变量是否指向同一个对象

  print(identical(constList1, constList2));//true

```      

上面代码中，分成了三个示例，每一个示例，表达了final和const的一个不同点。我们对三个示例进行分析：

1. DateTime.now()用于获取当前的时间，是DateTime的一个命名函数，final修饰的时候并没有什么问题，但是用const进行修饰的时候，报错。不能在const表达式的地方调用非“const”构造函数。我们先看final和const的定义：

   final用于修饰在运行时有确定值的常量。（运行时常量，在代码运行的时候才会被赋值，且final是惰性初始化，在运行时第一次使用前才会被初始化）

   const用于修饰在编译时有确定值的常量。（编译时常量就是在代码编译的时候，这个常量就被存入到引用它的类的常量池中了，与定义它的类没有什么关系，运行时引用编译时常量，并不会使定义这个常量的类被加载）

   那么上面的示例1中，DateTime.now()是获取当前时间的，获取当前时间必须程序运行起来才能获取到值，那么在编译期间是不能确定值的。修改构造函数的为const的前提条件是该类中的所有成员变量都要被final或const修饰。

   2.示例2定义了两个list，分别用final和const来修饰，可以看到，final修饰的list允许修改其内部的值，const修饰的list不允许修改其内部的值。表明：const的不可变性具有传递性，final的不可变性不具有传递性。

   3.示例3定义了四个list，其中两个用final修饰，两个用const修饰，identical方法用于判断两个变量是否指向对象，可以看到final修饰的两个相同的list并不指向同一个对象，const修饰的两个相同的list则指向同一个对象。表明：值相同时final在内存中会重复创建，const会引用相同的值。

以上三点就是final和const的不同点。

4.Object和dynamic

这里我们同样将Object和dynamic放在一起进行说明，因为这两个也是有一定的异同点。下面我们通过代码来展示相同点。

```dart

Object o =3;

o ="object";

print(o);//object

dynamic d =3;

d ="dynamic";

print(dynamic);//dynamic

```

上面代码中，和var截然不同的是，原本是int类型的 变量o 和 变量d，在后面都被重新赋值为String类型，并且能够输出变量而不报错，表示 Object和dynamic 能接受任意类型，并且是动态的（动态任意类型）。

我们再看下面的代码：

```dart

class Person{

    void speak(){

        print("hello world");    

      }

    @override

     void toString(){

        print("Person");    

      }

    }

    Object o = Person();

    o.toString();//Person

    o.speak();//The method 'speak' isn't defined for the class 'Object' ; speak方法没有为Object类定义

    dynamic d = Person();

    d.toString();//Person

    d.speak();//hello world

```

上面代码中，定义了一个Person类，重写了toString并定义了一个speak方法，可以看到，当变量o调用toString方法时能正常打印，但当变量o调用Person中定义的speak方法时，报错，speak方法没有为Object类定义，也就是说dart认为变量o的类型为Object。而用dynamic声明的变量d 并没有报错。让我们来看看下面的代码，看看dynamic声明的变量在什么时候会报错：

```dart

    //在上面的基础上 我们再定义一个类

    class Machine{

        void work(){

            print("hong long long");

          }

    }

    dynamic d = Person();

    d.toString();//Person

    d.speak();//hello world

    d.work();//Class 'Person' has no instance method 'work'. 类“Person”没有实例方法“work”。

```

可以看到，当我们调用Machine类中定义的work方法时，变量d 报错了，那么此时变量d的类型就是Person。

由上面的结果可以总结出Object和dynamic的不同点：

1.检查类型的时间：
1.1 Object在编译阶段检查类型。
1.2 dynamic在运行时检查类型。

2.实例类型：
2.1 Object声明的变量，最后的类型为Object（Object为所有类的基类，多态，导致Object能够用来创建不同实例的变量），所以，Object声明的变量，只能调用在Object中定义过的方法（函数）。

2.2*** dynamic声明的变量，因为在运行时才会进行类型检查，所以只有在运行时才会成为对应的实例，（编译阶段不检查类型，所以出现了上述中 变量d 调用Machine类中的work方法并报错），和Object不同能调用Person方法的原因是：被dynamic修饰的变量编译器会提供尽可能多的组合，使得dynamic声明的变量能够调用尽可能多的方法（函数）***。

5.最后

在实际开发时，尽量少用dynamic，因为它容易引起运行时错误。

const 与 static 连用为静态常量。

类中的变量如果被const修饰，外界引用时，并不会导致这个类被加载，读者可以自己写一个类，并在类中定义一个静态代码块进行检测。

最后附上思维导图一张：

image

---

作者本人也是刚接触dart 和 flutter，写博客的原因是因为想记录学习的脚步，同时也是为了自己更加深刻的理解。如果有不对的地方，请务必指正。也欢迎大家一起学习交流。