首页  思维导图  详情

Flutter面试基础知识：dart 语法基础与重点

2025-12-09 18:33:24   1  举报





AI智能生成

flutter面试、dart面试、移动端面试、前端面试、Flutter开发入门必看、Flutter学习笔记、Dart语法、面试、必备、dart

Flutter

dart

Dart面试

面试必备

Flutter面试

作者其他创作

大纲/内容

环境搭建

Flutter配置开发环境

（0）网址：https://flutterchina.club/setup-windows/

（1）使用镜像配置环境变量

同时可以在用户中心和系统中心进行配置环境变量

mac

说明：以下是mac本配置的方式：（与window方式不一样，但是Flutter中文网上给的镜像的方式是错误的，给的mac上配置的方式，特此说明） export PUB_HOSTED_URL=https://pub.flutter-io.cn export FLUTTER_STORAGE_BASE_URL=https://storage.flutter-io.cn

window

说明：window配置镜像的方式如下。 PUB_HOSTED_URL=https://pub.flutter-io.cn FLUTTER_STORAGE_BASE_URL=https://storage.flutter-io.cn

（2）下载Flutter的SDK

网址：https://flutter.dev/docs/development/tools/sdk/releases#windows

下载完成之后，进行解压，然后在进行环境变量的配置 配置到path路径下。

环境变量配置： D:\install_files\flutter\flutter_sdk\flutter\bin 配置完成之后， 现在就可以使用flutter命令了

命令测试

打开cmd命令，执行以下命令： flutter doctor 执行结果可以查看，flutter需要的条件有哪些，哪些还没有安装，都会给你列出来。 （如上图）

（3）安装插件

以上所有工作已经完成后 打开android studio进行安装Flutter插件，安装成功后，对android studio进行重启 然后在创建新项目的时候，就可以创建flutter项目了

（4）所有的准备工作已经完成

（5）遇到的第一个问题

错误日志如下： Could not determine the dependencies of task ‘:app:compileDebugJavaWithJavac‘.

解决方法： 1、修改android目录下的build.gradle文件中的所有的google()和jcenter()换成阿里云的镜像

buildscript {     ext.kotlin_version = '1.3.50'     repositories { //        google() //        jcenter()         maven { url 'https://maven.aliyun.com/repository/google' }         maven { url 'https://maven.aliyun.com/repository/jcenter' }         maven { url 'http://maven.aliyun.com/nexus/content/groups/public' }         maven { url 'http://download.flutter.io'}     }     dependencies {         classpath 'com.android.tools.build:gradle:4.1.0'         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"     } } allprojects {     repositories { //        google() //        jcenter()         maven { url 'https://maven.aliyun.com/repository/google' }         maven { url 'https://maven.aliyun.com/repository/jcenter' }         maven { url 'http://maven.aliyun.com/nexus/content/groups/public' }         maven { url 'http://download.flutter.io'}     } } rootProject.buildDir = '../build' subprojects {     project.buildDir = "${rootProject.buildDir}/${project.name}"     project.evaluationDependsOn(':app') } task clean(type: Delete) {     delete rootProject.buildDir }

解决方法： 2、修改flutter sdk下的flutter.gradle文件，具体目录是flutter\packages\flutter_tools\gradle

buildscript {     repositories {         maven { url 'https://maven.aliyun.com/repository/google' }         maven { url 'https://maven.aliyun.com/repository/jcenter' }         maven { url 'http://maven.aliyun.com/nexus/content/groups/public' }     }     dependencies {         classpath 'com.android.tools.build:gradle:3.5.0'     } }

Dart语言

变量

在dart语言中： 变量是一个引用，未初始化的变量值是null；

Object、var与dynamic

Dart所有的变量皆对象

int是一个类 所有的基本类型都是一个class类，是与java中不同的；

例如int： abstract class int extends num

var 在声明的变量赋值那一刻，就决定了它是什么类型

例如： var j = "yulinmufeng"; j=100;(报错) var l; j = "yulinmufeng"; j=100;

常量修饰符的区别： dynamic与var的使用方法是相反的（动态的）。例如以下： dynamic z = "yulinmufeng"; z= 100; 但在实际开发的情况下，动态的声明变量和静态的声明变量，dynamic和var变量定义的在执行效率上，不如var定义的变量； dynamic一般在不确定是什么类型的时候，才会使用dynamic来声明变量； dynamic一般使用频率不是很高； var的缺点是，不能很好一眼就看出来是什么类型； object与java中的表现是一样的；

object和dynamic的区别：【调用方法的类型检查时机】不同，编译时类型检查，运行时类型。

final与const的区别

相同

声明常量

必须初始化且只能赋值一次

不同

赋值时机不同

const 编译时赋值：声明时赋值。

final 运行时赋值：局部变量或顶层变量声明时赋值。

顶层变量

简：不在任何类或函数内的变量

详：顶层变量（Top-level variable）是指直接在 Dart 文件的最外层（不在类、函数内）声明的变量，作用域全局可见。

不可修改的严格程度不同

const更严格，不仅被修饰的变量不可变，而且与之关联的变量均不可变

final

final: 用法与java中是一样的；

const

const： 在赋值之后，是不能再次进行赋值的，与final是一样的； final是运行期常量； const是编译期常量； const比final的运行效率要高；

特性： final i = 1; const j = 1; //因为i是运行时确定，所以不能给编译时候就要确定的变量赋值 //const z= i;（不可以） //可以使用另一个编译时确定的变量给它赋值 const z=j+1;(这样是可以的)

使用场景： 均可以声明一个不可变量的声明

内置类型

数据类型：num

int

说明： 1、通过源码中的注释，可以看出int类型，占用的字节数，要看编译运行的平台， 分为4字节或者8字节，但可以认为和java一样，为4个字节； 2、dart当中的int，在编码的时候，可以将int当成java的int long来使用，如果我们写的 dart代码超过了4个字节，那么dart会将其编译成类似的java当中的long否则编译成java当中的 short或者int； 3、i.bitlength=占用的字节； 4、在使用上和java的方式是一样的； 备注：原则上java和Dart语言中的int不能拿到一块进行对比，因为Dart中为class类，而java是基本 数据类型；

double

说明： 1、如果要表示float类型时，只能使用double来表示； 2、Dart中的double和在java中的double在使用方式上是一样的；

说明： 1、num内置数据类型只有两个int和double；

字符串类型：String

说明： 1、在声明上与java一样； String str = "走，一起去搓澡！";（dart） 2、方法String.format("&s%d",str,i);java中格式化一个字符串； 3、在Dart中更方便来格式化字符串， String txt = "$str$num";（Dart语言字符串拼接） String txt = "${str}s去搓澡$num"; 4、在Dart中可以使用单引号和双引号两种声明方式，所以可以混合使用； String s1 = "'test'"; String s2 = '"test"'; 5、r前缀，------s3 = r"\n" 或者s3 = r'\n'  原始字符串。在Dart代码中，前缀r表示原始字符串（raw string），作用是忽略转义字符，例如s3 = r"\n"中的\n会被当作普通字符\和n，而非换行符。 6、三引号"""sss"""或 '''sss''' ：是多行字符串。在 Dart 中，三引号 """ 或 ''' 用于定义多行字符串，允许直接跨行书写并保留换行格式。

布尔类型：bool

说明： 1、bool来定义布尔类型； 2、定义方式： bool b= false;

数据类型：List

说明： 1、List数组 2、Dart语言泛型 List<String> list = new List(); 3、直接在声明的时候赋值 List<int> list = [1,2,3,4,5]; 4、Dart语言取数据(像java数组一样通过下标取元素) int item0 = list[0]; 5、遍历数组(与java中相似) for(var o in list){ } for(var j= 0; j < list.length; ++j){ } 6、List对象不可变（const [1,2,3,4,5] = 意思就是不可以再进行添加任何的元素） List<int> list = const [1,2,3,4,5]; list.add(1);报错了 7、const修饰的是变量，也就是引用，那么变量就不能够在重新引用其他的对象了 const List<int> list = [1,2,3,4,5]; list = [3,4]; //报错了 list.add(1); //报错了 print(list); //  final List<int> list = [1,2];  list = [3,4]; // 报错了  list.add(3); // 可以使用，不同与const const 编译时静态，final是运行时静态  print(list); //

dart 为什么使用final修饰list 可以调用add方法，而使用const修饰list 不可以调用

const更加严格，不仅引用不可变，引用的所有关联的引用都不变 在Dart中，`final`和`const`关键字虽然都用于声明一个变量是不可变的，但它们的含义和用法有所不同，这也解释了为什么使用`final`修饰的列表可以调用`add`方法，而使用`const`修饰的列表则不可以。 ### final `final`关键字表示变量的引用是不可变的。也就是说，一旦给`final`变量赋了一个值，就不能再把这个变量指向另一个对象。但是，这个变量所引用的对象本身是可以修改的（如果它允许的话）。 因此，如果你有一个`final`修饰的列表（例如，`final List<int> myList = [];`），你不能让`myList`引用另一个列表。但是，你可以调用`myList`的`add`方法来修改它包含的元素，因为`myList`所引用的列表对象本身是可变的。 ### const `const`关键字则更为严格。它表示变量的引用和所引用的对象都是不可变的。这意味着你既不能改变`const`变量所引用的对象，也不能修改该对象的状态（如果它允许的话）。 因此，如果你有一个`const`修饰的列表（例如，`const List<int> myConstList = [1, 2, 3];`），这个列表的内容在声明时就已经固定了，并且之后不能再改变。`myConstList`既不能引用另一个列表，也不能通过调用`add`方法来添加新元素，因为这样做会改变列表的内容，从而违反了`const`的不可变性要求。 ### 总结 简而言之，`final`和`const`的主要区别在于它们对变量所引用对象的可变性要求不同。`final`只要求变量的引用不可变，而`const`则要求变量的引用和所引用的对象都不可变。因此，使用`final`修饰的列表可以调用`add`方法修改其内容，而使用`const`修饰的列表则不可以。

映射集合：Map

说明： 1、声明一个映射集合如下： Map<int,int> map = {1:1,2:2,3:3}; map[1]输出值=1，通过key来获取value； 2、修改一个元素的话，也是可以用个key来修改value的值 map[1] = 100; 3、用const声明map和list是一样的； var map1 = const{1:1,2:2}; const var map1 = {1:1,2:2}; 如果取一个不存在的数据会返回null； 4、迭代器遍历与java是一样的

遍历

在Dart中，Map（映射）是一种包含键值对的数据结构。遍历Map通常意味着访问其所有的键（keys）和值（values）。Dart提供了几种不同的方式来遍历Map。 以下是遍历Dart中Map的一些常见方法： ### 遍历所有的键（Keys） ```dart Map<String, int> map = {   'apple': 1,   'banana': 2,   'cherry': 3 }; // 使用for-in循环遍历所有的键 for (String key in map.keys) {   print('Key: $key'); } ``` ### 遍历所有的值（Values） ```dart Map<String, int> map = {   'apple': 1,   'banana': 2,   'cherry': 3 }; // 使用for-in循环遍历所有的值 for (int value in map.values) {   print('Value: $value'); } ``` ### 同时遍历键和值（Keys and Values） ```dart Map<String, int> map = {   'apple': 1,   'banana': 2,   'cherry': 3 }; // 使用map的entries属性遍历所有的键值对 for (MapEntry<String, int> entry in map.entries) {   print('Key: ${entry.key}, Value: ${entry.value}'); } // 或者使用键值对分解（Key-value decomposition） for (String key in map.keys) {   int value = map[key];   print('Key: $key, Value: $value'); } ``` ### 使用forEach方法遍历 ```dart Map<String, int> map = {   'apple': 1,   'banana': 2,   'cherry': 3 }; // 使用forEach方法遍历Map，对每个键值对执行操作 map.forEach((key, value) {   print('Key: $key, Value: $value'); }); ``` 在Dart中，`Map`的`entries`属性返回一个包含所有键值对的`Iterable<MapEntry<K, V>>`。`MapEntry`是一个表示单个键值对的对象，它提供了`key`和`value`属性来访问键和值。 选择哪种遍历方式取决于你的具体需求，例如，如果你只需要访问键或值，那么使用`keys`或`values`属性会更简单。如果你需要同时访问键和值，那么使用`entries`或`forEach`方法会更方便。

Unicode：Runes

说明： 1、Runes：特殊字符表示类，其实真正表示的是，Unicode32=字符编码标准，这个标准可以表示任何 字符，就是所有的字符； 2、var clapping = '\u{1f44f}';//5个16进制需要使用{},用字符串数据表示一个拍手的图标 3、代码点与代码单元（可以自己去搜索一下，这两个的区别）

标识符：Symbols

说明： 1、（很少用到，作为了解）Symbols标识符，类似C、C++中的宏（但不完全相似） 2、定义一个symbols var a = #asdfg; a输出的时候就是：symbols 使用点一般在switch中使用，其他的使用点就不多； switch(a){   case #A:   break;   case #sadsad:   break; }

说明： java中有8大基本数据类型； Dart中有7大内置类型；

操作符

类型判断，类型转换：is、is!，as：类型判定操作符、类型转换操作符

类型判断操作符：is、is!

说明： 1、dart语言中没有java中的instantof，而是需要is来实现； is：属于int类型则命中，判断对象是否是指定的类型。 if(index is int){ } is!：不属于int类型则命中if，判断对象是否不是指定的类型。 if(index is! int){ } 区别：一个是是否是，一个是是否不是

类型转换操作符：as

说明： 将对象转换为指定类型 1、Dart语言中不支持java中强制类型转换的方法 2、Dart例如： num j = 1; //类型转换，不支持java的转化：(int)强转写法 int i = j as int;

赋值操作符：直接赋值、判空赋值

=（直接赋值）

??=（空赋值符）

说明： 1、java保证k后续使用时一定不为null String k; if(null == k){    k = "123"; } 2、dart语言中，??=   判空赋值符，如果k有值，这句话就当它不存在，如果k没有值就赋值456 k  ??= "456";

级联操作符：..

说明： 1、java中的话，就像是建造者是一样的，在每次返回的时候，都是他本身，这样的话就可以一直链式调用； 2、dart中级联操作符 new  Builder()..a()..b(); class Builder {   void  a(){   }   void  b(){   } }

三重字符串：``` ```，样例：```我是三重字符串，或称之为原始字符串、多行字符串```

集合扩展操作符：[...[] ]、[...?[]]或者{...{}}、{...?{}} 列表和字典的扩展操作符

... 和 ...? 的作用 •...：将一个非空的集合解包并插入到当前集合中。 •...?：和 ... 类似，但在处理可能为 null 的集合时更加安全。如果右侧的集合为 null，...? 不会抛出错误，而是忽略该集合。

条件运算符：三目、空合并操作符

expr1 ?? expr2（空合并运算符）

说明： 1、如果expr1不为null，那么就返回expr1，否则就返回expr2 例如： String  k  = "123"; var  v  =  k  ??  "789"; 那么v= 123； 如果： k = null； var  v  = k  ??  "789"; 那么v = 789;

三目表达式：condition?expr1:expr2

说明： 1、跟java中的三目运算符是一样的

空值检查操作符：?

说明： 1、在正常开发的时候，经常遇到的异常就是空指针异常； 但是在dart语言中，可以使用?.来解决这个功能。 2、grovy和kotlin语言中都有这个?.此功能。

运算符

在Dart中，运算符用于执行各种操作，如算术运算、比较运算、位运算、逻辑运算和赋值运算等。Dart支持许多常见的运算符，这些运算符可以应用于不同类型的变量。下面是一些Dart中常见的运算符及其用法： ### 算术运算符 - `+` 加法 - `-` 减法 - `*` 乘法 - `/` 除法 - `~/` 整除（返回商的整数部分） - `%` 取模（返回除法的余数） ### 比较运算符 - `==` 等于 - `!=` 不等于 - `>` 大于 - `<` 小于 - `>=` 大于或等于 - `<=` 小于或等于 ### 位运算符 - `&` 按位与 - `|` 按位或 - `^` 按位异或 - `~` 按位取反 - `<<` 左移 - `>>` 有符号右移 - `>>>` 无符号右移 ### 逻辑运算符 - `&&` 逻辑与 - `||` 逻辑或 - `!` 逻辑非 ### 赋值运算符 - `=` 赋值 - `+=` 加等于 - `-=` 减等于 - `*=` 乘等于 - `/=` 除等于 - `~/=` 整除等于 - `%=` 取模等于 - `&=` 按位与等于 - `|=` 按位或等于 - `^=` 按位异或等于 - `<<=` 左移等于 - `>>=` 右移等于 - `>>>=` 无符号右移等于 ### 条件（三元）运算符 - `condition ? exprIfTrue : exprIfFalse` ### 条件（判空返值）运算符 - exprlfnull ?? returnDefaultExpr ### 条件（判空赋值）运算符 - exprlfnull ??= setDefaultExpr ### 类型运算符 - `is` 检查对象是否是特定类型的实例 - `is!` 检查对象是否不是特定类型的实例 - `as` 类型转换 ### 其他运算符 - `..` 级联运算符，用于在同一对象上连续调用方法或访问属性 ### 示例 下面是一些Dart运算符的使用示例： ```dart void main() {   int a = 10;   int b = 5;      // 算术运算符   int sum = a + b;       // 加法   int diff = a - b;      // 减法   int product = a * b;   // 乘法   int quotient = a / b;  // 除法   int intQuotient = a ~/ b; // 整除   int remainder = a % b; // 取模      // 比较运算符   bool isEqual = a == b;   // 等于   bool isNotEqual = a != b; // 不等于      // 逻辑运算符   bool isBothPositive = (a > 0) && (b > 0); // 逻辑与   bool isAtLeastOnePositive = (a > 0) || (b > 0); // 逻辑或      // 赋值运算符   a += b; // a = a + b;      // 条件运算符   String result = (a > b) ? 'a is greater' : 'b is greater or equal';      // 类型运算符   bool isInt = a is int; // 检查a是否是int类型      // 级联运算符   List<int> list = [];   list..add(1)..add(2)..add(3); // 连续调用add方法      print('Sum: $sum');   print('Difference: $diff');   print('Product: $product');   print('Quotient: $quotient');   print('Integer Quotient: $intQuotient');   print('Remainder: $remainder');   print('Is Equal: $isEqual');   print('Is Not Equal: $isNotEqual');   print('Is Both Positive: $isBothPositive');   print('Is At Least One Positive: $isAtLeastOnePositive');   print('Result: $result');   print('Is a an int: $isInt');   print('List: $list'); } ``` 在使用运算符时，请注意运算符的优先级和结合性。如果需要改变默认的优先级，可以使用括号来明确指定运算的顺序。

方法

参数

分类

一句话总结

Dart 参数分必需、可选位置、可选命名三类，后两者支持默认值（如 func({int x = 10})）。

可选参数：可有默认值

可选位置参数

- **可选位置参数**：使用方括号 `[]` 包裹，可以选择性提供，通常有默认值。

可选具名参数

必需参数：无默认值

必需位置参数

- **位置参数**：使用中括号`[]` 包裹按照定义顺序传递，必须提供。

位置参数（Positional Parameters）：参数是根据它们在调用时的位置来传递的。 说明： 1、java中没有； 2、dart语言中 void   fun([int i, int j]){} 可选，可默认，按照位置传参，无需带参数别名。 可选参数位置，只要是用[]（通常省略）括起来的参数，这个方法在被调用的时候，就可以传递想要传递的参数， 但是在参数传递的时候，也可以在参数中，直接给参数进行辅助，就是固定的参数，就设置为默认值； 如：void  fun([int i, int j = 2]){} 如上如果要给j就行传值的话，就必须保证要给i传值，因为有位置要求； 3、应用场景，不需要再像java一样，写一大堆的重载函数，并且能够提供参数默认值；   // ke_xuan_wei_zhi_can_shu(0);   void ke_xuan_wei_zhi_can_shu([int? i, int? j]) {     print("$i-$j");   }

与具名参数相对应的是**位置参数**（Positional Parameters）。 在 Dart 中，如果参数列表没有用大括号 `{}` 括起来，参数就是位置参数。位置参数需要按照方法声明中参数的顺序传递，且不能省略。 以下是一个使用位置参数的简单示例： ```dart void printPersonDetails(String name, int age, String city) {   print('Name: $name, Age: $age, City: $city'); } void main() {   // 调用方法时按照参数的顺序传递值   printPersonDetails('Alice', 25, 'Wonderland'); } ``` 在这个示例中，`printPersonDetails` 方法有三个位置参数：`name`、`age` 和 `city`。调用该方法时，必须按照参数的顺序传递值。 总结： - **位置参数：** 使用方法声明中参数的顺序传递值，不能省略，参数列表不用大括号 `{}` 括起来。 - **具名参数：** 允许通过参数名指定要传递的值，可以按需传递，参数列表用大括号 `{}` 括起来。 在实际编码中，你可以根据需要选择使用位置参数或具名参数，以便更清晰地传递和理解函数参数。

必需具名参数

- **具名参数**：使用大括号 `{}` 包裹，调用时通过参数名传递值。

规则

可选混合参数

- **混合参数**：可以结合位置参数和具名参数。

是否有默认参数

可选参数有默认值

详解

在 Dart 中，除了具名参数，还有其他几种参数表达方式，主要包括位置参数、可选位置参数以及可选具名参数。下面是详细说明： ### 1. **位置参数（Positional Parameters）** 位置参数是最基本的参数形式，按照它们在函数定义中的顺序传递。在调用函数时，必须按照定义时的顺序传递这些参数。 **示例：** ```dart void greet(String name, int age) {   print("Hello, $name! You are $age years old."); } ``` **调用：** ```dart void main() {   greet("Alice", 25);  // 输出: Hello, Alice! You are 25 years old. } ``` ### 2. **可选位置参数（Optional Positional Parameters）** 可选位置参数使用方括号 `[]` 包裹。在调用时，参数可以选择性地提供。如果未提供这些参数，则它们会取默认值（如果定义了默认值）。 **示例：** ```dart void greet(String name, [int age = 0]) {   print("Hello, $name! You are $age years old."); } ``` **调用：** ```dart void main() {   greet("Alice", 25);  // 输出: Hello, Alice! You are 25 years old.   greet("Bob");  // 输出: Hello, Bob! You are 0 years old. } ``` ### 3. **具名参数（Named Parameters）** 具名参数用大括号 `{}` 包裹。在调用时，可以通过参数名显式传递参数值，增加了代码的可读性。 **示例：** ```dart void greet({required String name, int age = 0}) {   print("Hello, $name! You are $age years old."); } ``` **调用：** ```dart void main() {   greet(name: "Alice", age: 25);  // 输出: Hello, Alice! You are 25 years old.   greet(name: "Bob");  // 输出: Hello, Bob! You are 0 years old. } ``` ### 4. **混合参数（Combination of Positional and Named Parameters）** 你可以在函数中同时使用位置参数和具名参数。 **示例：** ```dart void greet(String name, {int age = 0, String? city}) {   print("Hello, $name! You are $age years old and live in $city."); } ``` **调用：** ```dart void main() {   greet("Alice", age: 25, city: "New York");  // 输出: Hello, Alice! You are 25 years old and live in New York.   greet("Bob", city: "Los Angeles");  // 输出: Hello, Bob! You are 0 years old and live in Los Angeles. } ``` ### 总结 - **位置参数**：按照定义顺序传递，必须提供。 - **可选位置参数**：使用方括号 `[]` 包裹，可以选择性提供，通常有默认值。 - **具名参数**：使用大括号 `{}` 包裹，调用时通过参数名传递值。 - **混合参数**：可以结合位置参数和具名参数。 根据需要选择不同类型的参数表达方式，可以使函数调用更加灵活和清晰。

子主题

在Dart中，参数是函数或方法定义时用于接收输入值的变量。Dart支持两种类型的参数：具名参数（named parameters）和位置参数（positional parameters）。下面是关于这两种参数的详细解释以及它们之间的区别。 **位置参数** 位置参数在函数或方法定义时按照声明的顺序排列，调用时也必须按照同样的顺序传递相应的值。在Dart中，位置参数是最基本的参数形式，它们通过参数在参数列表中的位置来标识。 例如： ```dart void greet(String name, int age) {   print('Hello, $name! You are $age years old.'); } greet('Alice', 30); // 调用时，必须按照声明的顺序传递name和age ``` 在上面的例子中，`name`和`age`都是位置参数，调用`greet`方法时，必须首先传递`name`的值，然后传递`age`的值。 **具名参数** 具名参数允许在调用函数或方法时通过参数的名称来指定值，而不是依赖参数的位置。具名参数在声明时使用大括号`{}`包裹，调用时可以使用参数的名称来指定值，这使得代码更具可读性，尤其是在参数较多或顺序容易混淆的情况下。 例如： ```dart void greet({String name, int age = 20}) {   print('Hello, $name! You are $age years old.'); } greet(name: 'Bob', age: 25); // 调用时，通过参数名称指定值 ``` 在上面的例子中，`name`和`age`都是具名参数。`age`还有一个默认值`20`，这意味着如果在调用时没有提供`age`的值，它将使用默认值。

具名参数

具名参数（Named Parameters）：参数是根据它们的名称来传递的，调用时可以不考虑顺序。 说明： 即大括号 `{}` 括起来的参数。 可选，可默认，按照参数别名传参，必须带参数别名。 1、可选命名参数又名可选命题参数，并且在使用的时候，跟可选位置参数，有点相似；如下： void  fun({int i,int j}){} 在上面方法调用的时候，传递的参数，要以键值对的形式进行传递；如下： fun(j:10,i:11);//这样调用 2、也可以设置默认参数值的；如下： void  fun({int i = 2,int j}){} 3、应用场景，不需要再像java一样，写一大堆的重载函数，并且能够提供参数默认值； // ke_xuan_ming_ming_can_shu(j: 2);   void ke_xuan_ming_ming_can_shu({int i = 1, int? j}) {     print("$i-$j");   }

在 Dart 中，参数列表中大括号 `{}` 括起来的参数是**具名参数**（Named Parameters）。 具名参数允许你在调用函数或方法时通过参数名指定要传递的值，而不必按照参数声明的顺序传递。这提高了代码的可读性，并允许你仅提供感兴趣的参数，而将其他参数保留为默认值。 以下是一个具有具名参数的示例： ```dart void printPersonDetails({String name = 'John', int age = 30, String? city}) {   print('Name: $name, Age: $age, City: $city'); } void main() {   // 调用方法时通过参数名传递值   printPersonDetails(name: 'Alice', age: 25, city: 'Wonderland');      // 也可以只提供感兴趣的参数   printPersonDetails(city: 'Cityville'); } ``` 在上述示例中，`printPersonDetails` 方法有三个具名参数：`name`、`age` 和 `city`。当调用这个方法时，你可以通过参数名来传递值，而不必按照参数的顺序传递。如果某个参数没有被提供，它将使用默认值。这样，你可以更灵活地调用具有多个参数的方法。

具名参数和位置参数的区别

**两者的区别** 1. **调用方式**：位置参数按照声明的顺序调用，而具名参数通过参数名称调用。 2. **灵活性**：具名参数提供了更大的灵活性，因为可以省略某些参数（如果它们有默认值），或者按照任何顺序传递参数。位置参数则要求必须按照声明的顺序传递所有参数。 3. **可读性**：具名参数使得代码更具可读性，特别是在参数较多或参数用途不明确的情况下。通过参数名称，可以更容易地理解每个参数的作用。 4. **默认值**：具名参数可以具有默认值，而位置参数通常不具有默认值（尽管可以通过其他方式实现）。 需要注意的是，Dart中的可选命名参数和可选位置参数在调用函数时不需要为参数指定值，但可选位置参数并不直接存在。Dart的命名参数可以模拟可选位置参数的行为，通过为它们提供默认值来实现。在定义时，可选命名参数使用`{}`包裹，而位置参数则直接按照顺序列出。 最后，Dart还支持将参数标记为`@required`或`required`（具体使用哪个与Dart版本相关），以强制要求调用者在调用函数或方法时提供该参数的值。这可以在使用具名参数时提供额外的参数验证。

默认参数值

在 Dart 中，默认值只能在具名参数中使用。位置参数是不能声明默认值。

方法对象

说明： 1、 void  fun(Function f){ } void  main(){    //方法都是对象，可以赋值给Function变量    Function   f  = fun;    f((int i,int j,String str){    return "1";    }); } 以上代码运行报错，原因是参数对象不匹配，传的是Function，但是参数值确实多个； //定义一个类型：F类型，这个F类型其实就是一个方法，接受两个int 参数，返回void typedef void F(int i,int j); void fun2(F f){   f(1);报错，此时会检测传递了几个参数； } 2、在java中接口调用的方法，在dart中也是不同的； java如下： class  OnClickListener{    void onClick(){} } class Button{    void  setOnClickListener(OnClickListener listener){    } } dart如下： typedef  void  onClick(); class Button{    void setOnClickListener(onClick  listener){     listener();    } }

在Dart中，方法（或函数）本身也是对象，它们可以像其他对象一样被引用、传递和赋值。这意味着您可以存储一个方法的引用到变量中，之后可以通过这个变量来调用这个方法。这种方法对象的使用方式提供了更高的灵活性和模块化编程的可能性。 下面是一些关于Dart中方法对象使用的示例和讲解： ### 1. 方法作为变量 在Dart中，您可以创建一个变量来引用一个方法，然后使用该变量来调用该方法。 ```dart void greet(String name) {   print('Hello, $name!'); } void main() {   // 将greet方法引用赋值给变量sayHello   var sayHello = greet;      // 使用变量sayHello来调用方法   sayHello('World'); // 输出: Hello, World! } ``` 在这个例子中，`greet`方法的引用被赋值给了变量`sayHello`。之后，我们可以通过`sayHello`变量来调用`greet`方法。 ### 2. 方法作为参数传递 Dart允许您将方法作为参数传递给其他方法或函数。这通常用于实现回调函数或高阶函数。 ```dart void executeCallback(void Function(String) callback, String message) {   callback(message); } void greet(String name) {   print('Hello, $name!'); } void main() {   executeCallback(greet, 'Dart'); // 输出: Hello, Dart! } ``` 在这个例子中，`executeCallback`函数接受一个函数作为第一个参数（即回调函数），以及一个字符串作为第二个参数。它调用传入的回调函数，并将字符串作为参数传递。 ### 3. 方法作为返回值 Dart中的方法也可以返回其他方法作为结果。这允许您创建返回函数或闭包的函数。 ```dart // 返回一个函数 Function makeGreeter(String prefix) {   return (String name) {     print('$prefix, $name!');   }; } void main() {   // 创建greeter函数   var greeter = makeGreeter('Hello');      // 调用greeter函数   greeter('Dart'); // 输出: Hello, Dart! } ``` 在这个例子中，`makeGreeter`函数返回一个接受`String`参数并打印问候语的函数。返回的函数被赋值给`greeter`变量，之后可以通过这个变量来调用它。 ### 4. 方法作为闭包 闭包是Dart中一个强大的概念，它允许函数（或方法）捕获其词法环境（lexical environment），即它们被定义时的外部变量。闭包可以记住并访问其外部作用域中的变量，即使函数在其外部作用域之外执行。 ```dart void main() {   var greeting = 'Hello';      // 创建一个闭包   Function sayMessage = () {     print('$greeting, Dart!');   };      // 调用闭包   sayMessage(); // 输出: Hello, Dart! } ``` 在这个例子中，`sayMessage`闭包捕获了`greeting`变量的值，并在之后打印出问候语。即使`main`函数的作用域已经结束，闭包仍然可以访问`greeting`变量的值。 通过理解和使用Dart中的方法对象，您可以编写更加灵活和模块化的代码，实现更高级的功能，如回调函数、高阶函数和闭包等。

匿名方法

说明： 1、匿名方法，lambda表达式

在 Dart 中，`=>` 符号表示箭头函数或箭头语法。它通常用于定义简单的匿名函数或表达式函数。箭头函数通常用于简化代码并提高可读性。例如，以下是一个使用箭头函数的简单示例： ```dart void main() {   List<int> numbers = [1, 2, 3, 4, 5];      // 使用箭头函数计算每个数字的平方并将结果打印出来   numbers.forEach((number) => print(number * number)); } ``` 在上面的示例中，`=>` 用于定义一个匿名函数，该函数接受一个参数 `number`，然后返回 `number * number` 的结果。箭头函数简化了代码，使其更加简洁和易读。

分类

实例方法

静态方法

工厂方法

构造方法

参数列表：构造方法的初始化参数列表，c++中有类似的参数列表

实例： 在 Dart 中，`: super.fromJson(json)` 这种写法是构造函数的初始化列表，它用于调用父类的构造函数。在这种情况下，它调用的是父类的 `fromJson` 构造函数。 以下是关于这种写法的详细解释： ### 构造函数的初始化列表 初始化列表允许你在构造函数体执行之前初始化实例变量。对于子类来说，初始化列表可以用来调用父类的构造函数，以确保父类的部分在子类构造函数体执行之前已经初始化完毕。 ### 示例代码解释 假设你有一个 `LoadReceiptList` 类，它有一个 `fromJson` 构造函数。然后你定义了一个子类 `RouteReceipt`，并且希望它也有一个 `fromJson` 构造函数，在该构造函数中调用父类的 `fromJson` 构造函数来初始化父类的部分属性。 ```dart class LoadReceiptList {   String? receiptImgUrl;   String? receiptType;   String? waybillReceiptId;   LoadReceiptList({this.receiptImgUrl, this.receiptType, this.waybillReceiptId});   LoadReceiptList.fromJson(Map<String, dynamic> json) {     receiptImgUrl = json['receiptImgUrl'];     receiptType = json['receiptType'];     waybillReceiptId = json['waybillReceiptId'];   }   Map<String, dynamic> toJson() {     final Map<String, dynamic> data = {};     data['receiptImgUrl'] = receiptImgUrl;     data['receiptType'] = receiptType;     data['waybillReceiptId'] = waybillReceiptId;     return data;   } } class RouteReceipt extends LoadReceiptList {   String? routeNodeId;   RouteReceipt({String? receiptImgUrl, String? receiptType, String? waybillReceiptId, this.routeNodeId})       : super(receiptImgUrl: receiptImgUrl, receiptType: receiptType, waybillReceiptId: waybillReceiptId);   @override   RouteReceipt.fromJson(Map<String, dynamic> json) : super.fromJson(json) {     routeNodeId = json['routeNodeId'];     // 父类的属性已经由 super.fromJson(json) 初始化过了   }   @override   Map<String, dynamic> toJson() {     final Map<String, dynamic> data = super.toJson();     data['routeNodeId'] = routeNodeId;     return data;   } } void main() {   // 示例 JSON 数据   Map<String, dynamic> json = {     'receiptImgUrl': 'http://example.com/image.jpg',     'receiptType': 'Type A',     'waybillReceiptId': '12345',     'routeNodeId': '67890'   };   // 使用 fromJson 创建 RouteReceipt 实例   RouteReceipt routeReceipt = RouteReceipt.fromJson(json);   // 打印结果以验证   print(routeReceipt.toJson()); } ``` ### 代码说明 - **`LoadReceiptList` 类**：有一个普通构造函数和一个 `fromJson` 构造函数，后者通过传入的 JSON 数据来初始化类的属性。 - **`RouteReceipt` 类**：继承自 `LoadReceiptList`，并增加了一个新的属性 `routeNodeId`。 - **`RouteReceipt.fromJson` 构造函数**：   - `: super.fromJson(json)` 调用了父类的 `fromJson` 构造函数，这样父类的属性 `receiptImgUrl`、`receiptType` 和 `waybillReceiptId` 会根据传入的 JSON 数据进行初始化。   - 子类特有的属性 `routeNodeId` 在构造函数体内被初始化。 通过这种方式，可以确保父类的部分在子类构造函数体执行之前已经初始化完毕，符合 Dart 构造函数的执行顺序。

实战

重写父类的静态方法

class LoadReceiptList {   String? receiptImgUrl;   String? receiptType;   String? waybillReceiptId;   LoadReceiptList(       {this.receiptImgUrl, this.receiptType, this.waybillReceiptId});   LoadReceiptList.fromJson(Map<String, dynamic> json) {     receiptImgUrl = json['receiptImgUrl'];     receiptType = json['receiptType'];     waybillReceiptId = json['waybillReceiptId'];   }   Map<String, dynamic> toJson() {     final Map<String, dynamic> data = {};     data['receiptImgUrl'] = receiptImgUrl;     data['receiptType'] = receiptType;     data['waybillReceiptId'] = waybillReceiptId;     return data;   } } class MidwayReceiptList extends LoadReceiptList {   num? routeNodeId;     MidwayReceiptList(       {this.routeNodeId, super.receiptImgUrl, super.receiptType, super.waybillReceiptId});     @override   MidwayReceiptList.fromJson(Map<String, dynamic> json) : super.fromJson(json) {     routeNodeId = json['routeNodeId'];   }   @override   Map<String, dynamic> toJson() {     final Map<String, dynamic> data = super.toJson();     data['routeNodeId'] = routeNodeId;     return data;   }   }

异常

说明： （1）介绍catch的参数； 1、dart中和java中的异常抛出不一样；如下： void  test(){    throw new  Exception("你好"); } void main(){   try{    test();    }catch(e){} } dart中虽然不强制你去捕获异常，但是类似java中try..catch异常也是可以的；如上面的代码； 2、java中针对不用的异常，就捕获不同的异常；但是在dart中是不可以的； 3、catch(e)中不仅可以接受一个参数e，其实可以同时接受好两个参数（最多两个参数），catch(e，s)这样； e:就是抛出的异常对象； s:就是调用栈信息，StackTrace （2）根据不同的异常类型，进行不同的处理； 语法on  TYPE  catch.... try{      test(); }on Exception catch(e,s){ }on intcatch(e){ }on Stringcatch(e){ }

在Dart中，`try-catch`语句用于捕获和处理异常。当代码执行过程中发生错误或异常时，可以使用`try-catch`来捕获这些异常，并在`catch`块中执行相应的错误处理逻辑。  try on on catch finally `try-catch`语句的基本结构如下： ```dart try {   // 尝试执行的代码，可能会抛出异常 } on ExceptionType1 {   // 处理特定类型的异常 } on ExceptionType2 {   // 处理另一种类型的异常 } catch (error, stackTrace) {   // 处理所有未被上述on块捕获的异常 } finally {   // 无论是否发生异常，都会执行的代码 } ``` 这里有几个关键点需要注意： - `try` 块包含可能抛出异常的代码。 - `on` 块（可选）用于捕获特定类型的异常。可以有多个`on`块，每个块处理不同类型的异常。 - `catch` 块（可选）用于捕获所有未被`on`块捕获的异常。`catch`块接收两个参数：`error`（异常对象）和`stackTrace`（堆栈跟踪信息，可选）。 - `finally` 块（可选）包含无论是否发生异常都会执行的代码。 ### 示例 下面是一个使用`try-catch`处理异常的简单示例： ```dart void main() {   try {     // 尝试执行可能会抛出异常的代码     int result = 10 / 0; // 这将抛出ArithmeticException   } on ArithmeticException {     // 处理ArithmeticException类型的异常     print('发生除以零的异常');   } on FormatException {     // 处理FormatException类型的异常     print('发生格式异常');   } catch (error, stackTrace) {     // 处理所有其他类型的异常     print('捕获到异常: $error');     if (stackTrace != null) {       print('堆栈跟踪: $stackTrace');     }   } finally {     // 无论是否发生异常，都会执行的代码     print('这是finally块中的代码');   } } ``` 在这个例子中，我们尝试执行一个除以零的操作，这将导致`ArithmeticException`异常。我们使用`on ArithmeticException`块来捕获这种特定类型的异常，并输出相应的消息。 如果`try`块中的代码抛出其他类型的异常（如`FormatException`），则相应的`on`块会捕获它。如果`try`块中的代码没有抛出任何被`on`块捕获的异常，那么`catch`块会捕获所有其他类型的异常。 最后，`finally`块中的代码无论是否发生异常都会执行。 ### 注意事项 - 如果没有`on`块和`catch`块，`try`块中的异常将不会被捕获，并且程序会终止执行。 - `on`块和`catch`块是可选的，但至少需要其中一个来捕获异常。 - `on`块和`catch`块按照它们在代码中的顺序进行匹配，一旦找到匹配的异常类型，就不会再检查后续的`on`块或`catch`块。 - 如果不需要处理特定类型的异常，可以只使用`catch`块来捕获所有类型的异常。 通过合理地使用`try-catch`语句，您可以提高Dart程序的健壮性，确保在发生异常时能够优雅地处理错误情况。

类

私有：私有属性、私有方法均使用头部下划线命名来声明

在Dart中，并没有直接声明私有类的方式，因为Dart中的类默认就是公共的，可以被任何其他Dart代码访问。然而，你可以通过命名约定来模拟私有属性和方法的行为。 以下是如何在Dart中声明私有属性、私有方法和私有静态方法的示例： ### 私有属性 私有属性通常使用单个下划线`_`作为前缀。 ```dart class MyClass {   // 私有属性   String _privateProperty = 'This is private';   // 公共方法用于访问私有属性   String getPrivateProperty() {     return _privateProperty;   }   // 公共方法用于设置私有属性   void setPrivateProperty(String value) {     _privateProperty = value;   } } ``` ### 私有方法 私有方法也使用单个下划线`_`作为前缀。 ```dart class MyClass {   // 私有方法   void _privateMethod() {     print('This is a private method');   }   // 公共方法调用私有方法   void callPrivateMethod() {     _privateMethod();   } } ``` ### 私有静态方法 Dart中并没有直接的方式来声明一个私有静态方法。但你可以通过结合私有方法和静态方法的方式来实现类似的功能。私有静态方法通常用于工具函数或者仅在类内部使用的辅助方法。 ```dart class MyClass {   // 私有静态方法   static void _privateStaticMethod() {     print('This is a private static method');   }   // 公共静态方法调用私有静态方法   static void callPrivateStaticMethod() {     _privateStaticMethod();   } } ``` 需要注意的是，Dart的私有性是通过命名约定来实现的，而不是通过语言特性强制执行的。这意味着，尽管Dart建议并鼓励使用下划线前缀来表示私有成员，但实际上你仍然可以从类的外部访问这些成员。Dart编译器会发出警告，但不会阻止你这样做。因此，遵守这个命名约定主要是为了保持代码的可读性和维护性，而不是为了提供安全性或强制封装。 如果你确实需要更严格的访问控制，你可能需要重新考虑你的设计，或者使用其他语言特性（如封装在另一个类中）来模拟更严格的私有性。但在大多数情况下，Dart的命名约定已经足够满足大多数应用的需求。

类说明： 1、私有的类和属性，在dart语言中，表示方式； //包括类的定义  如果使用 _ 开头，意味着这个类就是private class  Point{    int _x;//使用_开始命名的变量，就是java的private，在外面不可以调用    int y; }

在Dart中，你可以通过不使用任何特定的关键字来声明私有属性。Dart遵循一种命名约定，即使用下划线`_`开头的标识符被认为是私有的。这种约定在Dart中被广泛接受并作为私有成员的默认实现方式。 例如，下面是如何声明一个私有属性的例子： ```dart class MyClass {   // 这是一个私有属性   String _privateProperty;   // 这是一个公共方法，可以访问和修改私有属性   void setPrivateProperty(String value) {     _privateProperty = value;   }   // 这是另一个公共方法，可以返回私有属性的值   String getPrivateProperty() {     return _privateProperty;   } } void main() {   var obj = MyClass();   // 设置私有属性的值   obj.setPrivateProperty('Hello');   // 获取私有属性的值   print(obj.getPrivateProperty()); // 输出: Hello   // 直接访问私有属性会导致编译错误   // print(obj._privateProperty); // 错误: 私有成员无法直接访问 } ``` 在这个例子中，`_privateProperty`是一个私有属性，它只能被`MyClass`类内部的方法访问。尽管Dart没有提供语言级别的访问控制修饰符（如Java中的`private`关键字），但使用下划线前缀的命名约定被广泛接受，并且Dart的编译器和工具链都遵循这一约定。 需要注意的是，这种约定并不是强制性的，只是Dart社区的一个共识。如果你尝试从类的外部访问一个以下划线开头的属性或方法，Dart编译器会发出警告，但并不会阻止你这样做。然而，这通常被认为是不好的做法，因为它违反了类的封装原则。 此外，Dart还提供了一种名为库私有（library-private）的特性，通过在标识符前使用`_`前缀，并紧跟库名，可以声明只有当前库内部可以访问的属性和方法。例如： ```dart // 在同一个Dart文件中 String _libraryPrivateProperty; // 在另一个Dart文件中，即使属于同一个库，也无法访问 // print(_libraryPrivateProperty); // 错误: 无法访问库私有成员 ``` 这种库私有特性提供了更细粒度的访问控制，但通常只在大型库或框架中需要更复杂的封装时使用。对于大多数应用和小型库，使用单个下划线前缀的命名约定就足够了。

构造函数

构造函数语法糖Point(this._x,this.y)

说明： class  Point{    int _x;    int y;    Point(this._x,this.y);//构造函数 } Point(this._x,this.y); 此构造方法相对于java中来说，比之前要简单的多； dart语言中是不能进行方法重载的，但是我们是有定义多个方法的需求；

命名构造函数

说明： 1、dart语言中是不能进行方法重载的，但是我们是有定义多个方法的需求； 命名构造方法（可以根据名字就可以直接看出来这个构造方法是干嘛用的，这也是为什么有了命名构造方法， 还可以有可选参数构造方法的原因）： Point.Y(this.y);//加this Point._X(this._X); 调用方式：var  point = new Ponit.X(1); 2、构造方法的可选参数 Point(int x,int y){}//不用加this了

参数初始化列表

说明：类似c++的参数初始化列表 参数初始化列表(初始化类中的属性，可以不写方法体): Point.XY():_x=1,y=2; Point.fromMap(Map map):_x = map['x'],y=map['y'];

重定向构造函数

说明： 重定向构造函数 class View{    View(int content,int  attr);    //重定向构造函数    View.a(int   context):this(context,0); } 可用来作重载使用

常量构造函数

说明： class ImmutabelPoint{    final int x;    final int y;    //常量构造方法    const  ImmutabelPoint(this.x,this.y); } 使用new来创建常量构造方法的对象，就和普通的对象没有区别； 但是使用const来创建多个对象，传递的参数一样，表示这几个对象是同一个编译器常量对象（必须定义常量构造函数） void   main(){    var  p1 = const ImmutabelPoint(1,1);    var  p1 = const ImmutabelPoint(1,1);    print(p1.hashCode == p2.hashCode);//true    print(p1 == p2);//true }

工厂构造函数

说明： 在命名构造函数前面其实加一个factory就是工厂构造函数； 在工厂的构造方法中，不可以使用this class MyObject {   String name;   // 普通构造函数   MyObject(this.name);   // 工厂构造函数   factory MyObject.createInstance(String name) {     // 在这里可以进行一些逻辑处理     return MyObject(name);   } } void main() {   // 使用工厂构造函数创建对象   var obj = MyObject.createInstance("Example");   print(obj.name); // 输出：Example } 类似类方法

Getter与Setter

说明： 每一个实例属性，变量都会有一个隐式的get，非final 还有set方法；

操作符重载

说明： 操作符重载：把已经定义的、有一定功能的操作符进行重新定义； 例如： <、+、|、[]、>、/、^、[]=、<=、~/、&、~、>=、*、<<、==、-、%、>> 在 Dart 语言中，操作符重载是通过特定的方法来实现的，而不像某些其他语言那样提供了直接的操作符重载语法。Dart 使用约定来定义这些方法。以下是一些 Dart 中的常见操作符及其对应的方法： []：索引运算符，对应方法：operator [](index)  []=：索引赋值运算符，对应方法：operator []=(index, value) +：加法运算符对应方法：operator +(other) -：减法运算符，对应方法：operator -(other) *：乘法运算符，对应方法：operator *(other) /：除法运算符，对应方法：operator /(other) ==：相等运算符，对应方法：operator ==(other) 要重载这些操作符，你只需在你的类中实现相应的方法。例如： dart Copy code class Complex {   double real;   double imaginary;   Complex(this.real, this.imaginary);   // 加法运算符重载   Complex operator +(Complex other) {     return Complex(real + other.real, imaginary + other.imaginary);   }   // 相等运算符重载   bool operator ==(Object other) {     if (identical(this, other)) return true;     return other is Complex && real == other.real && imaginary == other.imaginary;   } } void main() {   Complex c1 = Complex(1.0, 2.0);   Complex c2 = Complex(2.0, 3.0);   // 使用重载的加法运算符   Complex sum = c1 + c2;   print("Sum: ${sum.real} + ${sum.imaginary}i");   // 使用重载的相等运算符   print("Are they equal? ${c1 == c2}"); }

类、抽象类与接口

说明： 1、abstract 使用abstract修饰符定义一个抽象类，抽象类中允许出现无方法的方法与java没有什么区别，不可以多继承，可以多实现； 在 Dart 中，抽象类（Abstract Class）是一种不能被实例化的类，通常用于定义一组方法的接口，其中的方法可以是抽象的（没有具体实现），也可以包含具体的方法。抽象类可以被其他类继承或实现，从而实现其中定义的抽象方法。 以下是一个简单的 Dart 抽象类的示例： dart Copy code // 定义一个抽象类 abstract class Animal {   // 抽象方法，没有具体实现   void makeSound();   // 具体方法   void sleep() {     print("Animal is sleeping.");   } } // 可以被继承，继承抽象类并实现抽象方法 class Dog extends Animal {   @override   void makeSound() {     print("Dog barks!");   } } // 可以被实现，实现抽象类并实现抽象方法 class Cat implements Animal {   @override   void makeSound() {     print("Cat meows!");   } } void main() {   var dog = Dog();   dog.makeSound(); // 调用抽象类中的抽象方法   dog.sleep();     // 调用抽象类中的具体方法   var cat = Cat();   cat.makeSound(); // 调用抽象类中的抽象方法   cat.sleep();     // 调用抽象类中的具体方法 } 2、接口（类） 与java不同，Dart中没有interface关键字，Dart中每个类（也包含虚拟类）都隐式的定义了一个包含所有势力成员的接口， 并且这个类实现了这个接口。如果你想创建类M来支持类N的方法，而不想继承N的实现，则类M应该实现N的接口； 每一类都可以看作为一个接口，Dart语言中没有分的太清楚。 Dart 支持一个类实现多个接口。一个类可以使用 implements 关键字来实现多个接口。这样，该类就需要提供每个接口中定义的方法。 以下是一个简单的例子，演示了一个类如何实现多个接口： // 定义两个接口 abstract class Printable {   void printInfo(); } abstract class Loggable {   void logInfo(); } // 实现多个接口的类 class Logger implements Printable, Loggable {   @override   void printInfo() {     print("Printing information...");   }   @override   void logInfo() {     print("Logging information...");   } } void main() {   var logger = Logger();   logger.printInfo(); // 调用 Printable 接口的方法   logger.logInfo();   // 调用 Loggable 接口的方法 } 在这个例子中，Logger 类同时实现了 Printable 和 Loggable 两个接口。这允许它使用两个接口中定义的方法。实现多个接口的这种能力使得 Dart 类具有更大的灵活性，可以适应不同的需求和设计模式。

问题

抽象类中的方法必须被重写吗

抽象方法必须在非抽象子类中被重写，但非抽象方法则不是必需的。】

在Dart中，抽象类（abstract class）允许你定义一个类的结构，但不完全实现它。抽象类可以包含抽象方法（由`abstract`关键字标记的方法），这些方法在抽象类中没有实现，必须在任何继承该抽象类的非抽象子类中实现。 对于抽象类中的方法，以下是一些关键点： 1. **抽象方法**：在抽象类中定义的方法，如果标记为`abstract`，则不需要（也不可以）在抽象类本身中提供方法体。这样的方法必须在任何非抽象子类中实现。 2. **非抽象方法**：抽象类也可以包含非抽象方法，这些方法在抽象类中有具体的实现。子类可以选择重写这些方法，也可以继承它们的默认实现。 3. **子类必须实现所有抽象方法**：任何继承抽象类的非抽象子类都必须实现抽象类中定义的所有抽象方法。如果子类没有实现所有抽象方法，那么它本身也必须被标记为`abstract`。 所以，对于你的问题，“抽象类中的方法必须被重写吗？”答案是：抽象方法必须在非抽象子类中被重写，但非抽象方法则不是必需的。 以下是一个简单的例子： ```dart abstract class Animal {   // 抽象方法，必须在子类中实现   abstract void makeSound();   // 非抽象方法，子类可以选择重写或者继承默认实现   void eat() {     print('The animal eats.');   } } class Dog extends Animal {   // 必须实现从Animal继承来的抽象方法makeSound   @override   void makeSound() {     print('The dog barks.');   }   // 可以选择重写eat方法，也可以继承默认实现   @override   void eat() {     print('The dog eats dog food.');   } } void main() {   Dog dog = Dog();   dog.makeSound(); // 输出: The dog barks.   dog.eat();       // 输出: The dog eats dog food. } ``` 在这个例子中，`Animal`是一个抽象类，它有一个抽象方法`makeSound`和一个非抽象方法`eat`。`Dog`类继承了`Animal`类，并且实现了`makeSound`方法。同时，它也重写了`eat`方法，但如果不重写，它将继承`Animal`类中`eat`方法的默认实现。

简构

抽象父类

非抽象方法

不需要全部实现

抽象方法

抽象子类

不需要全部实现

非抽象子类

需要全部实现

简述

非抽象方法，切在具体子类的中才需要全部实现

继承（extends）和实现（implements）

不可多继承，可单继承类或虚拟类；可以多实现类或虚拟类。

 mixins（混入类）（with）

说明： Mixins是一种在多类继承中重用一个类代码的方法；而且被Mixins侵入的类 不能有构造函数。 此功能就是相对于弥补java不能多继承的问题； class A{   void a(){} } class B{   void b(){} } class C with A,B{   void c(){      a();      b();   } } 还有一种写法： class C = Object with A,B;//C类就是AB的混合类； 可以在C类中调用AB类中的方法，满足了我们的多继承的需求，但是不能重写； 使用混入的话可以弥补我们没有多继承的缺陷；

例子：混入类属性、方法以及静态属性和方法的使用

//总结：混入类的非静态属性和方法直接使用，静态属性和方法需要加上融合类名称 void main() {   var o = c();   o.cm();   o.printP();   c.scm(); } mixin a {   final String fap = 'fap';   static var sap = 'sap';   void am() {     print('am');   }   static void sam() {     print('sam');   } } mixin b {   final String fbp = 'fbp';   static var sbp = 'sbp';   void bm() {     print('am');   }   static void sbm() {     print('sbm');   } } class c with a, b {   final String fcp = 'fcp';   static var scp = 'sbp';   void cm() {     am();     bm();     print('cm');   }   static void scm() {     a.sam();     b.sbm();     print('scm');   }   void printP() {     print(fap + ' ' + fbp + ' ' + fcp);     print(a.sap + ' ' + b.sbp + ' ' + c.scp);   } } /* 输出 am am cm fap fbp fcp sap sbp sbp sam sbm scm*/

扩展（extension）

extension HttpManagerExtension on HttpManager {}

扩展是什么？如何使用

在Dart中，扩展（Extension）是使用静态方法扩展现有类的一种语法糖。和oc中类比一样。它允许开发者在不修改类本身的情况下为类添加新的方法和功能。通过使用扩展，我们可以为Dart内置类、自定义类甚至第三方库的类添加方法，以满足特定的需求。 扩展的定义格式如下： ```dart extension ExtensionName on ClassName {   // 添加方法和功能 } ``` 其中，`ExtensionName`是我们自定义的扩展名称，`ClassName`是要扩展的类名。通过在扩展内部定义方法和功能，我们可以像调用类的实例方法一样使用它们。 例如，假设我们有一个字符串，并希望将其转换为整数。虽然字符串类本身并没有提供这样的方法，但我们可以使用扩展为其添加一个`toInt`方法： ```dart extension StringExtension on String {   int toInt() {     return int.parse(this);   } } void main() {   int number = '123'.toInt();   print(number); // 输出: 123 } ``` 在上面的例子中，我们为`String`类添加了一个`toInt`扩展方法。在`main`函数中，我们可以直接调用字符串实例的`toInt`方法，将字符串转换为整数。 除了定义方法，扩展还可以定义getter、setter和operator等。虽然扩展方法中不能使用`dynamic`类型，但支持更强大的泛型扩展。这使得代码结构更为简洁，链式调用更加流畅。 使用扩展的好处是它们不会修改原始类，因此不会引入额外的继承层次或破坏类的封装性。同时，扩展方法的实现非常简单，它们是通过静态方法来实现的，与调用静态函数一样快速。 总的来说，Dart中的扩展是一种强大的代码复用和增强工具，允许开发者以灵活的方式为现有类添加新的功能，而无需修改这些类的源代码。

延展

子类是否可以访问父类的扩展，以及父类的父类的扩展呢？扩展可以继承吗？

答：均可以。 示例代码 // 定义扩展 extension MyExtension on ParentClass {   void extendedMethod() {     print('This is an extended method.');   }   String get extendedProperty => 'This is an extended property.'; } // 定义扩展 extension MyParentParentExtension on ParentParentClass {   void extendedMethodParentParent() {     print('This is an extended method Parent Parent.');   }   String get extendedPropertyParentParent => 'This is an extended property Parent Parent.'; } // 父类的父类 class ParentParentClass {   void parentparentMethod() {     print('This is a parent method.');   }     void useparentparentExtension() {     // 调用扩展方法     this.extendedMethodParentParent();     // 访问扩展属性     print(this.extendedPropertyParentParent);   }   } // 父类 class ParentClass extends ParentParentClass {   void parentMethod() {     print('This is a parent method.');   } } // 子类 class ChildClass extends ParentClass {   void childMethod() {     print('This is a child method.');   }   void useExtension() {     // 调用扩展方法     this.extendedMethod();     // 访问扩展属性     print(this.extendedProperty);   }   } void main() {   var child = ChildClass();   // 调用子类方法   child.childMethod();   // 调用父类方法   child.parentMethod();   /// 父类的扩展属性和方法   // 调用父类的扩展方法和属性   child.useExtension();   // 间接直接调用父类的扩展方法和属性   child.extendedMethod();     /// 父类的父类的扩展属性和方法   // 间接使用父类的父类的扩展属性和扩展方法   child.useparentparentExtension();   // 直接调用父类的父类的扩展方法和属性   child.extendedMethodParentParent(); } //  执行的结果 //  This is a child method. //  This is a parent method. //  This is an extended method. //  This is an extended property. //  This is an extended method. //  This is an extended method Parent Parent. //  This is an extended property Parent Parent. //  This is an extended method Parent Parent.

可调用的对象

说明： 实现call()方法，就允许像调用函数一样调用Dart类的实例。 例子： class WannabeFunction {   String call(String a, String b, String c) => '$a $b $c!'; } void main() {   var wf = WannabeFunction();   var outByCall = wf.call('Hi', 'there,', 'gang');   var out = wf('Hi', 'there,', 'gang'); // 和上边调用call方法效果一样，称之为可调用的对象   print(outByCall);   print(out); } 调用(只有call方法的时候才能这样调用) wf(,,);就相当于调用了call(,,)方法；也可以直接调用test.call();

如何实现多继承

方法

继承❌：extend a 继承类，单继承

实现✅：implement a,b实现接口（类），此处注意dart中类就是接口

混入✅：with a,b混入类

组合✅

详解

类和抽象类都不可以多继承 可以通过实现多个协议或者mixin的方式实现多继承 在 Dart 中，尽管直接的多继承是不允许的，但可以通过一些其他方式来实现类似的效果，以达到多继承的目的。以下是一些常见的模式和技巧： 使用 Mixin： Mixin 是 Dart 中一种特殊的类，它提供了一种在多个类之间共享功能的方式。通过 with 关键字，可以将 Mixin 类的功能混入到其他类中。 mixin A {   void methodA() {     print("Method A");   } } mixin B {   void methodB() {     print("Method B");   } } class C with A, B {   void methodC() {     print("Method C");   } } void main() {   var obj = C();   obj.methodA(); // 调用 Mixin A 的方法   obj.methodB(); // 调用 Mixin B 的方法   obj.methodC(); // 调用类 C 的方法 } 使用接口（Interface）： 类可以实现多个接口，这样可以达到一种形式的多继承。一个类可以同时继承一个父类并实现多个接口。 dart Copy code class A {   void methodA() {     print("Method A");   } } class B {   void methodB() {     print("Method B");   } } abstract class C {   void methodC(); } class D extends A implements C {   @override   void methodC() {     print("Method C");   } } void main() {   var obj = D();   obj.methodA(); // 调用父类 A 的方法   obj.methodC(); // 调用接口 C 的方法 } 这两种方式都能够在 Dart 中实现一定程度的多继承，但需要根据具体的需求和设计选择合适的方法。 Mixin 提供了更灵活和可复用的方式，而接口则更强调契约和规范。

问题

class c with a,b {} 中 a、b可以使用mixin修饰，也可以使用class修饰吗？如果可以两者有什么区别？

在Dart中，`mixin`和`class`有不同的用途和语义，它们不可以随意互换使用。`with`关键字后面应该跟随一个或多个使用`mixin`修饰的类或另一个`mixin`。 `mixin`是一种特殊的类，用于在多个类层次结构中复用代码。使用`mixin`时，你是在创建一个可以与其他类混合使用的代码块，这个代码块可以包含方法、getter、setter等，但不包含状态（即字段）。`mixin`不能单独实例化，它们必须被混入到其他类中才能使用。 `class`则是定义对象的基础结构，包含了对象的状态和行为。类可以实例化，并且可以继承其他类或实现接口。 对于你的示例`class C with A, B {}`，这里`A`和`B`都应该是使用`mixin`修饰的类或另一个`mixin`，而不是使用`class`修饰。因为`with`关键字是用于将`mixin`的功能混入到类中，而不是用于将普通类混合使用。 如果`A`和`B`是用`class`修饰的，那么它们不能被直接用于`with`关键字后面进行混入。在Dart 3.0.0之前，没有构造方法的类可以视为`mixin`，但从Dart 3.0.0开始，`mixin`需要显式地使用`mixin`关键字来声明，以便区分它与常规类。 两者的主要区别在于： * `mixin`用于代码复用，并且不包含状态（字段）。它们不能单独实例化，必须被混入到其他类中。 * `class`用于定义对象的结构和行为，可以包含状态，并且可以实例化。它们可以继承其他类或实现接口。 所以，对于`class C with A, B {}`，`A`和`B`必须是使用`mixin`修饰的类或另一个`mixin`，而不是使用`class`修饰的类。

异步编程

异步编程（async、Future、await和）

异步编程则是在单线程中更高效地处理并发任务的方式。使用 async 和 await 关键字，以及 Future 类，可以编写异步的代码，从而更有效地利用单线程的执行能力。

Future是什么

是什么：Future表示异步操作的结果，可以有两种状态:未完成或已完成。

在异步编程中随处可见，代表了事件结果

对异步编程的异常捕获

用法

Future Api

单Future

then

catchError

whenCompelete

then或catchError任意执行后执行

timeout

代码示例： 你可以将 then、catchError、whenComplete 和 timeout 结合使用，以在 Future 完成或超时时执行相应的逻辑。以下是一个例子： import 'dart:async'; void main() {   final myFuture = asyncFunction(); // 替换为你的异步操作函数   myFuture       .timeout(Duration(seconds: 5), onTimeout: () {         print('The operation timed out');         // 在超时时执行的逻辑，例如返回一个默认值或抛出特定异常         //throw TimeoutException('Operation took too long');         return 'timeout';       })       .then((result) {         print('Operation completed successfully: $result');       })       .catchError((error) {         print('Error occurred: $error');       })       .whenComplete(() {         print('Operation completed, whether successful or with error');       }); } Future<String> asyncFunction() async {   // 模拟一个较长时间的异步操作   await Future.delayed(Duration(seconds: 10));   return 'Hello, World!'; } timeout中未抛出异常的执行结果： The operation timed out Operation completed successfully: timeout Operation completed, whether successful or with error 抛出异常的执行结果： The operation timed out Error occurred: TimeoutException: Operation took too long Operation completed, whether successful or with error 在上面的例子中，myFuture 使用了 timeout 方法来设置一个5秒的超时时间。如果 myFuture 在5秒内未完成，将触发 onTimeout 回调，并抛出 TimeoutException 异常。接着，通过 then 处理成功完成的情况，通过 catchError 处理发生异常的情况，最后使用 whenComplete 处理无论成功还是发生异常时都需要执行的逻辑。 需要注意的是，then、catchError、whenComplete 都会返回一个新的 Future，因此可以链式调用它们。这种结构允许你以清晰的方式组合和处理异步操作的结果、错误和完成情况。

使用方法

多个Future

串行（串联操作）

串联多个Future.then.then

示例代码： Future result = costlyQuery(url); result     .then((value) => expensiveWork(value))     .then((_) => lengthyComputation())     .then((_) => print('Done!'))     .catchError((exception) {   /* Handle exception... */ });

按一定顺序分别await

示例代码： try {   final value = await costlyQuery(url);   await expensiveWork(value);   await lengthyComputation();   print('Done!'); } catch (e) {   /* Handle exception... */ }

✅注意一种不正确的情况【错误❌，abc异步】Future.wait([a,b,c]) 

a、b、c 不按顺序执行，Future.wait([a, b, c]) 不会保证 a、b 和 c 的执行顺序。

并发（平行操作）（parallel operations）

Future.wait([]) 和 await [].wait 一样，后者是前者的语法糖，编译后代码完全一致

await [].wait

❌可以分别处理每个Future的异常，允许多个Future抛出异常

Wait for each future in a list, returns a list of futures: 示例代码 基本结构 try{ await [].wait  } on ParallelWaitError<List<bool?>, List<AsyncError?>> catch(e){ } 详细代码： void main() async {   Future<void> delete() async =>  ...   Future<void> copy() async =>  ...   Future<void> errorResult() async =>  ...      try {     // Wait for each future in a list, returns a list of futures:     var results = await [delete(), copy(), errorResult()].wait;     } on ParallelWaitError<List<bool?>, List<AsyncError?>> catch (e) {     print(e.values[0]);    // Prints successful future     print(e.values[1]);    // Prints successful future     print(e.values[2]);    // Prints null when the result is an error     print(e.errors[0]);    // Prints null when the result is successful     print(e.errors[1]);    // Prints null when the result is successful     print(e.errors[2]);    // Prints error   }

场景举例：资源上传的，有两个步骤一个获取令牌，第二个步根据令牌信息上传文件

返回不同类型的future示例： import 'dart:async'; void main() async {   Future<int> delete() async {     print("delete int");     return 1;   }   Future<String> copy() async {     print("copy string");     return "string from copy";   }   Future<bool> errorResult() async {     print("errorResult bool"); //     throw Exception('errorResult function throw an exception.');     return false;   }   (int, String, bool) result = (-1, "default", false);   try {     // Wait for each future in a record, returns a record of futures:     result = await [delete(), copy(), errorResult()].wait;   } on ParallelWaitError<(int?, String?, bool?),       (AsyncError?, AsyncError?, AsyncError?)> catch (e) {     print(e.values);   }   // Do something with the results:   var deleteInt = result.$1;   var copyString = result.$2;   var errorBool = result.$3;   print("deleteInt = $deleteInt, copyString = $copyString, errorBool = $errorBool."); } 返回结果： delete int copy string errorResult bool deleteInt = 1, copyString = string from copy, errorBool = false. 抛出异常返回结果： delete int copy string errorResult bool (1, string from copy, null) deleteInt = -1, copyString = default, errorBool = false.

Future.wait()

只能处理最先抛出的异常

等待多个异步结果进行后续操作：wait方法 Future<void> deleteLotsOfFiles() async =>  ... Future<void> copyLotsOfFiles() async =>  ... Future<void> checksumLotsOfOtherFiles() async =>  ... await Future.wait([   deleteLotsOfFiles(),   copyLotsOfFiles(),   checksumLotsOfOtherFiles(), ]); print('Done with all the long steps!');

Future.wait() returns a future which completes once all the provided futures have completed. It completes either with their results, or with an error if any of the provided futures fail. 只返回一个error，最先抛出的error，可以返回多个不同类型的Future 代码片段： Future.wait([]).then((List<dynamic>results){}).catchError((error){}).whenCompelete((){}) 当你使用 Future.wait 时，可以使用 catchError 捕获任何其中一个异步操作抛出的异常。此外，你还可以在所有异步操作都完成时执行一些逻辑，可以在 then 或 whenComplete 中处理。以下是一个例子： void main() {   Future.wait([     asyncFunction1(),     asyncFunction2(), //     asyncFunctionWithError(),   ]).then((List<dynamic> results) {     // 所有异步操作完成时执行的逻辑     print('All operations completed successfully with results: $results');   }).catchError((error) {     // 捕获异步操作中的任何一个抛出的异常     print('Error occurred: $error');   }).whenComplete(() {     // 无论成功还是失败，都会执行的逻辑     print('All operations completed (whether successful or with error)');   }); } Future<int> asyncFunction1() async {   await Future.delayed(const Duration(seconds: 2));   print('Async function 1 completed');   return 1; } Future<String> asyncFunction2() async {   await Future.delayed(const Duration(seconds: 3));   print('Async function 2 completed'); //   throw Exception('An error occurred 2'); //   print('Async function with error completed 2');   return 'Hello, World!'; } Future<void> asyncFunctionWithError() async {   await Future.delayed(const Duration(seconds: 1));   print('Async function with error completed asyncFunctionWithError');   throw Exception('An error occurred'); } 抛出异常的执行结果： Async function with error completed asyncFunctionWithError Async function 1 completed Async function 2 completed Error occurred: Exception: An error occurred All operations completed (whether successful or with error) 未抛出异常的执行结果： Async function 1 completed Async function 2 completed All operations completed successfully with results: [1, Hello, World!] All operations completed (whether successful or with error) 在上面的例子中，Future.wait 用于等待三个异步操作完成。then 和 catchError 互斥 then 用于处理所有异步操作都完成并执行成功（无异常抛出）的情况下才会执行。 catchError 用于捕获所有异步执行完成后，最先执行完的异步操作抛出的异常， whenComplete 用于所有异步操作均执行完，无论异步操作成功还是失败都会执行的逻辑。

如果需要捕获所有异常而不仅仅是第一个抛出的异常，可以使用 Future.wait() 的 eagerError 参数设置为 false：

不常用，仅了解即可。Future.forEach：

串行和并行的区别

如果你希望多个异步操作按顺序执行，即等待一个完成后再执行下一个，使用 await。 如果你希望同时开始执行多个异步操作，然后在所有操作完成后进行处理，使用 Future.wait() 或者Array<Future>.wait。 通常情况下，选择取决于你的需求和性能优化。使用 await 可以更直观地表达代码的执行顺序，而 Future.wait() 可以在同时处理多个异步操作时提供更好的性能。

Future 四个静态方法 any、doWhile、forEach、wait 分别有什么区别，以及用法

Future 类在 Dart 中提供了一系列静态方法，其中包括 any、doWhile、forEach 和 wait。这些方法用于处理一组 Future 对象，但它们在用法和用途上有一些区别。 1. Future.any： 用途： Future.any 用于从一组 Future 中取得第一个完成的 Future 的结果，无论它是成功还是失败。 方法签名： static Future<dynamic> any(Iterable<Future<dynamic>> futures) 示例： Future<String> fetchUserData() async {   // 模拟异步操作   await Future.delayed(Duration(seconds: 2));   return 'User data'; } Future<String> fetchProductData() async {   // 模拟异步操作   await Future.delayed(Duration(seconds: 3));   return 'Product data'; } void main() async {   List<Future<String>> futures = [     fetchUserData(),     fetchProductData(),   ];   try {     var result = await Future.any(futures);     print('First completed result: $result');   } catch (error) {     print('All futures failed: $error');   } } 2. Future.doWhile： 用途： Future.doWhile 用于在条件为真的情况下反复执行异步操作，直到条件为假。 方法签名： dart Copy code static Future<void> doWhile(FutureOr<bool> Function() action) 示例： dart Copy code Future<void> fetchData() async {   // 模拟异步操作   await Future.delayed(Duration(seconds: 1));   print('Data fetched'); } void main() async {   bool condition = true;   await Future.doWhile(() async {     await fetchData();     condition = /* some condition */;     return condition;   });   print('Do-while loop completed'); } 3. Future.forEach： 用途： Future.forEach 用于遍历一组元素，并为每个元素执行异步操作。 方法签名： dart Copy code static Future<void> forEach<T>(Iterable<T> elements, FutureOr<void> Function(T element) action) 示例： dart Copy code Future<void> processItem(String item) async {   // 模拟异步操作   await Future.delayed(Duration(seconds: 1));   print('Processed: $item'); } void main() async {   List<String> items = ['Item 1', 'Item 2', 'Item 3'];   await Future.forEach(items, (item) async {     await processItem(item);   });   print('All items processed'); } 4. Future.wait： 用途： Future.wait 用于等待一组 Future 全部完成，并返回一个包含所有结果的 List。 方法签名： dart Copy code static Future<List<T>> wait<T>(Iterable<Future<T>> futures, {bool eagerError = false}) 示例： dart Copy code Future<String> fetchUserData() async {   // 模拟异步操作   await Future.delayed(Duration(seconds: 2));   return 'User data'; } Future<String> fetchProductData() async {   // 模拟异步操作   await Future.delayed(Duration(seconds: 3));   return 'Product data'; } void main() async {   List<Future<String>> futures = [     fetchUserData(),     fetchProductData(),   ];   try {     var results = await Future.wait(futures);     print('All results: $results');   } catch (error) {     print('One or more futures failed: $error');   } } 这些方法提供了对异步操作的不同处理方式，根据具体需求选择合适的方法。要注意的是，这些方法返回的 Future 会在所有操作完成后才完成，可以通过 await 来等待这个结果。

await

unawaited(calledMethod())

使用方法：https://dart.dev/tools/linter-rules/unawaited_futures

await calledMethod()

单个 样例： BAD: void main() async {   doSomething(); // Likely a bug. } GOOD: Future doSomething() => print("doSomething"); void main() async {   await doSomething();   unawaited(doSomething()); // Explicitly-ignored fire-and-forget. }

汇总

•异步等待（Awaiting）: await 自动解包Future，await 关键字使异步操作的结果（Future）变为普通值（Response<T>）自动解包，并暂停执行直到操作完成。 •异步函数（Async Function）: 使用 async 关键字声明的函数允许在内部使用 await。 •隐式返回 Future: 在 async 函数中，返回的非 Future 类型的值会被自动包装成 Future 对象。 •自动化操作: 这种行为是 Dart 语言设计的一部分，使异步编程更加简洁和一致。

async

async声明为异步方法，返回Future，隐式装包

示例代码

Future<int> fetchNumber() async {   // throw Exception("An error occurred!"); // 抛出异常，执行catchError，whenComplete也会执行无论是否成功完成就会执行。   await Future.delayed(Duration(seconds: 4));   print("fetchNumber done.");   return 42; } void main() {   fetchNumber().then((result) {     print("Result: $result");   }).catchError((error) {     print("Error: $error");   }).whenComplete(() {     print("Operation completed.");   }).timeout(Duration(seconds: 3), onTimeout: () {     print("Operation timed out!");   }); } 执行结果：验证过✅（注意timeout，可以看做是一个提示对执行没有影响） （等待3秒钟后） Operation timed out! （等待4秒钟后） fetchNumber done. Result: 42 Operation completed. 打开throw exception行的注释执行结果如下： Error: Exception: An error occurred! Operation completed. 总结：await后边的，然后then，complete 。timeout看做是一个提示即可，对执行顺序没有影响，是否展示只和是否超时有关系。

await等待执行结果，异步变同步(多个异步串行执行)

使用`async`和`await`的代码是异步的，但是看起来很像同步代码。当我们需要获得A的结果，再执行B，时，你需要`then()->then()`,但是利用`async`与`await`能够非常好的解决回调地狱的问题

示例

//async 表示这是一个异步方法,await必须再async方法中使用 //异步方法只能返回 void和Future Future<String> readFile() async {   //await 等待future执行完成再执行后续代码   String content = await new File("/Users/xiang/enjoy/a.txt").readAsString();   String content2 = await new File("/Users/xiang/enjoy/a.txt").readAsString();   //自动转换为 future   return content; }

经典题目

initstate中调用异步操作，不得已不要加await

概念与原理

🎯#Future有默认的timeout吗？如果有是多少？一句话精准的告诉我 Dart 的 `Future` **没有默认的 timeout**，除非显式使用 `timeout()` 方法或外部库设置，否则会一直等待完成。

await 暂停机制

await 的暂停机制： 遇到 await 时，Dart 会暂停当前函数的执行 将函数的剩余部分包装为一个回调，在 Future 完成后恢复执行 这个恢复操作实际上是通过微任务队列完成的

执行顺序

题目一

void main() async {   print("1. Start");   Future(() => print("2. Event Queue 1"),)     .then((_) => print("3. Microtask 1"))     .then((_) => print("4. Microtask 2"));   Future(     () => print("5. Event Queue 2"),   ).then((_) => print("6. Microtask 3"));   Future.microtask(() => print("7. Microtask 4"));   print("8. After await");   Future(() => print("9. Event Queue 3"));   print("10. End"); } // 1. Start // 8. After await // 10. End // 7. Microtask 4 // 2. Event Queue 1 // 3. Microtask 1 // 4. Microtask 2 // 5. Event Queue 2 // 6. Microtask 3 // 9. Event Queue 3

题目二

void main() async {   print("1. Start");   Future(() => print("2. Event Queue 1"),)     .then((_) => print("3. Microtask 1"))     .then((_) => print("4. Microtask 2"));   await Future(     () => print("5. Event Queue 2"),   ).then((_) => print("6. Microtask 3"));   await Future.microtask(() => print("7. Microtask 4"));   print("8. After await");   Future(() => print("9. Event Queue 3"));   print("10. End"); } // 1. Start // 2. Event Queue 1 // 3. Microtask 1 // 4. Microtask 2 // 5. Event Queue 2 // 6. Microtask 3 // 7. Microtask 4 // 8. After await // 10. End // 9. Event Queue 3

题目三

void main() async {   print("1. Start");   Future(() => print("2. Event Queue 1"),)     .then((_) => print("3. Microtask 1"))     .then((_) => print("4. Microtask 2"));   await Future(     () => print("5. Event Queue 2"),   ).then((_) => print("6. Microtask 3"));   Future.microtask(() => print("7. Microtask 4"));   print("8. After await");   Future(() => print("9. Event Queue 3"));   print("10. End"); } //1. Start //2. Event Queue 1 //3. Microtask 1 //4. Microtask 2 //5. Event Queue 2 //6. Microtask 3 //8. After await //10. End //7. Microtask 4 //9. Event Queue 3

Stream：简单发布订阅模型

Stream是什么 ，有几种，如何使用

Stream在Dart中是一个核心概念，简称 “流”，用于处理异步事件流。简单来说，Stream可以看作是发出的一系列异步数据。与集合（Iterable或Collection）不同，集合表示一系列的对象，而Stream表示的是异步的事件流。这意味着Stream中的数据或事件不是主动拉取的，而是异步产生的并推送给接收者。 Stream主要有两种类型： 1. 单订阅Stream（Single-Subscription）：这种Stream只包含一个事件序列，事件需要按顺序提供，不能丢失。例如，读取一个文件或接收一个网页的内容。 2. 广播Stream（Broadcast）：这种Stream针对单个消息的，一次处理一个消息。它可以在任何时候监听，支持添加多个监听器，并允许随时取消监听。一个常见的例子是浏览器的鼠标事件。 使用Stream时，主要有两种方式接收数据： 1. 使用异步for循环（async for）：这是一个专门用于遍历Stream的语法结构，它会在每个异步事件到达时进行处理。 2. 使用Stream的listen方法：这个方法允许你注册一个回调函数，当Stream中有新的事件产生时，这个函数会被调用。 此外，Stream还常常与转换（transform）操作一起使用，以便对事件流进行各种处理，如映射、过滤等。这些转换操作可以链式调用，形成一个处理管道，从而方便地对Stream中的数据进行复杂的处理。 总的来说，Stream是Dart中处理异步事件流的重要工具，它使得开发者能够以一种高效且灵活的方式处理异步数据。通过合理使用Stream及其相关操作，可以大大提高程序的性能和响应速度。

Stream在Dart中是一个核心概念，它代表了一系列异步产生的数据或事件。与传统的集合（Iterable或Collection）不同，Stream中的数据是异步提供的，这意味着数据并不是立即可用的，而是在某个时间点异步地推送给接收者。 Stream主要分为两种类型：单订阅Stream（Single-Subscription）和广播Stream（Broadcast）。 ### 1. 单订阅Stream（Single-Subscription） **概念**： 单订阅Stream只包含一个事件序列，事件需要按顺序提供，且一旦开始监听，就不能再次订阅。这种Stream适用于那些需要按照特定顺序处理事件的场景，例如读取文件或接收网络响应。 **使用方式**： 通常使用异步for循环（`await for`）来遍历并处理单订阅Stream中的每个事件。 **举例**： 假设我们有一个产生整数的单订阅Stream，我们想要遍历并打印每个整数： ```dart import 'dart:async'; void main() async {   Stream<int> numberStream = Stream.fromIterable([1, 2, 3, 4, 5]);      await for (int number in numberStream) {     print(number); // 输出: 1, 2, 3, 4, 5   } } ``` ### 2. 广播Stream（Broadcast） **概念**： 广播Stream允许多个监听器同时监听事件流，并且可以在任何时候添加或移除监听器。这种Stream适用于那些需要多个组件或功能共享相同事件流的场景，如浏览器的鼠标事件或键盘输入。 **使用方式**： 广播Stream通常使用`listen`方法来注册回调函数，以处理Stream中的事件。每个注册的监听器都会收到相同的事件。 **举例**： 假设我们有一个广播Stream用于处理用户点击事件，我们想要添加多个监听器来响应这些事件： ```dart import 'dart:async'; import 'dart:html'; void main() {   // 假设clickStream是一个表示用户点击事件的广播Stream   Stream<MouseEvent> clickStream = ...; // 这里应该是获取或创建点击事件流的代码      // 添加第一个监听器，打印点击的坐标   clickStream.listen((event) {     print('Clicked at (${event.clientX}, ${event.clientY})');   });      // 添加第二个监听器，执行其他操作   clickStream.listen((event) {     // 执行其他逻辑...   }); } ``` ### 区别 * **订阅模式**：单订阅Stream只能被一个监听器订阅，而广播Stream允许多个监听器同时订阅。 * **事件处理**：对于单订阅Stream，一旦开始监听，就不能再次订阅，且事件通常只推送一次；而广播Stream支持动态地添加和移除监听器，每个监听器都会收到相同的事件。 无论是单订阅还是广播Stream，它们都是Dart中处理异步事件流的强大工具。根据具体需求和应用场景，选择适合的Stream类型并正确使用，可以大大提高程序的响应性和灵活性。

异步事件流

Stream(流) 在 Dart API 中也经常出现，表示发出的一系列的异步数据。 Stream 是一个异步数据源，它是 Dart 中处理异步事件流的统一 API。

场景：多用于事件传递、文件读取、异步循环等场景

监听用户输入

StreamBuilder+StreamController

当使用 Stream 监听用户输入时，你需要使用 StreamBuilder 来构建一个 Widget 树，结合StreamController 以响应 Stream 中的事件。以下是完整的第一个示例，包括监听代码： import 'dart:async'; import 'package:flutter/material.dart'; void main() {   runApp(MyApp()); } class MyApp extends StatelessWidget {   @override   Widget build(BuildContext context) {     return MaterialApp(       home: InputListenerDemo(),     );   } } class InputListenerDemo extends StatefulWidget {   @override   _InputListenerDemoState createState() => _InputListenerDemoState(); } class _InputListenerDemoState extends State<InputListenerDemo> {   final StreamController<String> _inputController = StreamController<String>();   @override   Widget build(BuildContext context) {     return Scaffold(       appBar: AppBar(         title: Text('Input Listener Demo'),       ),       body: Center(         child: Column(           mainAxisAlignment: MainAxisAlignment.center,           children: [             TextField(               onChanged: (text) {                 // 将文本变化通过 Stream 发送出去                 _inputController.add(text);               },               decoration: InputDecoration(labelText: 'Type Something'),             ),             SizedBox(height: 20),             StreamBuilder<String>(               stream: _inputController.stream,               builder: (context, snapshot) {                 return Text('Input: ${snapshot.data ?? 'No Input'}');               },             ),           ],         ),       ),     );   }   @override   void dispose() {     _inputController.close();     super.dispose();   } } 在这个例子中，我们使用了 StreamBuilder<String> 来监听 _inputController.stream。StreamBuilder 接收 Stream 的事件，当有新的文本输入时，它会自动重建 Widget 树并更新显示的文本内容。这样，用户输入的变化将会实时地反映在界面上。

StreamController.listen

StreamController独自实现监听并刷新视图，主要使用 listen 方法：结合setState(() { } 你可以直接调用 Stream 的 listen 方法来注册事件处理函数，以便在事件发生时执行特定的逻辑。 dart Copy code import 'dart:async'; import 'package:flutter/material.dart'; void main() {   runApp(MyApp()); } class MyApp extends StatelessWidget {   @override   Widget build(BuildContext context) {     return MaterialApp(       home: InputListenerDemo(),     );   } } class InputListenerDemo extends StatefulWidget {   @override   _InputListenerDemoState createState() => _InputListenerDemoState(); } class _InputListenerDemoState extends State<InputListenerDemo> {   final StreamController<String> _inputController = StreamController<String>();   @override   Widget build(BuildContext context) {     return Scaffold(       appBar: AppBar(         title: Text('Input Listener Demo'),       ),       body: Center(         child: Column(           mainAxisAlignment: MainAxisAlignment.center,           children: [             TextField(               onChanged: (text) {                 // 将文本变化通过 Stream 发送出去                 _inputController.add(text);               },               decoration: InputDecoration(labelText: 'Type Something'),             ),             SizedBox(height: 20),             Text('Input:'), // 用于显示输入的文本           ],         ),       ),       floatingActionButton: FloatingActionButton(         onPressed: () {           // 直接调用 Stream 的 listen 方法注册事件处理函数           _inputController.stream.listen((String data) {             // 处理输入的文本             setState(() {               // 更新界面上显示的文本               // 注意：在实际应用中可能需要根据业务逻辑处理文本而不仅仅是显示               Text('Input: $data');             });           });         },         child: Icon(Icons.play_arrow),       ),     );   }   @override   void dispose() {     _inputController.close();     super.dispose();   } } 在这个例子中，我们在 FloatingActionButton 的 onPressed 回调中直接调用了 _inputController.stream.listen 方法来注册事件处理函数。当用户输入文本时，该函数将会被调用，我们在其中更新了显示的文本。

await for

使用 async/await： 在异步函数中，你可以使用 await for 语法来监听 Stream 的事件。 dart Copy code import 'dart:async'; import 'package:flutter/material.dart'; void main() {   runApp(MyApp()); } class MyApp extends StatelessWidget {   @override   Widget build(BuildContext context) {     return MaterialApp(       home: InputListenerDemo(),     );   } } class InputListenerDemo extends StatefulWidget {   @override   _InputListenerDemoState createState() => _InputListenerDemoState(); } class _InputListenerDemoState extends State<InputListenerDemo> {   final StreamController<String> _inputController = StreamController<String>();   @override   Widget build(BuildContext context) {     return Scaffold(       appBar: AppBar(         title: Text('Input Listener Demo'),       ),       body: Center(         child: Column(           mainAxisAlignment: MainAxisAlignment.center,           children: [             TextField(               onChanged: (text) {                 // 将文本变化通过 Stream 发送出去                 _inputController.add(text);               },               decoration: InputDecoration(labelText: 'Type Something'),             ),             SizedBox(height: 20),             Text('Input:'), // 用于显示输入的文本           ],         ),       ),       floatingActionButton: FloatingActionButton(         onPressed: () async {           // 使用 async/await 监听 Stream 的事件           await for (String data in _inputController.stream) {             // 处理输入的文本             setState(() {               // 更新界面上显示的文本               // 注意：在实际应用中可能需要根据业务逻辑处理文本而不仅仅是显示               Text('Input: $data');             });           }         },         child: Icon(Icons.play_arrow),       ),     );   }   @override   void dispose() {     _inputController.close();     super.dispose();   } } 在这个例子中，我们在 FloatingActionButton 的 onPressed 回调中使用 await for 语法监听了 _inputController.stream 的事件。当用户输入文本时，await for 语法将会迭代 Stream 中的事件，我们就可以更新视图中的文本了。

使用方法

Stream API

StreamController (.listen((entity) {}))

StreamController.stream.listen((entity) {}) 示例代码： void main(List<String> arguments) {   // ...   FileSystemEntity.isDirectory(searchPath).then((isDir) {     if (isDir) {       final startingDir = Directory(searchPath);       startingDir.list().listen((entity) {         if (entity is File) {           searchFile(entity, searchTerms);         }       });     } else {       searchFile(File(searchPath), searchTerms);     }   }); }

StreamBuilder

StreamBuilder、StreamController、await for 三种方式有什么区别

总结：StreamBuilder用于响应式更新UI的场景，listen和await for用于非UI相关的业务逻辑场景，其中 listen适用于手动管理订阅过程，对每个事件进行个性化处理，可以在非异步函数中使用。 await for 更适用于在异步函数中等待和处理整个 Stream 的事件序列，不需要手动取消订阅，对于异步操作的结果处理更为方便，不可以在非异步函数中使用。 在实际开发中，根据具体需求选择合适的方式。通常，如果你只关心某个特定时间范围内的事件，使用 listen 更合适；如果你需要一直监听整个 Stream 的事件，而且可能在异步函数中处理结果，那么 await for 循环更方便。 三种方式都是用于监听 Stream 事件，但它们在使用场景和实现上有一些区别。下面简要介绍这三种方式的特点和适用场景： 1. StreamBuilder： 使用场景： 适用于在 Flutter Widget 树中实时更新 UI 的场景。StreamBuilder 是一个 Widget，它根据 Stream 的事件动态构建 Widget 树，从而实现响应式 UI。 示例： StreamBuilder<String>(   stream: myStream,   builder: (context, snapshot) {     if (snapshot.hasData) {       return Text('Data: ${snapshot.data}');     } else if (snapshot.hasError) {       return Text('Error: ${snapshot.error}');     } else {       return Text('Waiting for data...');     }   }, ) 特点： StreamBuilder 使用起来非常方便，可以直接嵌套在 Widget 树中，根据 Stream 的状态动态构建 UI。 2. Stream.listen： 使用场景： 适用于非 Widget 层次结构的场景，例如在函数中监听事件。不适用于构建和更新 Widget 树。 示例： StreamController<String> myController = StreamController<String>(); void setupStreamListener() {   myController.stream.listen((data) {     print('Data received: $data');   }); } 特点： 通过 listen 方法注册回调函数，可以处理 Stream 中的事件，但它不直接用于构建 UI。 3. await for 循环： 使用场景： 适用于异步函数中，需要等待 Stream 发送事件并处理这些事件的场景。await for通常用于遍历异步产生的Stream数据，这在处理如文件读取、网络请求或其他异步数据流时很有用。 示例： Future<void> processStream() async {   await for (String data in myStream) {     print('Data received: $data');   } } 特点： await for 循环在异步函数中等待 Stream 发送的事件，可以方便地处理异步事件序列，但同样不直接用于构建 UI。 总体而言，选择使用哪种方式取决于你的具体需求。如果需要在 Flutter Widget 树中实时更新 UI，使用 StreamBuilder 是最常见的方式。而在非 Widget 层次结构的代码中，可以使用 Stream.listen 或 await for 循环来处理 Stream 事件。

listen和await for 详细的区别

listen 和 await for 都是用于监听 Dart 中的 Stream 事件，但它们在使用方式和用途上有一些区别。 listen 方法： 使用方式： listen 方法是 Stream 提供的方法之一，通过调用 stream.listen 来注册事件监听器。 stream.listen(   (data) {     // 处理数据   },   onError: (error) {     // 处理错误   },   onDone: () {     // 处理完成事件   },   cancelOnError: false, // 可选参数，设置为 true 时遇到错误会立即取消订阅 ); 场景： 适用于需要手动管理订阅过程，对每个事件分别进行处理的场景。常见用于异步编程、非 UI 相关的业务逻辑。 取消订阅： 如果不再需要监听事件，需要手动调用 cancel 或等到 Stream 关闭。 await for 循环： 使用方式： await for 循环是 Dart 中用于迭代异步 Stream 的语法糖，可以在异步函数中使用。 await for (var data in stream) {   // 处理数据 } 场景： 适用于在异步函数中等待和处理整个 Stream 的事件序列，通常用于处理异步操作的结果。 取消订阅： 不需要手动取消订阅，await for 会自动处理订阅和取消订阅的过程，当 Stream 关闭时，循环会自动退出。 区别总结： listen 适用于手动管理订阅过程，对每个事件进行个性化处理，可以在非异步函数中使用。 await for 更适用于在异步函数中等待和处理整个 Stream 的事件序列，不需要手动取消订阅，对于异步操作的结果处理更为方便。 在实际开发中，根据具体需求选择合适的方式。通常，如果你只关心某个特定时间范围内的事件，使用 listen 更合适；如果你需要一直监听整个 Stream 的事件，而且可能在异步函数中处理结果，那么 await for 循环更方便。

问答

dart实现监听用户输入 并展示到text widget上 需要使用await for  吗

在Dart中，尤其是与Flutter框架结合使用时，监听用户输入（如TextField的文本变化）并展示到Text widget上通常不需要使用`await for`。`await for`通常用于遍历异步产生的Stream数据，这在处理如文件读取、网络请求或其他异步数据流时很有用。 对于用户输入，Flutter提供了`TextField` widget，它有一个`onChanged`回调，该回调会在用户输入文本时触发。你可以使用这个回调来更新状态，并反映到Text widget上。 下面是一个简单的例子，展示了如何使用`TextField`的`onChanged`回调来监听用户输入，并将输入文本展示到另一个Text widget上： ```dart import 'package:flutter/material.dart'; void main() {   runApp(MyApp()); } class MyApp extends StatelessWidget {   @override   Widget build(BuildContext context) {     return MaterialApp(       home: Scaffold(         appBar: AppBar(           title: Text('User Input Example'),         ),         body: Center(           child: MyInputField(),         ),       ),     );   } } class MyInputField extends StatefulWidget {   @override   _MyInputFieldState createState() => _MyInputFieldState(); } class _MyInputFieldState extends State<MyInputField> {   String _userInput = '';   void _handleTextChange(String text) {     setState(() {       _userInput = text;     });   }   @override   Widget build(BuildContext context) {     return Column(       mainAxisAlignment: MainAxisAlignment.center,       children: <Widget>[         TextField(           decoration: InputDecoration(labelText: 'Enter Text'),           onChanged: _handleTextChange, // 当文本变化时调用此回调         ),         SizedBox(height: 20), // 添加一些间距         Text('You entered: $_userInput'), // 显示用户输入的文本       ],     );   } } ``` 在这个例子中，`TextField`的`onChanged`属性接受一个函数，该函数会在用户每次键入字符时被调用。这个函数接收一个参数，即用户当前输入的文本。我们使用`setState`方法来更新状态，这会导致Flutter重新构建widget，从而更新UI以反映新的用户输入。 因此，对于监听用户输入并展示到Text widget上的情况，你不需要使用`await for`。相反，你应该使用Flutter提供的响应式编程模式，利用状态管理和widget重建来更新UI。

asynchronous for loop

await for(final entity in list){}

示例代码：（等价stream api 示例） void main(List<String> arguments) async {   // ...   if (await FileSystemEntity.isDirectory(searchPath)) {     final startingDir = Directory(searchPath);     await for (final entity in startingDir.list()) {       if (entity is File) {         searchFile(entity, searchTerms);       }     }   } else {     searchFile(File(searchPath), searchTerms);   } }

使用Stream和await for循环来遍历数据的好处是什么

使用`Stream`和`await for`循环来遍历数据在Dart（特别是在Flutter应用中）有很多好处。以下是一些主要的好处： 1. **异步处理**：`Stream`是异步的，这意味着你可以在不阻塞UI线程的情况下处理数据。这对于需要处理大量数据或执行耗时操作的应用来说尤为重要。通过使用`Stream`，你可以确保应用的响应性和流畅性。 2. **懒加载和流式处理**：`Stream`支持懒加载，即它只在需要时才生成数据。这可以节省内存和处理器资源，特别是在处理大量数据时。此外，你可以通过转换和操作符对`Stream`进行流式处理，以实现复杂的逻辑和数据操作。 3. **错误处理**：`Stream`提供了错误处理机制，你可以通过监听错误事件来处理在数据生成或处理过程中发生的异常。这有助于增强应用的健壮性和可靠性。 4. **可组合性**：`Stream`可以轻松组合和链式调用，使得构建复杂的数据流变得简单。你可以将多个`Stream`连接在一起，或者对单个`Stream`应用多个转换操作符，以实现灵活且强大的数据处理逻辑。 5. **可读性和可维护性**：使用`await for`循环遍历`Stream`可以使代码更加简洁和易读。与传统的循环和回调相比，它减少了嵌套和回调地狱的问题，使得代码更加易于理解和维护。 在你给出的例子中，`Stream.fromIterable([1, 2, 3, 4, 5])`创建了一个包含整数的`Stream`，然后使用`await for`循环遍历这个`Stream`并打印每个整数。虽然这个例子中的数据是静态的，但在实际应用中，`Stream`可能来自网络请求、文件读取、用户输入等异步数据源，使用`await for`循环可以方便地处理这些异步数据。 总的来说，使用`Stream`和`await for`循环遍历数据可以提高应用的性能、可读性和可维护性，特别适用于处理异步和流式数据。

操作订阅者：取消、异常、暂停继续

广播模式：允许多个订阅者 Stream有两种订阅模式：单订阅和多订阅。单订阅就是只能有一个订阅者，上面的使用我们都是单订阅模式，而广播是可以有多个订阅者。通过 Stream.asBroadcastStream() 可以将一个单订阅模式的 Stream 转换成一个多订阅模式的 Stream，isBroadcast 属性可以判断当前 Stream 所处的模式。

单订阅流和广播订阅流初始化有什么区别，分别是如何初始化的

在Dart中，单订阅流和广播流的初始化方式有所不同，主要体现在它们的创建和使用的灵活性上。以下是它们初始化的主要区别： ### 单订阅流初始化 单订阅流通常是通过一些直接产生事件流的构造器或者方法来创建的。这些构造器和方法产生的流在没有监听者时不会发送事件，一旦有监听者订阅并开始接收事件，如果监听者取消订阅，流将停止发送事件。 例如，你可以使用以下方式初始化单订阅流： ```dart // 使用fromIterable从集合创建单订阅流 Stream<int> singleSubscriptionStreamFromIterable = Stream.fromIterable([1, 2, 3, 4, 5]); // 使用fromFuture从Future创建单订阅流 Future<int> future = Future.value(42); Stream<int> singleSubscriptionStreamFromFuture = Stream.fromFuture(future); // 使用generate创建单订阅流，基于提供的函数生成事件 Stream<int> singleSubscriptionStreamFromGenerate = Stream.generate(() => Random().nextInt(100)); ``` ### 广播流初始化 广播流不是直接通过构造器创建的，而是通过将已有的单订阅流转换为广播流来初始化的。这通常是通过调用单订阅流的`asBroadcastStream`方法来实现的。广播流允许多个监听者订阅，并且无论是否有监听者，它都能产生事件。 例如，你可以使用以下方式初始化广播流： ```dart // 假设我们有一个单订阅流 Stream<int> singleSubscriptionStream = Stream.fromIterable([1, 2, 3, 4, 5]); // 将单订阅流转换为广播流 Stream<int> broadcastStream = singleSubscriptionStream.asBroadcastStream(); ``` ### 初始化区别 * **创建方式**：单订阅流通常通过直接调用流构造器或方法创建，而广播流则是通过将单订阅流转换为广播流来创建的。 * **订阅者数量**：在初始化时，这个区别还不明显，但单订阅流在后续只允许一个订阅者，而广播流则允许多个订阅者。 * **事件发送**：单订阅流在初始化后，只有在有监听者时才会发送事件，而广播流则不论是否有监听者都在发送事件（当然，前提是底层数据源在产生事件）。 ### 使用场景 * **单订阅流**：适用于那些只需要一个接收者的场景，如文件I/O流的读取、单个组件的状态更新或一次性的数据加载。 * **广播流**：适用于那些需要多个组件或功能共享相同事件流的场景，如全局状态管理、多个UI组件的响应或跨多个部分的实时数据流。 在初始化流时，你应该根据你的应用程序的具体需求来选择使用单订阅流还是广播流。如果你不确定，通常从单订阅流开始是一个好的选择，因为它更加简单和直观，而且你可以随时通过调用`asBroadcastStream`方法将其转换为广播流，以满足更多的订阅者需求。

使用指南：https://dart.dev/guides/libraries/library-tour#stream

isolate（Dart中的异步机制）

像进程一样的线程

事件驱动

事件队列与微任务队列

微任务队列的优先级是最高的 跟普通的任务并列好几个的时候，就算是微任务后提交，也会先把微任务执行完，之后再执行普通的任务！

微任务队列

会不会插队执行呢？会。

是什么，如何使用

在 Dart 中，Isolate（孤立体）是一种并发模型，用于在独立的执行上下文中执行代码，具有独立的内存空间。每个 Isolate 都运行在自己的 Dart 虚拟机实例中，彼此之间不共享内存。这种设计可以提高并发性，并允许开发者更好地利用多核处理器。 通常，Isolate 用于处理计算密集型的任务、并行处理、在后台执行长时间运行的任务，或者在 Flutter 中用于在主 UI 线程之外执行某些任务，以保持应用的响应性。 以下是 Isolate 的一些特点： 独立的内存空间： 每个 Isolate 有自己的内存空间，不与其他 Isolate 共享数据，相互之间通过消息传递进行通信。 并发执行： Isolate 允许并行执行代码，特别适用于多核处理器环境。 消息传递： Isolate 之间通过消息传递来进行通信。这些消息可以包含序列化后的数据，也可以包含共享的可发送对象。 下面是一个简单的示例，演示了如何创建和使用 Isolate： import 'dart:isolate'; void isolateFunction(SendPort sendPort) {   // 接收消息并处理   ReceivePort receivePort = ReceivePort();   sendPort.send(receivePort.sendPort);   receivePort.listen((message) {     print('Isolate received message: $message');   }); } void main() async {   // 创建一个新的 Isolate   ReceivePort receivePort = ReceivePort();   Isolate.spawn(isolateFunction, receivePort.sendPort);   // 等待 Isolate 发送消息   SendPort sendPort = await receivePort.first;   // 在主 Isolate 中发送消息到新创建的 Isolate   sendPort.send('Hello from main Isolate'); } 在这个例子中，我们创建了一个新的 Isolate，并在主 Isolate 中与新 Isolate 之间通过消息传递进行通信。这里的 SendPort 和 ReceivePort 用于实现 Isolate 之间的消息传递。 要注意的是，在 Flutter 中，Isolate 也被广泛用于在后台执行任务以保持应用的响应性，例如在 Isolate 中执行网络请求、计算密集型任务等。Flutter 提供了 compute 函数，可以方便地在 Isolate 中执行任务并将结果返回给主 UI 线程。 import 'package:flutter/foundation.dart'; void backgroundTask(String message) {   print('Background task received message: $message'); } void main() {   // 在 Isolate 中执行任务   compute(backgroundTask, 'Hello from main Isolate'); } 在上述代码中，compute 函数会自动在后台 Isolate 中执行 backgroundTask 函数，而不会阻塞主 UI 线程。这样可以确保应用在执行一些耗时任务时仍然保持响应性。

应用场景有哪些？

Isolate 在 Dart 中的使用场景主要涉及以下几个方面： 并发执行： Isolate 允许在独立的执行上下文中并发执行代码，这对于处理计算密集型任务、并行处理以及提高应用性能很有用。 长时间运行的任务： Isolate 可以用于在后台执行长时间运行的任务，而不影响主 UI 线程的响应性。这对于执行需要较长时间的计算、I/O 操作或网络请求等任务非常有用。 并行处理： 当需要同时处理多个任务时，每个任务可以在独立的 Isolate 中执行，以提高整体性能。 下面是一些 Isolate 的使用场景和示例： 1. 处理计算密集型任务： import 'dart:isolate'; void computePi(SendPort sendPort) {   // 执行计算密集型任务   double pi = 0.0;   for (int i = 0; i < 1000000000; i++) {     pi += (i.isOdd ? -1.0 : 1.0) * (4.0 / (2 * i + 1));   }   // 发送结果到主 Isolate   sendPort.send(pi); } void main() async {   ReceivePort receivePort = ReceivePort();   Isolate.spawn(computePi, receivePort.sendPort);   double result = await receivePort.first;   print('Computed Pi: $result'); } 在这个例子中，computePi 函数在一个独立的 Isolate 中执行计算密集型的任务，然后将结果发送回主 Isolate。 2. 在后台执行网络请求： 在 Flutter 中，Isolate 经常用于在后台执行网络请求，以避免在主 UI 线程中阻塞。 import 'dart:isolate'; import 'dart:async'; import 'dart:io'; void fetchData(SendPort sendPort) async {   HttpClient httpClient = HttpClient();   try {     HttpClientRequest request = await httpClient.getUrl(Uri.parse('https://example.com'));     HttpClientResponse response = await request.close();     String data = await response.transform(utf8.decoder).join();     sendPort.send(data);   } catch (error) {     sendPort.sendError(error.toString());   } finally {     httpClient.close();   } } void main() async {   ReceivePort receivePort = ReceivePort();   Isolate.spawn(fetchData, receivePort.sendPort);   receivePort.listen((dynamic data) {     if (data is String) {       print('Data received: $data');     } else if (data is Error) {       print('Error: ${data.toString()}');     }   }); } 在这个例子中，fetchData 函数在 Isolate 中执行网络请求，并将结果或错误信息通过消息传递发送回主 Isolate。 3. 并行处理任务： import 'dart:isolate'; void processItem(SendPort sendPort, String item) {   // 执行任务   String processedItem = item.toUpperCase();   // 发送处理后的结果到主 Isolate   sendPort.send(processedItem); } void main() async {   List<String> items = ['item1', 'item2', 'item3'];   List<ReceivePort> receivePorts = [];   for (int i = 0; i < items.length; i++) {     ReceivePort receivePort = ReceivePort();     receivePorts.add(receivePort);     Isolate.spawn(processItem, receivePort.sendPort);   }   for (int i = 0; i < items.length; i++) {     String item = await receivePorts[i].first;     print('Processed item: $item');   } } 在这个例子中，每个任务被分发到独立的 Isolate 中并行执行，最终结果通过消息传递返回到主 Isolate。 这些示例涵盖了一些常见的 Isolate 使用场景，包括计算密集型任务、网络请求以及并行处理任务。在实际应用中，Isolate 可以根据具体需求来使用，以提高应用的性能和并发处理能力。

总结

future、stream、isolate的区别，以及各自的应用场景

阅读

https://www.jianshu.com/p/d4df418244e8

学习工具

知识点

发布渠道

https://github.com/flutter/flutter/wiki/Flutter-build-release-channels

查看发布渠道：flutter channel

环境配置

版本

查看dart版本：dart --version 查看flutter版本：flutter --version pub.yaml文件 environment:   sdk: '>=2.18.2 <3.0.0' # dart sdk version   flutter: ">=2.5.0" # flutter sdk version

dart升级

flutter sdk升级

flutter upgrade

使用flutter upgrade命令可以升级到Flutter的最新版本。该命令会检查可用的Flutter SDK版本，并将您的Flutter环境升级到最新的稳定版本。请注意，升级后的版本可能会引入一些不兼容的更改，因此建议在升级之前仔细阅读Flutter的更新日志，并根据需要进行必要的调整。 另外，如果您想要升级到特定的Flutter版本，可以使用flutter upgrade v<version_number>命令，将<version_number>替换为您想要升级到的特定版本号。但请注意，只能升级到已发布的版本，并且需要确保该版本与您的应用程序兼容。

官方文档：https://flutter.cn/docs/release/upgrade

产看版本

查看flutter版本：flutter --version

归档列表

https://flutter.cn/docs/release/archive?tab=macos

Flutter SDK 归档列表：https://flutter.cn/docs/release/archive?tab=macos

三方讲解

https://www.jianshu.com/p/4567f9509ba3

如何升级

依赖库pub

flutter pub get

flutter pub outdated

编译打包

flutter build

➜  gallery git:(main) ✗ flutter build Build an executable app or install bundle. Global options: -h, --help                  Print this usage information. -v, --verbose               Noisy logging, including all shell commands executed.                             If used with "--help", shows hidden options. If used with "flutter doctor", shows additional diagnostic information. (Use "-vv" to force verbose                             logging in those cases.) -d, --device-id             Target device id or name (prefixes allowed).     --version               Reports the version of this tool.     --enable-analytics      Enable telemetry reporting each time a flutter or dart command runs.     --disable-analytics     Disable telemetry reporting each time a flutter or dart command runs, until it is re-enabled.     --suppress-analytics    Suppress analytics reporting for the current CLI invocation. Usage: flutter build <subcommand> [arguments] -h, --help    Print this usage information. Available subcommands:   aar               Build a repository containing an AAR and a POM file.   apk               Build an Android APK file from your app.   appbundle         Build an Android App Bundle file from your app.   bundle            Build the Flutter assets directory from your app.   ios               Build an iOS application bundle (macOS host only).   ios-framework     Produces .xcframeworks for a Flutter project and its plugins for integration into existing, plain iOS Xcode projects.   ipa               Build an iOS archive bundle and IPA for distribution (macOS host only).   macos             Build a macOS desktop application.   macos-framework   Produces .xcframeworks for a Flutter project and its plugins for integration into existing, plain macOS Xcode projects.   web               Build a web application bundle. Run "flutter help" to see global options.

初始化

确保正确绑定引擎和正确的初始化应用。（确保在 Flutter 应用程序启动时，框架和引擎之间的必要绑定的建立。）

`WidgetsFlutterBinding.ensureInitialized();` 是在 Flutter 应用程序中的一个常见用法，它用于确保 Flutter 的绑定已经初始化。这行代码通常出现在 `main` 函数或应用程序的入口处。 在 Flutter 中，Widgets 是构建用户界面的基本构建块，而 `WidgetsFlutterBinding` 是与框架（framework）的绑定，负责初始化和维护一些全局状态。在确保初始化后，Flutter 应用程序就能够使用 Flutter 框架提供的功能，包括管理 Widget 树、处理用户输入、渲染 UI 等。 具体而言，`WidgetsFlutterBinding.ensureInitialized();` 主要用于处理异步任务、初始化资源，或在应用程序启动时执行一些必要的操作。例如，如果你的应用程序需要在启动时初始化一些数据或执行异步的操作，你可以将这些操作放在 `main` 函数中，并使用 `WidgetsFlutterBinding.ensureInitialized();` 确保初始化已完成。 以下是一个简单的示例： ```dart import 'package:flutter/widgets.dart'; void main() {   WidgetsFlutterBinding.ensureInitialized();   // 在这里执行你的初始化操作，例如加载数据等   runApp(MyApp()); } class MyApp extends StatelessWidget {   @override   Widget build(BuildContext context) {     return MaterialApp(       home: Scaffold(         appBar: AppBar(           title: Text('My Flutter App'),         ),         body: Center(           child: Text('Hello, Flutter!'),         ),       ),     );   } } ``` 这个示例中，`WidgetsFlutterBinding.ensureInitialized();` 确保在 `main` 函数中初始化 Flutter 绑定，然后执行你的初始化逻辑，最后运行你的应用程序。

`WidgetsFlutterBinding.ensureInitialized();` 的作用是确保 Flutter 的绑定（binding）已经被初始化。在 Flutter 应用中，`WidgetsFlutterBinding` 是 Flutter 框架与 Flutter 引擎之间的绑定，它负责管理整个应用程序的生命周期、构建和渲染。 具体而言，`ensureInitialized` 方法执行以下任务： 1. **初始化绑定：** 确保 `WidgetsFlutterBinding` 已经被正确初始化。如果尚未初始化，它将执行初始化的过程。 2. **处理异步任务：** 在应用程序启动时，可能存在一些需要异步执行的任务，例如初始化插件、加载资源等。`ensureInitialized` 确保在执行其他操作之前，这些异步任务已经完成。 在大多数情况下，`WidgetsFlutterBinding.ensureInitialized();` 出现在应用程序的入口函数（通常是 `main` 函数）中，以确保在 Flutter 应用程序启动时，框架和引擎之间的必要绑定已经建立。 以下是一个简单的示例： ```dart import 'package:flutter/widgets.dart'; void main() {   WidgetsFlutterBinding.ensureInitialized();   // 在这里执行你的初始化操作，例如加载数据等   runApp(MyApp()); } class MyApp extends StatelessWidget {   @override   Widget build(BuildContext context) {     return MaterialApp(       home: Scaffold(         appBar: AppBar(           title: Text('My Flutter App'),         ),         body: Center(           child: Text('Hello, Flutter!'),         ),       ),     );   } } ``` 在这个示例中，`WidgetsFlutterBinding.ensureInitialized();` 确保初始化已经完成，然后你可以在之后执行应用程序的初始化逻辑。

初始化过程

顺序：main -> 绑定（初始化绑定） -> 业务初始化 -> runApp（启动页面）

main

入口函数

绑定

是什么❓了解绑定做了什么，flutter框架

`WidgetsFlutterBinding.ensureInitialized();` 是用于确保在 Flutter 应用程序启动时，框架（Flutter Framework）与引擎（Flutter Engine）之间的绑定已经被正确初始化。 在 Flutter 中，有三个主要的绑定（Binding）： 1. **WidgetsFlutterBinding：** 负责构建和维护 Widget 树，并将它们与渲染树连接起来。`WidgetsFlutterBinding` 是框架与引擎之间的桥梁，管理整个应用程序的生命周期。 2. **ServicesBinding：** 处理底层平台服务，例如输入、触摸事件、定时器等。 3. **SchedulerBinding：** 负责调度和处理帧（Frame）以及处理动画等任务。 `ensureInitialized` 方法是 `WidgetsFlutterBinding` 类的一个静态方法，用于确保在使用这个绑定的功能之前，绑定已经被正确地初始化。如果尚未初始化，`ensureInitialized` 方法将触发初始化过程。 所以，`WidgetsFlutterBinding.ensureInitialized();` 的作用是确保在执行其他 Flutter 框架相关操作之前，`WidgetsFlutterBinding` 已经被初始化。这有助于确保应用程序能够正常运行并使用 Flutter 框架提供的功能。

WidgetsFlutterBinding.ensureInitialized()

作用是什么

确保在应用业务初始化操作之前，框架（Flutter Framework）与引擎（Flutter Engine）之间的绑定已经被正确初始化。

业务初始化

例如：网络、推送、地图等模块的初始化。

初始化操作：App配置、模块初始化、用户手机权限申请 配置：主要进行应用级别的配置项配置。如App配置：app版本配置、开发模式和发布模式配置。网络配置：Host配置。样式配置：如状态栏样式。第三方库配置：key配置等等 模块初始化：网络，缓存，以及其他业务模块和第三方组件。 手机权限申请。

runApp函数

插入根控件、开始构建UI。（将根 Widget 插入 Widget 树中，并通知框架开始构建 UI。）

是初始化绑定、业务初始化操作、启动页面

初始化优化

Flutter 应用启动优化是提高应用程序启动性能的一项关键任务。以下是一些可以帮助你优化 Flutter 应用启动时间的方法： 1. **使用 AOT 编译：** 在生产环境中，使用 Ahead-of-Time (AOT) 编译模式，而不是 Just-in-Time (JIT) 编译模式。AOT 编译可以将 Dart 代码预先编译成本地机器码，提高应用程序启动性能。    ```bash    flutter build aot    ``` 2. **延迟加载资源：** 只在需要时加载资源，例如图片、字体等。你可以使用 `Image.network` 的 `loadingBuilder` 参数来显示占位符，然后在图片加载完成后再显示真实的图片。 3. **使用 `const` 构造函数：** 在构建 Widget 树时，尽量使用 `const` 构造函数来创建静态的部分。这样可以在编译时进行常量折叠，减少运行时的工作。 4. **避免不必要的重建：** 使用 `const` 构造函数创建静态的 Widget，并使用 `AutomaticKeepAliveClientMixin`、`PageStorageKey` 等保持状态的方法，避免不必要的 Widget 重建。 5. **使用 `async` 和 `await`：** 在需要等待的异步操作中使用 `async` 和 `await`，以确保异步任务在启动过程中不会阻塞主线程。 6. **使用 `FutureBuilder`：** 如果应用程序有需要等待的异步操作，可以使用 `FutureBuilder` 来在数据准备好后再构建 UI。 7. **合理使用插件：** 谨慎选择和使用 Flutter 插件，确保插件的初始化不会对应用程序启动时间产生过大的影响。 8. **减少不必要的依赖：** 在 Widget 的 `build` 方法中，只声明真正需要重建的 Widget，避免过多的不必要依赖。 9. **使用 Flutter DevTools：** 使用 Flutter DevTools 中的性能分析工具来识别和解决应用程序启动时的性能瓶颈。 10. **减小应用程序包大小：** 通过适当的资源压缩和移除不必要的资源，减小应用程序包的大小可以加快应用程序的下载和初始化速度。 11. **优化网络请求：** 如果应用程序在启动时需要进行网络请求，确保网络请求是高效和快速的，避免阻塞主线程。 12. **升级 Flutter 版本：** 定期升级 Flutter 到最新的稳定版本，以获取性能和稳定性方面的改进。 这些优化策略可以根据应用程序的具体情况进行调整和组合。进行性能测试和分析是评估和改进应用程序启动性能的关键步骤。

疑难杂症

zsh: command not found: flutter

如果您在使用zsh时出现 "zsh: command not found: flutter" 的错误，这可能是因为您的zsh shell无法找到Flutter的可执行文件。这通常是因为Flutter的可执行文件路径未添加到系统的`$PATH`环境变量中。 以下是一些可能的解决方法： 1. **检查Flutter安装路径：**    确保您已经正确安装了Flutter，并且知道Flutter的安装路径。默认情况下，Flutter通常安装在用户的主目录下的 `~/flutter` 目录中。如果您不确定安装路径，可以使用以下命令找到：    ```bash    echo $HOME/flutter    ``` 2. **将Flutter可执行文件路径添加到$PATH：**    打开您的zsh配置文件（通常是`~/.zshrc`），并确保已经将Flutter的`bin`目录添加到您的`$PATH`环境变量中。在`~/.zshrc`中添加以下行：    ```bash    export PATH="$PATH:$HOME/flutter/bin"    ```    保存文件并重新加载zsh配置：    ```bash    source ~/.zshrc    ``` 3. **重新安装Flutter：**    如果上述步骤没有解决问题，您可以尝试重新安装Flutter。确保您按照Flutter的官方安装指南进行操作。    ```bash    git clone https://github.com/flutter/flutter.git -b stable --depth 1    export PATH="$PATH:`pwd`/flutter/bin"    ```    请确保在zsh配置文件中将上述 `export PATH` 行添加到永久环境变量中。 4. **检查zsh配置：**    确保您的zsh配置文件没有其他导致冲突的问题。有时，其他zsh配置或插件可能会影响到`$PATH`的设置。 如果您尝试了上述步骤仍然遇到问题，您可能需要仔细检查您的系统环境变量和zsh配置文件，以确保正确设置了Flutter的路径。

android

gradle

gradle版本列表：https://services.gradle.org/distributions/

常用命令

Gradlew的常用命令包括： 1. `./gradlew assembleRelease`：用于快速构建Release版本的App。 2. `./gradlew tasks --all`：用于查看所有任务。 3. `./gradlew :app:dependencies`：查看项目的依赖，包括哪些库。 4. `./gradlew -v`：查看Gradle、Groovy、Ant、JVM等的版本。 5. `./gradlew clean`：和clean project类似，用于清除构建文件夹。 6. `./gradlew build --info`：编译并打印日志。 7. `./gradlew installDebug`：编译并安装Debug包。 8. `./gradlew build --info --debug --stacktrace`：调试模式并打印堆栈信息。 9. 产看依赖关系：./gradlew app:dependencies --configuration releaseRuntimeClasspath 此外，还可以通过添加参数来执行特定任务，例如`./gradlew assembleDebug`用于编译并打De包。更多命令可以查阅相关文档或咨询专业人士。

案例

强制依赖版本

allprojects {     repositories {         google()         mavenCentral()     }     configurations.all {         resolutionStrategy { //    force 'androidx.lifecycle:lifecycle-common:2.5.1'             //                failOnVersionConflict()         }     } }

疑问

环境

jdk版本有几个地方可以设置？这几个地方的优先级？

疑问❓

gradle sync 为什么每次都执行

dart

mixin只作为声明

ct_user_mixin.dart CTUserMixin

ct_driver_addorder_mixin.dart ct_driver_addorder_mixin.dart

没有实现会报错吗

字典、工具

api文档：https://api.dart.dev/stable