Dart基础学习

Miketutu2025-12-22 8:09

Day-1 Dart中列表类型

List -- 上：

  1. 在尾部添加 -add

  2. 在尾部添加一个列表 - addAll（列表）

  3. 删除满足内容的第一个 - remove（内容）

  4. 删除最后一个 - removeLast（）

  5. 删除索引范围内数据 - removeRange(start,end)

    void main() {
    List students = ["张三","李四","王五"];

    /*

    • 在"尾部"添加 -- add
    • 在"尾部"添加一个列表 -- addAll
    • 删除满足内容的第一个 -- remove
    • 删除最后一个 -- removeLast()
    • 删除索引范围内数据 -- removeRange(start,end) end结束的索引不包含在范围内
    • */
      students.add("新同学");

    students.addAll(["同学2","同学1"]);
    students.remove("张三");
    students.removeLast();
    students.removeRange(0, 1);
    print(students);
    }

List -- 常用的操作方法和属性：

  1. 循环 - forEACH((item){})

    students.forEach((item) {
    print(item);
    });

  2. 是否都满足条件 - every

    // 是不是都以"王字开头"
    var flag = students.every((item){
    return item.toString().startsWith('王');
    });
    print(flag);

  3. 筛选出满足条件的数据 - where

    var newList = students.where((item){
    return item.toString().startsWith('王');
    }).toList();

  4. List的属性

    // List常用的一些属性 方法（）.属性
    print(students.length);
    print(students.last); // 列表的最后一个
    print(students.first); // 列表的第一个
    print(students.isEmpty); // 列表是否是空的

Dart中的字典类型 - Map
复制代码 
void main(List<String> args) {
  Map transMap = {"lunch":"午饭","morning":"早上" ,"hello":"你好"};
  print(transMap);
  // 通过英文找到对应中文的描述
  print(transMap["lunch"]); // 午饭

  transMap["hello"] = "你非常好";
  print(transMap["hello"]);
}
Dart中字典类型 - Map常用操作方法和属性

  1. 循环 - forEach

    // 字典里面有很多对应关系
    transMap.forEach((key,value) {
    print("key,value");
    });

  2. 在添加一个字典 - addAll

    // addAll 给当前字典在添加一个字典
    transMap.addAll({"afternoon":"下午"});
    print(transMap);

  3. 是否包含某个key - containsKey

    // containsKey判断字典中是否包含某个key
    print(transMap.containsKey("fine"));

  4. 删除某个Key - remove

  5. 清空字典 - clear

    // 清空字典
    transMap.clear();
    print(transMap);

Dart中的动态类型 - dynamic
定义：

Dart语言中，dynamic用来声明动态类型

特点：

允许变量运行时自由改变类型，同时绕过编译时的静态检查

语法：

dynamic 属性名 = 值

复制代码 
void main(List<String>args){
    dynamic free = "字符串";
    free = 1;
    free = [];
    free = false;
    free = {};
    // 类型变化 不会引起编译的检查
}
Dynamic和var的区别
  • dynamic：运行时可自由改变类型，无编译检查，方法和属性直接调用。
  • var：根据初始值进行推断类型，确定类型后类型确定，有编译检查，仅限推断的属性和方法
Dart的空安全机制：
定义：

在Dart语言中，通过编辑静态检查将运行时空指针提前暴露

特点：

将空指针异常从运行时提前至编译时，减少线上奔溃

常用空安全操作符：

|------|------|------------------------|---------------------------------------------|
| 操作符 | 符号 | 作用 | 示例 |
| 可空类型 | ? | 声明可空变量 | String? → 允许 String 或 null |
| 安全访问 | ?. | 对象为 null 时跳过操作，返回 null | user?.name → 若 user 为 null 则返回 null |
| 非空断言 | !. | 开发者保证变量非空（否则运行时崩溃） | name!.length → 断言 name 非空 |
| 空合并 | ?? | 左侧为 null 时返回右侧默认值 | name ?? "Guest" → name 为 null 时返回 "Guest" |

复制代码 
void main(List<String> args){
  String? username = null; // ？ 表示变量可以是null
  username?.startsWith("新"); // 安全访问
  // 客观判断
  // username = "张三";
  // 主观判断：开发者认为username一定不为null
  username!.startsWith("新");

  // 要保证别人一定能够显示用户名
  String displayName = username ?? "默认值";
  
}
Dart中常见算数运算符
定义：

Dart语言中，对数字进行加减乘除运算采用算数运算符

复制代码 
void main(List<String> args) {
  double item = 10.99;
  double allPrice = item * 4;
  double money = 100;
  double lastMoney = money - allPrice;
  double everyMoney = lastMoney / 4;
  // 整除
  // int everymoney = lastMoney ~/ 4;
  print(everyMoney);
}
Dart中常见赋值运算符
定义：

|-----|---------------------------|
| 运算符 | 作用 |
| = | 赋值操作 |
| += | 加等，a += b 相当于 a = a + b |
| -= | 减等，a -= b 相当于 a = a - b |
| *= | 乘等，a *= b 相当于 a = a * b |
| /= | 除等，a /= b 相当于 a = a / b |

复制代码 
// 赋值运算符
  int a= 1;
  a+=2; // a = a+ 2
  print(a);
  a -=1;
  print(a);
Dart中的常见比较运算符
定义：

在Dart语言中，对数值进行比较操作使用比较运算符

特点：

比较运算符的结果都是布尔类型

|-----|----------------|
| 运算符 | 作用 |
| == | 判断两个值是否相等 |
| != | 判断两个值是否不等 |
| > | 判断左侧值是否大于右侧值 |
| >= | 判断左侧值是否大于等于右侧值 |
| < | 判断左侧值是否小于右侧值 |
| <= | 判断左侧值是否小于等于右侧值 |

复制代码 
void main(List<String> args){
    int a = 1;
    int b =2;
    print(a == b);
    print(a != b);
    print(a > b);
    print(a >= b);
    print(a < b);
    print(a <= b);
}
Dart中的常见逻辑运算符
定义：

在Dart语言中，需要对boolean类型的值进行逻辑运算，需要使用逻辑运算符

|------|----------------------------------------|
| 运算符 | 作用 |
| && | 逻辑与，a && b，a 和 b 同时为 true 时结果为 true |
| || | 逻辑或，a || b，a 或 b 有一个为 true 时结果为 true |
| ! | 逻辑非，!a，对 a 的布尔值取反 |

Dart的流程控制
if分支语句：
定义：

在Dart语言中，if分支语句可以进行不同逻辑的判断和处理

|------|--------|
| if分支 | 作用 |
| 单分支 | 单个条件判断 |
| 双分支 | 两个条件判断 |
| 多分支 | 多个条件判断 |

复制代码 
void main(List<String> args) {
  int score = 61;
  // 单条件情况
  if(score > 60) {
    print("及格");
  }

  // 双分支
  bool isMarry = false;
  if(isMarry) {
    print("恭喜成家");
  } else {
    print("还没结婚");
  }

  // 多分支
  if(score > 80) {
    print("优秀");
  } else if(score >= 60){
    print("及格");
  } else {
    print("不及格");
  }
}
Dart中的三元运算符：
语法：

表达式（布尔值） ？结果1 ：结果2

复制代码 
print(59 >= 60 ? "及格" : "不及格");
Dart中的switch/case
定义：

在Dart语言中，如果分支条件很多，且条件是判断相等，可以使用switch case语句

语法：

switch(变量) {

case 值1：

逻辑1；

break；

default：

默认逻辑值；

复制代码 
void main(List<String> args) {
  int state = 100; // 1 代付款 2 待发货 3 待收货 4 待评价 5 未知状态
  
  switch (state) {
    case 1:
      print("待付款");
      break;
    case 2:
      print("待发货");
      break;
    case 3:
      print("待收货");
      break;
    case 4:
      print("待评价");
      break;
    default:
      print("未知状态");
  }
}
Dart中的循环语句 - while
定义：

在Dart语言中，循环主要使用while和for循环

while（条件）{

逻辑;

}

特点：

只要满足条件，括号中逻辑一直执行，想要执行可以使用break或者continue

注意：break是跳出整个while循环，continue是跳出当前迭代，进入下一次迭代

复制代码 
void main(List<String> args) {
  List foods = [
    "第一个包子",
    "第二个包子",
    "第三个包子",
    "第四个包子",
    "第五个包子", // 4
  ];
  
  int index = 0;
  while (index < foods.length) {
    if (index == 2) {
      // break; // break跳出整个循环
      index += 1;
      continue; // 跳出当前迭代
    }
    print(foods[index]);
    index += 1;
  }
  
  // 第一种场景 吃到第二个的时候 就已经吃饱了 跳出整个循环使用break;
}
Dart中的循环语句 - for
定义：

在Dart语言中，for循环可以对列表类型进行遍历

for循环语法：

for(int i =0; i < 10; i++){

逻辑；

}

注意：break是跳出整个while循环，continue是跳出当前迭代，进入下一次迭代

复制代码 
void main(List<String> args) {
  List foods = [
    "第一个包子",
    "第二个包子",  // 补全了缺失的部分
    "第三个包子",
    "第四个包子",
    "第五个包子",
  ];

  for (var i = 0; i < foods.length; i++) {
    // 吃两个吃饱了
    if (i == 2) {
      // break; 跳出整个循环
      continue; // 跳出当前迭代
    }
    print(foods[i]);  // 修正了：printf → print
  }
}
Dart函数：
定义：

在Dart中，函数是代码组合和复用的核心单元。

要素：

  • 返回类型
  • 函数名
  • 参数
  • 函数体
复制代码 
int add (int a, int b){
  return a+ b;
}
Dart中的函数的返回值：

分类：函数返回值分为有返回值和无返回值

有返回值：具体类型 函数名称（）{}

无返回值：void 函数名称（）{}

返回值可以省略，Dart会自动推断类型为dynamic

复制代码 
void main (List<String> args){
  print(add(1, 2, 3));
  test();
}

// 返回类型 函数名称 参数 函数体
int add(int a,int b, int c){
  return a+ b  + c;
}

void test() {
  print("测试无返回值数据");
}
函数的参数 - 必传参数
分类：

函数的参数分为：必传参数 可选位置参数 可选命名参数

特点：

必传参数不能为空

函数的参数 - 可选位置参数

特点：

可选位置参数必须位于必传参数后面，采用中括号包裹

语法：

函数名（String a , [String ? b ,....]）传递时按照顺序传递

使用场景：

参数少且顺序固定

默认值：可选参数可以设置默认值

复制代码 
// 可选位置参数(按照顺序)
String combine(String a, [String? b = "b", String? c = "c"]) {
  return a + (b ?? "") + (c ?? "");
}
函数的参数 - 可选命名参数
特点：

可选命名参数必位于必选参数后面，采用大括号包裹

语法：

函数名(String a,{ String ? b, ...})，传递时按照 参数名：值的方式进行传递，无需关注顺序

使用场景

参数多且需明确含义时

复制代码 
// 可选命名参数（不用按照顺序）
void showPerson (String username,{int? age = 18,String? sex = '女'}) {
  print('姓名：$username,年龄：$age,性别：$sex');
}

不需要按照顺序，但是要按照参数名

匿名函数：
特点：

可以声明一个没有名称的函数赋值给变量，进行调用。

语法：

Function 变量名 = （）{}；

注意：

函数的类似使用Function来声明

复制代码 
void main(List<String> args) {
  // test();
  onTest(test);
}
// 匿名函数赋值给test变量
Function test = () {
  print("测试数据");
};

void onTest(Function callback) {
  callback();
}
箭头函数
特点：

但函数体只有一行代码时，可以使用箭头函数编写

语法：

函数名 () => 代码逻辑

注意：

可以使用return 关键字

Dart中的类 - class
定义：

Dart语言中，类（class）是面向对象编程的核心，类包含属性和方法来定义对象的行为和状态

需求：

定义一个Person类，属性包括姓名，年龄，性别，包括学习的方法

语法：

class Person {属性 方法}

实例化对象：

Person 变量 = Person();

属性和方法

变量.属性/方法

复制代码 
void main(List<String> args) {
  Person p = Person();
  p.name = '程梦雨';
  p.age = 31;
  p.Study();
}

class Person {
  String name = ""; // 姓名
  int age = 0; // 年龄
  String sex = "女";

  void Study() {
    print("$name在学习");
  }
}

关键字：class

Dart中的类 - 默认构造函数
定义：

实例化对象的时候，使用构造函数直接给对象中的属性赋值

常见分类：

默认构造函数，命名构造函数，构造函数的语法糖

定义语法：
复制代码 
class 类名 {
  类名（可选命名参数）{
    
  }
}
实例化语法：

Person p = new Person（属性：值）

复制代码 
void main(List<String> args) {
  Person p = Person(name: "程梦雨",age: 31,sex: "女");
  // p.name = '程梦雨';
  // p.age = 31;
  p.Study();
}

class Person {
  String? name = ""; // 姓名
  int? age = 0; // 年龄
  String? sex = "女";
  // 默认构造函数
  Person({String? name,int? age,String? sex}){
    this.name = name;
    this.age = age;
    this.sex = sex;
  }
  void Study() {
    print("$name在学习");
  }
}
Dart中的构造函数 - 命名构造函数
定义：

构造函数可以采用命名的方式，返回一个实例化对象

定义语法：

class 类名 {

类名.构造函数名（可选命名参数） {

}

}

实例化语法：

Pseron p = Person.构造函数名（属性：值）

复制代码 
void main(List<String> args) {
  Person pp = Person.createPserosn(name: "Mike",age: 30);
  pp.Study();
}
Person.createPserosn({String? name,int? age,String? sex}){
    this.name = name;
    this.age = age;
    this.sex = sex;
  }

默认构造函数和命名构造函数可同时存在

Dart中的构造函数 - 构造函数语法糖
定义:

同名构造函数和命名构造函数都支持简写方法

语法：
复制代码 
class 类名 {
  类名（this.属性1，this.属性2）;
  
}

void main(List<String> args) {
  Person p = Person(name: "程梦雨", age: 31, sex: "女");
  p.Study();
  Person pp = Person.createPerson(name: "Mike", age: 30);
  pp.Study();
}

class Person {
  String? name = ""; // 姓名
  int? age = 0; // 年龄
  String? sex = "女";
  // 语法糖(不要求顺序)
  Person({this.age,this.name,this.sex});
  Person.createPerson({this.age,this.name,this.sex});
  void Study() {
    print("$name在学习");
  }
}
Dart中类的公有属性和私有属性
公有属性：

提供自身或者其他外部文件和类使用的属性和方法

私有属性：

仅供自身使用的属性和方法

语法：

私有属性以下划线开头，如_name ，其余均为公有属性

Dart中类的继承：
定义：

继承是拥有父类的属性和方法

特点：

Dart属于单继承，一个类只能拥有一个直接父类，子类拥有父类所有的属性和方法

语法：

class 类名 extends 父类

重写：

子类可通过@override注解重写父类方法，扩展其行为

注意：

子类不会继承父类构造函数，子类必须通过super关键字调用父类构造函数确保父类正确初始化

super语法：

子类构造函数（可选命名参数）：super（{参数}）

复制代码 
void main(List<String> args) {
  Child c = Child(name: "程梦雨", age: 31);
  c.study();
}

// 父类
class Parent {
  String? name;
  int? age;

  Parent({this.name, this.age});

  void study() {
    print("父类-$name在学习");
  }
}

// 子类继承父类
class Child extends Parent {
  // 先声明子类构造函数
  Child({String? name, int? age}) : super(name: name, age: age);
  @override
  void study() {
    // TODO: implement study
    // super.study(); // 先调用父类的方法
    print("子类$name在学习");
  }
}
Dart中的类的多态 - 继承和方法重写
定义：

Dart中的类的是指同一操作作用于不同的对象，可以产生不同的执行效果

场景：

微信和支付宝都遵循同样支付接口，实现逻辑不同，即同一个支付操作拥有不同的支付效果

实现方式：

  1. 继承和方法重写

  2. 抽象类和接口

    void main(List<String> args) {
    PayBase wx = WxPay();
    wx.pay();
    PayBase zf = AliPay();
    zf.pay();
    }
    class PayBase{
    void pay(){
    print("基础支付");
    }
    }

    class WxPay extends PayBase{
    @override
    void pay() {
    // super.pay();
    print("这是微信支付");
    }
    }

    class AliPay extends PayBase{
    @override
    void pay(){
    // super.pay();
    print("只是支付宝支付");
    }
    }

Dart中类的多态 - 抽象类和接口实现
定义：

使用abstract关键字声明一个抽象类（没有实现体）

方法：

使用implements关键字继承并实现抽象类

复制代码 
void main(List<String> args) {
  PayBase wx = WxPay();
  wx.pay();
}

abstract class PayBase {
  void pay(); // 抽象类是不具体实现
}

// 微信支付
class WxPay implements PayBase {
  @override
  void pay() {
    print("微信支付");
  }
}
Dart中类的混入
定义：

Dart允许在不使用传统继承的情况下，向类中添加新的功能

方式：

使用mixin关键字定义一个对象

方式：

使用with关键字将定义的对象混入到当前对象

特点：

一个类支持with多个mixin，调用优先级遵循"后来居上"原则，即后混入的会覆盖先混入的同名的方法

Dart中泛型：
定义：

Dart允许使用类型参数，限定类型的同时又让类型更加灵活，让代码更加健壮和维护性更强

常见分类：

  • 泛型集合

  • 泛型方法

  • 泛型类

    void main(List<String> args) {

    复制代码 
    // 列表泛型
List<String> list = [];
list.add("value");

Map<String,int> map = {};
map["a"] = 1;

getValue<String>("1");

Student<String> s= Student();
s.name =  '程';

    }

    // 函数中的方法
    T getValue<T> (T value) {
    return value;
    }

    void printList<T>(List<T> list) {

    }
    // 类定义泛型的接收
    class Student<T> {
    T? name;
    }

Dart的异步编程 - 事件循环
介绍：

Dart是单线程语言，即同时只能做一件事，遇到耗时任务就会造成程序阻塞，此时需要异步编程。

定义：

Dart采用单线程 + 事件循环的机制完成耗时任务的处理

事件循环：
微任务对列：

Future.microtask()

事件对列：

Future，Future.delayed()，I/O操作（文件，网络）等

Future的基本使用：
介绍：

Future代表一个异步操作的最终结果

状态：

Uncompleted（等待）Completed with a value(成功) Completedd with a error(失败)

创建：

Future(() {})

执行成功：

不抛出异常 - 成功状态 - then（（）{}）

执行失败：

throw Exception（）- 失败状态 -catchError（（）{}）

复制代码 
void main(List<String> args) {

  Future f = Future((){
    return "Hello Flutter";
  //     没有抛出异常
    throw Exception();
  });

  // then中接收成功状态
  f.then((value) {
    print(value);
  });
  // 抛出异常
  f.catchError((onError) {
    print("出现错误");
  });
}
Future的链式调用：
介绍：

Future可以通过链式的方式连续得到异步的结果

语法：

通过Future().then() 拿到执行成功的结果

语法：

通过Future.catchError 拿到执行失败的结果

注意：

在上一个then返回对象会在下一个then中接收

Dart中异步编程 - async和await
介绍：

除了通过then/catchError方式，还可以通过async/await来实现异步编程

特点：

await总是等到后面的Future执行成功，才执行下方逻辑，async必须搭配awit使用

语法：
复制代码 
void main(List<String> args) {
  test();
}

void test() async {
  try {
    String result =  await Future(() {
        return '测试';
        // throw Exception();
      });
      print(result);
      // await Future.delayed(Duration(seconds: 3));
      // await下方的逻辑，永远是Future执行成功之后执行的
      print("执行成功逻辑");
  } catch (e) {
    print("异步请求出现异常");
  }
}

Flutter框架核心

相关推荐
JAVA+C语言2 分钟前
Java ThreadLocal 的原理
java·开发语言·python
精神小伙就是猛15 分钟前
C# Task/ThreadPool async/await对比Golang GMP
开发语言·golang·c#
办公自动化软件定制化开发python22 分钟前
基于PyQt5开发的文件智能查找工具，开源思路+完整实现，解决办公文件检索痛点
开发语言·qt
工程师00722 分钟前
C#状态机
开发语言·c#·状态模式·状态机
cngm11030 分钟前
记录两个网卡同时访问两个网段的调试方法route print
服务器·网络·windows
古城小栈33 分钟前
Tokio：Rust 异步界的 “霸主”
开发语言·后端·rust
_OP_CHEN36 分钟前
【从零开始的Qt开发指南】（二十）Qt 多线程深度实战指南：从基础 API 到线程安全，带你实现高效并发应用
开发语言·c++·qt·安全·线程·前端开发·线程安全
爱喝水的鱼丶39 分钟前
SAP-ABAP:SAP性能侦探：STAD事务码的深度解析与应用实战
开发语言·数据库·学习·sap·abap
while(1){yan}43 分钟前
SpringAOP
java·开发语言·spring boot·spring·aop
专注于大数据技术栈43 分钟前
java学习--Collection
java·开发语言·学习
热门推荐
01GitHub 镜像站点02Labelme从安装到标注：零基础完整指南03网站改了域名，如何查找？04Linux下V2Ray安装配置指南05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06Claude Code 2.1.2 升级报错？别折腾了，一行命令搞定07【踩坑笔记】50系显卡适配的 PyTorch 安装082025-04-03 Latex学习1——本地配置Latex + VScode环境09CentOS的ISO镜像下载10Netlify 的深度解析及使用指南