Dart 语言入门指南：Flutter开发第一步

Dart 是 Google 开发的面向对象的编程语言，也是 Flutter 框架的官方开发语言，具有简洁的语法和强大的异步编程能力。本文将带你快速入门 Dart 语言，从基本语法到面向对象编程，再到 Flutter 项目的依赖管理和异步函数的使用。

# 一、基本类型

Dart 是强类型语言，同时也支持类型推断。以下是 Dart 的基本数据类型：

// 数字类型
int age = 18;  // 整数值
double price = 3.14;  // 浮点数
num number = 10;  // num 可以是 int 或 double

// 字符串（UTF-16 编码的字符序列）
String name = 'John';
String greeting = "Hello, $name!";  // 字符串插值
String multiLine = '''
  多行
  字符串
''';

// 布尔值
bool isActive = true;
bool isActive = false;

// 列表 (类似其他语言的数组，有序集合)
List<int> numbers = [1, 2, 3];
var names = ['Alice', 'Bob', 'Charlie'];  // 类型推断 List<String>
print(names[0]);
print(names);

// 集合 (无序且唯一集合)
var uniqueNumbers = {1, 2, 3};  // Set<int>
// 即使你写了两个 2，集合中也只保留一个。

Set<String> countries = {'USA', 'China', 'Japan'};

// 映射 (键值对集合)
Map<String, int> scores = {'Alice': 100, 'Bob': 90};
var capitals = {
  'USA': 'Washington',
  'China': 'Beijing'
};
print(capitals['China']);

# 二、变量声明

Dart 提供了几种声明变量的方式：

// 明确指定类型
String name = 'Alice';

// 使用 var，自动推断类型
var age = 30;  // 推断为 int
// age = 30.0;  // 不能再赋值double类型的值!!!

// late 延迟初始化
late String description;
void init() {
  description = 'Some description';
}

// dynamic 动态类型，可以改变类型
dynamic dynamicVar = 'hello';
dynamicVar = 100;  // 可以重新赋值为不同类型

常量声明：

// 使用 final。只能赋值一次，运行时确定类型
final city = 'Beijing';

// 使用 const，编译时常量
const double pi = 3.14159;

区别：

• • var 可以重新赋值，但值类型不能变。

• • dynamic 类型也可以变。

• • final 是运行时常量，一旦赋值不能更改。

• • const 是编译时常量，必须在定义时确定值。

# 三、运算符

Dart 支持大多数常见的运算符：

1. 算术运算符：+, -, *, /, %, ~/ (整除), ++, --

2. 关系运算符：==, !=, >, <, >=, <=

3. 逻辑运算符：&&, ||, !

4. 赋值运算符：=, +=, -=, *=, /=, %=, ~/=, ??=（如果为 null 才赋值）

5. 条件运算符：?:, ?? (空值合并)

6. 级联运算符：.. (允许对同一对象进行一系列操作)

7. 类型测试运算符：is, is!, as

// 算术运算符
var sum = 1 + 2;
var product = 2 * 3;
var division = 5 / 2;  // 结果是 2.5
var integerDivision = 5 ~/ 2;  // 结果是 2

int a = 10, b = 3;

print(a + b);  // 13
print(a - b);  // 7
print(a * b);  // 30
print(a / b);  // 3.33...
print(a ~/ b);  // 3 （整数除）
print(a % b);  // 1 （取余）

// 字符串拼接
String first = 'Hello';
String second = 'World';
String combined = first + ' ' + second;
print(combined);  // Hello World

// 关系运算符
var isEqual = (5 == 5);
var isGreater = (10 > 5);

// 逻辑运算符
var and = (true && false);
var or = (true || false);
var not = !true;

// 赋值运算符
var x = 5;
x += 3;  // x = x + 3

String result = age >= 18 ? '成人' : '未成年';
print(result);  // 成人

// 条件表达式
var result = (age > 18) ? 'adult' : 'child';
var name = username ?? 'Guest';  // 如果 username 为 null，则使用默认值 'Guest'

// 级联运算符 (..)
var person = Person()
  ..name = 'Alice'
  ..age = 30
  ..greet();

// 类型测试运算符
if (person is Person) {
  print('It is a Person');
}

# 四、条件语句

switch字符串上也是能用的。

// if-else
if (age < 18) {
  print('未成年');
} else if (age < 65) {
  print('成年人');
} else {
  print('退休了');
}

// switch-case
var grade = 'A';
switch (grade) {
  case 'A':
    print('Excellent');
    break;
  case 'B':
    print('Good');
    break;
  case 'C':
    print('Fair');
    break;
  default:
    print('Unknown');
}

# 五、循环语句

Dart 支持多种循环方式：

// for 循环
for (var i = 0; i < 5; i++) {
  print(i);
}

// for-in 循环
var numbers = [1, 2, 3];
for (var number in numbers) {
  print(number);
}

// while 循环
var i = 0;
while (i < 5) {
  print(i);
  i++;
}

// do-while 循环
var j = 0;
do {
  print(j);
  j++;
} while (j < 5);

// forEach 方法
numbers.forEach((number) => print(number));

// map 方法
var doubled = numbers.map((number) => number * 2).toList();

# 六、函数

Dart 中的函数也是对象，是一等公民，可以作为参数传递或赋值给变量。

// 基本函数
int add(int a, int b) {
  return a + b;
}

// 箭头函数 (单行函数)
int multiply(int a, int b) => a * b;

// 可选位置参数（用方括号 `[]`）
String sayHello(String name, [String? title]) {
  return title == null ? 'Hello $name' : 'Hello $title $name';
}

// 可选命名参数（用花括号 `{}`）
void enableFlags({bool? bold, bool? hidden}) {
  // ...
}

// 默认参数值
void connect({String host = 'localhost', int port = 8080}) {
  print('$host:$port');
}

// 匿名函数
var list = ['a', 'b', 'c'];
list.forEach((item) {
  print(item);
});

// 高阶函数
Function makeAdder(int addBy) {
  return (int i) => addBy + i;
}
var add2 = makeAdder(2);
print(add2(3));  // 输出 5

# 七、面向对象编程（类与对象）

Dart 是面向对象的语言，支持类、继承、接口和混入：

// 基本类
class Person {
  // 实例变量
  String name;
  int age;
  
  // 构造函数
  Person(this.name, this.age);
  
  // 命名构造函数
  Person.guest() {
    name = 'Guest';
    age = 18;
  }
  
  // 方法
  void greet() {
    print('Hello, my name is $name');
  }
  
  // 重写 toString
  @override
  String toString() => 'Person(name: $name, age: $age)';
}

// 继承
class Student extends Person {
  String major;
  
  // 调用父类构造函数
  Student(String name, int age, this.major) : super(name, age);
  
  // 重写方法
  @override
  void greet() {
    print('Hello, I am $name, studying $major');
  }
}

// 抽象类
abstract class Shape {
  double area();  // 抽象方法
}

class Circle implements Shape {
  double radius;
  
  Circle(this.radius);
  
  @override
  double area() => 3.14 * radius * radius;
}

// Getter 和 Setter
class Rectangle {
  double width, height;
  
  Rectangle(this.width, this.height);
  
  double get area => width * height;
  set area(double value) => width = value / height;
}


// 混入 (Mixin)
mixin Musical {
  void playMusic() {
    print('Playing music');
  }
}

class Performer with Musical {
  // 现在有 playMusic 方法
}

// 工厂构造函数
class Logger {
  final String name;
  static final Map<String, Logger> _cache = {};
  
  factory Logger(String name) {
    return _cache.putIfAbsent(name, () => Logger._internal(name));
  }
  
  Logger._internal(this.name);
}

# 八、工程包的依赖引用

Dart 使用 pub 作为包管理器，依赖在 pubspec.yaml 中声明：

name: my_app
description: A sample Dart application
version: 1.0.0

environment:
  sdk: '>=2.12.0 <3.0.0'

dependencies:
  flutter:
    sdk: flutter
  http: ^1.4.0  # 版本约束
  provider: ^6.1.5

dev_dependencies:
  flutter_test:
    sdk: flutter
  test: ^1.26.2

然后运行命令：

flutter pub get

在代码中导入包：

// 导入标准库
import 'dart:math';

// 导入其他文件
import 'package:my_app/utils.dart';
import 'package:http/http.dart' as http;

// 部分导入
import 'package:large_library/utils.dart' show someFunction;

// 相对路径导入
import './models/user.dart';

void greet() async {
  await hello.loadLibrary();
  hello.printGreeting();
}

# 九、异步编程

Dart 使用 Future 和 async/await 处理异步操作：

// Future
Future<String> fetchUserOrder() {
  return Future.delayed(Duration(seconds: 2), () => 'Large Latte');
}

void main() {
  print('Fetching user order...');
  fetchUserOrder()
    .then((order) => print('Order: $order'))
    .catchError((error) => print('Error: $error'))
    .whenComplete(() => print('Done'));
}

// 使用async/await，以及其异常处理
Future<void> printOrderMessage() async {
  try {
    var order = await fetchUserOrder();
    print('Order: $order');
  } catch (error) {
    print('Error: $error');
  } finally {
    print('Done');
  }
}

// Stream 用于处理一系列异步事件（如监听按钮点击、WebSocket 数据流）
Stream<int> countStream(int to) async* {
  for (int i = 1; i <= to; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

void main() async {
  var stream = countStream(5);
  await for (var count in stream) {
    print(count);
  }
  // v2
  countStream(5).listen((count) {
    print(count);
  });
}

# 总结

本文介绍了 Dart 语言的核心基础语法，其中面向对象编程，异步编程，工程依赖这些都是后面写Flutter功能开发要具备的基础能力。Dart 语言简洁高效，结合 Flutter 框架可以高效地开发跨平台应用。