【Dart】001-变量、常量、类

【Dart】001-变量、常量、类

一、Hello World

void main() {
  hello(); // hello, world!
}

// 我从哪里来？(在哪里)
void hello(){
  // 我是谁? (是什么)
  String str = 'hello, world!';
  // 我要到哪里去？(做什么)
  print(str);
}
1
2
3
4
5
6
7
8
9
10
11

二、变量

1、定义和使用

代码演示

void main() {
  hello();
}

void hello() {
  String name = '訾博';
  String name2 = "訾博";
  String name3 = '''訾博''';
  String name4 = """訾博""";
  print('hello, world!');
  print('hello, $name!');
  print('hello, ${name}!');
  print('hello, ${name2}!');
  print('hello, ${name3}!');
  print('hello, ${name4}!');
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行结果

hello, world!
hello, 訾博!
hello, 訾博!
hello, 訾博!
hello, 訾博!
hello, 訾博!
1
2
3
4
5
6

2、声明和初始化变量的四种方式

代码演示

void main() {
  hello();
}

void hello() {
  // 1、声明并初始化变量
  String name = '訾博';
  // 2、先声明变量，再初始化
  String name2;
  name2 = '訾博';
  // 3、声明变量时，不指定类型（不推荐）
  var name3 = '訾博';
  name3 = '訾博2';
  print(name);
  print(name2);
  print(name3);
  // 4、使用其他变量初始化变量
  String name4 = name;
  print(name4);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果

訾博
訾博
訾博2
訾博
1
2
3
4

三、常量

1、使用 final 关键字声明：只能赋值一次数据

代码演示

void main() {
  final String name;
  // 不写数据类型（不推荐）
  final name2;
  name = '訾博';
  print(name);
  name = "zibo"; // The final variable 'name' can only be set once. 
}
1
2
3
4
5
6
7
8

运行结果

訾博
1

2、使用 const 关键字声明：声明时必须赋值

代码演示

void main() {
  // The constant 'name' must be initialized.
  const String name = '訾博';
  // 不写数据类型（不推荐）
  const name2 = '訾博';
  print(name);
  name = "zibo"; // Constant variables can't be assigned a value. 
}

1
2
3
4
5
6
7
8
9

运行结果

訾博
1

四、类

1、基本使用

代码演示

void main() {
  User user = User('訾博', 26);
  user.say();
  print(user.name);
  print(user.age);
}

class User {
  String name;
  int age;

  // 构造函数
  User(this.name, this.age);

  void say() {
    print('name: $name, age: $age');
  }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行结果

name: 訾博, age: 26
訾博
26
1
2
3

五、const 关键字的一点点细节

1、常量：编译期间其值就已经确定

常量对象不会在运行时创建！

代码演示

void main() {
  User user = const User('訾博', 26);
  User user2 = const User('訾博', 26);
  // 检查两个引用是否对同一个对象
  print(identical(user, user2));
  User user3 = User('zibo', 26);
  User user4 = User('zibo', 26);
  // 检查两个引用是否对同一个对象
  print(identical(user3, user4));
}

class User {
  final String name;
  final int age;

  // 构造函数，必须是 const ，否则会报错
  const User(this.name, this.age);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行结果

true
false
1
2

2、什么时候可以使用 const

使用在有 const 构造方法的类中，其所有成员必须以 final 修饰。

只有在应用未运行时就已经确定的量才是常量。

class User {
  final String name;
  final int age;

  // 构造函数，必须是 const ，否则会报错
  const User(this.name, this.age); // const 构造不能有方法体

}
1
2
3
4
5
6
7
8

3、只有被 const 的修饰的常量才不允许被修改

void main() {
  User user = const User('訾博', 26);
  const User user2 = User('訾博', 26);
  // 检查两个引用是否对同一个对象
  print(identical(user, user2));
  user = User('zibo', 26); // 正常
  user2 = User('zibo', 26); // 报错：Constant variables can't be assigned a value.
}

class User {
  final String name;
  final int age;

  // 构造函数，必须是 const ，否则会报错
  const User(this.name, this.age);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4、const 修饰列表也不允许修改

示例一

void main() {
  List<int> list = const [1, 2, 3, 4, 5];
  list.add(100);
  // 运行时报错
  // dart:_internal       UnmodifiableListMixin.add
  // test\Hello.dart 3:8  main
}
1
2
3
4
5
6
7

示例二

void main() {
  const List<int> list = [1, 2, 3, 4, 5];
  list.add(100);
  // 运行时报错
  // dart:_internal       UnmodifiableListMixin.add
  // test\Hello.dart 3:8  main
}
1
2
3
4
5
6
7

示例三

void main() {
  List<int> list = [1, 2, 3, 4, 5];
  list.add(100);
  print(list); // [1, 2, 3, 4, 5, 100]
}
1
2
3
4
5

5、flutter 中使用 const 的注意点

被标记为 const 的相同 Widget 应被视为同一对象，然后却没有！

在 debug 模式下，（由于 Dart 的去重策略）你也许会发现两个 const 的 widget 长得并不完全一样。

六、与变量相关的关键字

1、var：自动类型推断

var关键字用于声明一个变量，它是一种动态类型，可以在声明时不指定具体的类型，而是根据赋值的内容进行类型推断。例如：var message = 'Hello';。var关键字在编译时确定变量的类型，一旦确定就不能更改。

2、final：只能被赋值一次

final关键字用于声明一个只能被赋值一次的变量。一旦赋值后，无法再修改其值。它必须在声明时或构造函数中进行初始化。例如：final int age = 25;。final变量在运行时是常量。

3、const：声明时必须赋值，且只能赋值这一次

const关键字用于声明一个编译时常量。与final不同，const变量在编译时就确定了其值，且必须是常量表达式。例如：const double pi = 3.14;。const变量在编译时就被解析并分配内存。

4、late：声明时不用初始化，使用前必须初始化

late关键字用于声明一个延迟初始化的非空变量。与var、final和const不同，late变量可以在声明时不进行初始化，而是在稍后的某个时刻进行初始化。例如：late String name;。late变量在使用之前必须被正确初始化，否则会在运行时抛出异常。

5、dynamic：任意类型

在Dart中，dynamic是一个关键字，用于声明动态类型的变量。使用dynamic关键字声明的变量可以在运行时具有不同的类型，类似于其他动态语言中的变量。

使用dynamic关键字声明的变量可以存储任意类型的值，并且可以在不同的上下文中动态地改变其类型。这意味着它可以在不进行编译时类型检查的情况下，接受任何类型的值，并且可以在运行时根据需要进行类型转换。

dynamic value = 10;
print(value); // 输出：10

value = 'Hello';
print(value); // 输出：Hello

value = true;
print(value); // 输出：true
1
2
3
4
5
6
7
8

6、无关键字：变量可为空

String name;
1

在Dart中，如果你使用String name;这样的声明语句来声明一个变量，而没有为其赋予初始值，那么该变量的初始值将被默认设置为null。这意味着它是一个可空变量，可以存储null值。