Dart语言

基础篇：

第 1 部分：Dart 的基础语法

1.1 Dart 程序的结构

一个简单的 Dart 程序通常包含一个 main() 函数，这是程序的入口点。所有 Dart 程序都会从 main() 函数开始执行。

void main() {
  print('Hello, Dart!');
}

• void 表示 main() 函数没有返回值。
• print() 是一个函数，用于将内容输出到控制台。

1.2 变量和数据类型

Dart 是一种静态类型语言，这意味着你需要声明变量的类型，或者让 Dart 自动推断类型。

void main() {
  int a = 10; // 整数类型
  double b = 20.5; // 浮动类型
  String name = 'Dart'; // 字符串类型
  bool isActive = true; // 布尔类型
  
  print(a); 
  print(b);
  print(name);
  print(isActive);
}

常见数据类型：

• int：整数
• double：浮动数
• String：字符串
• bool：布尔值（true 或 false）

1.3 常量和变量

Dart 还支持常量和变量的声明，使用 var 关键字时 Dart 会自动推断类型。

void main() {
  var age = 25; // 自动推断为 int 类型
  const pi = 3.14; // 常量（编译时值不可更改）
  final name = 'Dart Language'; // 只读变量，运行时值不可更改
  
  print(age);
  print(pi);
  print(name);
}

• const：编译时常量
• final：运行时常量

第 2 部分：控制结构

2.1 条件语句

Dart 使用 if、else 和 switch 来处理条件。

void main() {
  int number = 10;

  if (number > 0) {
    print('Number is positive');
  } else if (number < 0) {
    print('Number is negative');
  } else {
    print('Number is zero');
  }
}

2.2 循环语句

Dart 提供 for、while 和 do-while 来进行循环。

void main() {
  for (int i = 0; i < 5; i++) {
    print('i = $i');
  }
}

你也可以使用 for-in 来遍历集合：

void main() {
  List<int> numbers = [1, 2, 3, 4, 5];
  
  for (var number in numbers) {
    print(number);
  }
}

第 3 部分：函数

Dart 中的函数定义方式与其他语言类似。你可以定义带有参数和返回值的函数。

int add(int a, int b) {
  return a + b;
}

void main() {
  var result = add(3, 4);
  print(result); // 输出 7
}

• int add(int a, int b) 定义了一个接受两个整数并返回整数的函数。
• return 关键字用于返回结果。

3.1 可选参数

Dart 还支持可选参数，分为两种类型：位置参数 和 命名参数。

位置参数（Positional Parameters）：

• [] 表示参数可选，且放在必需位置参数的后面，可以指定默认值。
• 在调用时按位置传递参数，不能改变顺序。
• ? 使参数能够接受 null 值

示例：

void greet(String name, [int? age, String gende = 'Unknown']) {
  print('Hello $name, your gender is $gende');
  if (age != null) {
    print('You are $age years old.');
  }
}

void main() {
  greet('Alice', 25);  // 传递时按位置
  greet('Bob');  // 只传递 name
}

命名参数（Named Parameters）：

• 使用大括号 {} 来定义。
• 在调用时需要指定参数名，可以按任意顺序传递。
• ? 使参数能够接受 null 值
• 位置参数需按顺序传递（如下1要在'1'之前）

示例：

void greet(int index1, String index2, {required String name, int? age, String gende = 'Unknown'}) {
  print('$index2, $index1, Hello $name, your gender is $gende');
  if (age != null) {
    print('You are $age years old.');
  }
}

void main() {
  greet(age: 25, 1, name: 'Alice', '1');  // 按名称传递
  greet(name: 'Bob', 1, '1');  // 只传递 name，age 默认为 null
  // 虽然上面两行也可以运行不报错，但代码的可读性和可维护性变差
  // 建议入参按函数参数顺序
  greet(1, '1', name: 'Alice', age: 25);  // 按名称传递
  greet(1, '1', name: 'Bob');  // 只传递 name，age 默认为 null
}

第 4 部分：面向对象

Dart 是面向对象的语言，支持类和对象的创建。

4.1 定义类和对象

class Person {
  String name;
  int age;

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

  void introduce() {
    print('My name is $name and I am $age years old.');
  }
}

void main() {
  var person1 = Person('Alice', 25);
  person1.introduce();  // 输出：My name is Alice and I am 25 years old.
}

4.2 继承

class Animal {
  void speak() {
    print('Animal speaks');
  }
}

class Dog extends Animal {
  @override
  void speak() {
    print('Dog barks');
  }
}

void main() {
  var dog = Dog();
  dog.speak();  // 输出：Dog barks
}

• extends 用于继承父类。
• @override 用于重写父类方法。

第 5 部分：集合和异步编程

5.1 List 和 Map

void main() {
  List<String> fruits = ['Apple', 'Banana', 'Orange'];
  print(fruits);

  Map<String, String> capitals = {
    'USA': 'Washington, D.C.',
    'France': 'Paris',
    'Japan': 'Tokyo'
  };
  print(capitals);
}

5.2 异步编程

Dart 使用 Future 和 async、await 来处理异步操作。

Future<void> fetchData() async {
  await Future.delayed(Duration(seconds: 2));
  print('Data fetched!');
}

void main() {
  fetchData();
  print('Waiting for data...');
}

• Future 是用于表示未来某个时间点会完成的操作。
• async 和 await 用于处理异步操作。

进阶篇：

第 6 部分：错误处理

在 Dart 中，错误处理通过 try、catch 和 finally 来实现。

6.1 try、catch 和 finally

void main() {
  try {
    int result = 10 ~/ 0;  // 故意让除数为 0，抛出异常
    print(result);
  } catch (e) {
    print('An error occurred: $e');
  } finally {
    print('This will always execute');
  }
}

• try 块中放置可能会抛出异常的代码。
• catch 用来捕获异常并处理。
• finally 无论是否发生异常都会执行。

6.2 自定义异常

你还可以创建自定义的异常类来更好地处理特定的错误情况。

class CustomException implements Exception {
  String cause;
  CustomException(this.cause);

  @override
  String toString() {
    return 'CustomException: $cause';
  }
}

void main() {
  try {
    throw CustomException('Something went wrong!');
  } catch (e) {
    print('Caught an exception: $e');
  }
}

第 7 部分：库和包

Dart 允许你通过库（import）和包来扩展应用程序的功能。你可以导入 Dart 标准库或者第三方库。

7.1 导入库

import 'dart:math';  // 导入 Dart 内置的数学库

void main() {
  var random = Random();
  print(random.nextInt(100));  // 打印一个 0 到 99 之间的随机数
}

7.2 创建和使用包

你可以创建自己的 Dart 包，或者使用社区发布的包。在 pubspec.yaml 文件中配置依赖关系后，通过 import 使用这些包。

dependencies:
  http: ^1.2.2

通过 pub get 下载包，然后在代码中使用：

import 'package:http/http.dart' as http;

void main() async {
  var response = await http.get(Uri.parse('https://jsonplaceholder.typicode.com/posts'));
  print(response.body);
}

第 8 部分：异步编程（更深入）

虽然前面简单介绍了 Dart 的异步编程，但 Dart 的 async 和 await 可以更深入地应用。特别是在处理复杂的 I/O 操作或多个异步任务时，理解其工作方式非常重要。

8.1 Future 和 Stream

• Future 表示一个尚未完成的异步操作。
• Stream 用于表示一系列异步事件（比如从网络获取的数据流）。

使用 Future 进行并行操作：

Future<int> fetchData() async {
  await Future.delayed(Duration(seconds: 1));
  return 66;
}

void main() async {
  print('Fetching data...');
  int result = await fetchData();
  print('Data fetched: $result');
}

使用 Stream 来处理数据流：

Stream<int> countStream() async* {
  for (int i = 0; i < 5; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;  // 使用 yield 产生数据
  }
}

void main() async {
  await for (var count in countStream()) {
    print('Count: $count');
  }
}

• async* 和 yield 用于异步生成流数据。
• await for 用来监听流数据。

其他说明：

• async：将函数标记为异步，返回一个 Future 对象。
• await：用于等待异步操作完成，通常在 async 函数中使用。
• async*：用于定义一个返回 Stream 的异步生成器函数，支持异步地产生多个值。

第 9 部分：扩展与 mixins

9.1 扩展（Extensions）

Dart 允许你为现有的类添加新的功能，甚至不需要修改类的原始定义。通过扩展，你可以给类添加新的方法。

extension StringUtils on String {
  // 计算单词数
  int get wordCount {
    return split(' ').length;
  }

  // 获取字符串反转
  String get reverse {
    return split('').reversed.join('');
  }
}

void main() {
  String text = "Hello world, how are you?";

  print(text.wordCount);  // 输出: 5
  print(text.reverse);    // 输出: "?uoy era woh ,dlrow olleH"
}

9.2 Mixins

Mixin 是 Dart 中的一种复用代码的机制，它允许你将方法或属性混入到多个类中，而不是通过继承。

mixin Swimmable {
  void swim() {
    print('Swimming!');
  }
}

mixin Flyable {
  // 默认的属性
  String flySpeed = "fast";

  void fly() {
    print("Flying at $flySpeed speed!");
  }
}

class Bird with Flyable, Swimmable {
  // 可以重写 Flyable 中的属性
  @override
  String flySpeed = "medium";

  void chirp() {
    print('Chirp Chirp!');
  }
}

void main() {
  var bird = Bird();
  bird.swim();  // 输出: Swimming!
  bird.fly();   // 输出: Flying at medium speed!
  bird.chirp(); // 输出: Chirp Chirp!
}

• mixin 用来定义一个可以被其他类混入的类。
• with 用来将 mixin 添加到类中。

第 10 部分：Flutter 简介

Dart 的一大亮点是与 Flutter 的结合。Flutter 是一个开源的 UI 框架，允许你使用 Dart 来构建跨平台的应用。

10.1 安装 Flutter 和创建第一个应用

如果你打算学习 Flutter，可以通过安装 Flutter SDK 来开始。在 Flutter 中，你可以使用 Dart 语言来构建用户界面。

import 'package:flutter/material.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});
  
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      home: Scaffold(
        appBar: AppBar(
          title: Text('Hello, Flutter!'),
        ),
        body: Center(
          child: Text('Welcome to Dart and Flutter!'),
        ),
      ),
    );
  }
}

• runApp() 启动应用。
• MaterialApp 和 Scaffold 用于构建基本的应用界面。