1 Dart初识

本教程为本人上课笔记

从markdown导入进来，部分代码的缩进不对

若要阅读代码，可将代码复制到idea中，自动调整缩进

本教程使用的 Dart 版本为：2.17.5

1.1 Dart介绍

Dart是谷歌开发的计算机语言，可以用于Web、服务器、移动应用和物联网等领域。

Dart诞生于2011年，是Flutter框架所依赖的语言

1.2 Dart安装-windows

要在本地开发Dart需要先安装Dart SDK

访问官网：https://dart.dev/get-dart

使用 https://gekorm.com/dart-windows/ 选择稳定版的dart SDK安装，选择默认路径

备注：安装之前，请将360等安全软件关闭

1.3 安装Dart开发工具

• 常用工具：IDEA，WebStorm，VSCode等均可
• 使用VSCode:

第一步、安装插件 dart，如图

第二步、安装插件 code runner

安装插件 code runner 用于运行dart源码，方法同上

第三步、运行dart源码，如图

• 使用 IDEA

第一步，安装插件 dart

第二步，创建dart项目

1.4 基本入门

• 1) 入口方法

//带返回值
void main() {
  print('Hello Dart');
}
//不带返回值
main(){
  print('Hello Dart');
}
//带外部参数
void main(List arguments) {
  print('Hello ${arguments}');
}

对于带外部参数，按如下执行

• 2) 注释

注释类似于Java，分为

单行注释 -> //

代码块注释 -> /* 代码块 */

• 3) 变量

dart是一个强大的脚本类语言

可以类Python一样，不预先定义变量类型，系统自定推断

可以类Java一样，事先声明变量类型

var str1 = "Cheng Da"; //不预先定义变量类型
String str2 = "Dart";
int str3 = 123;
print(str1);
print(str2);
print(str3);

如果将变量声明为var，后面赋值类型不匹配，依然会报错

void main(){
  var str1 = "Cheng Da";
  str1 = 1234;
  print(str1);
}

• 4) 命名规则

名称只能由数字、字母、下划线和美元符号($)组成

名称一般以小写字母开头

名称不能以数字开头

名称不能是保留字或关键字

名称区分大小写，username 与userName不是同一个

名称要见名知意

• 5) 常量

使用 final 和 const 修饰符

const 值不变，一开始就赋值

final 可以开始不赋值，可以在运行过程中赋值一次

void main(){
    //const常量
    const PI1 = 3.14;
    print(PI1);
    //final常量
    final PI2; 
    PI2 = 3.1415926; 
    print(PI2); //使用懒加载，只有在要调用时才会对常量赋值
}

2 数据类型

2.1 常用数据类型

int: 整型

double: 浮点型

String: 字符串

Boolean: 布尔

List: 数组/列表

Maps: 字典

2.2 String类型

• 1) 定义的几种方式

//用弱类型
var str1 = "123";
//用强类型
String str2 = "123";
//用三单号定义多行字符串
String str3 = '''Cheng
Da
QQ: 525037668
''';

• 2) 字符串的常见操作

//拼接字符串
String str1 = "Hello";
String str2 = "Dart";
print("${str1} ${str2}");
String str3 = str1 + " : " + str2;
print(str3);
String str4 = "${str1} --- ${str2}";
print(str4);
//几个重要的属性和操作
print("是否为空: ${str3.isEmpty}");
print("字符串长度: ${str3.length}");
print("是否相同: ${str3.compareTo(str1)}");
print("是否含有指定字符串: ${str3.contains("Dart")}");
print("是否以指定字符串结尾: ${str3.endsWith("Dart")}");
print("找出特定字符串第一次出现的索引: ${str3.indexOf("Dart")}");
print("找出特定字符串最后一次出现的索引: ${str3.lastIndexOf("Dart")}");
print("用特定字符串替换当中的某字符串，全部替换: ${str3.replaceAll("Dart", "dart")}");
print("用特定字符串分割字符串为数组: ${str3.split(" : ")}");
print("截取字符串: ${str3.substring(0,5)}"); //提取出 Hello
print("全部转小写: ${str3.toLowerCase()}");

2.3 数值类型

• 1) 定义

//类型
int a = 100; //整型
double b = 100.12; //浮点型
print("double b 是浮点型 ${b}");
var d = 3.14; //推断 d 为double
print("var d 推断是double型 ${d}");
//运算符
print("整型与浮点型运算后为浮点型 r1 = ${r1}");
var r2 = a + a;
print("整型与整型运算后为整型型 r2 = ${r2}");
var r3 = b * d;
print("浮点型与浮点型运算后为浮点型 r3 = ${r3}");

• 2)常见操作

double a = 3.14;
print("a 的绝对值 ${a.abs()}");
print("不小于 a 的最小整数 ${a.ceil()}");
print("不大于 a 的最大整数 ${a.floor()}");
print("最接近 a 的整数 ${a.round()}");
print("a 转为整数 ${a.toInt()}");
print("a 转为字符串 ${a.toString()}");
print("a 丢弃小数位后生成整数 ${a.truncate()}");

2.4 布尔类型

• 1) 定义

//定义bool类型的变量
bool flag1 = true;
bool flag2 = false;
var flag3 = true;

• 2) 条件判断

if (flag1){
    print("真");
}else{
    print("假");
}
if("有钱".compareTo("多金") == 0){
    print("有钱 == 多金");
}else{
    print("有钱 != 多金");
}

2.5 数组类型

不限定元素个数

• 1) 定义

var list1 = ["Cheng","Da"];
var list2 = [];
var list3 = [] //定义 list3 中的元素只能是字符串
list2.add("Hello");
list2.add("Dart");
print("list1 推断是数组 ${list1}");
print("list2 定义是数组 ${list2}");
print("list2 数组的长度 ${list2.length}");
print("list2 中提取索引为0的元素 ${list2[0]}");

• 2) 常见方法

var list1 = ["Cheng","Da","Hello","Dart"];
print("list1数组元素个数: ${list1.length}");
print("list1数组第一个元素: ${list1.first}");
print("list1数组最后一个元素: ${list1.last}");
print("list1是否为空: ${list1.isEmpty}");
print("list1是否不为空: ${list1.isNotEmpty}");
print("Dart所在的索引位置: ${list1.indexOf("Dart")}");
print("list1中是否包含flutter: ${list1.contains("flutter")}");
print("list1中索引3位置的元素是: ${list1.elementAt(3)}");
print("list1转为Map: ${list1.asMap()}");
print("list1插入元素: ${list1.insert(2,"Haha")}"); //在2个位置插入
print("list1转字符串: ${list1.join(',')}"); //转字符串以逗号分割
print("字符串转list: ${'Hello,Dart'.split(',')}");

2.6 Map类型

• 1) 定义

//第一种方式
var person = {
    "name": "云计算程老师",
    "age": "38",
    "work": ["老师","程序员"]
};
print(person); //打印出封装对象
print(person["name"]); //取出对象的某个属性

//第二种方式
var person2 = new Map();
person2["name"] = "Dart";
person2["age"] = 10;
person2["work"] = ["Web","Script"];
print(person2); //打印出封装对象
print(person2["work"]);

• 2) 常见方法

var person = {
    "name": "云计算程老师",
    "age": "38",
    "work": ["老师","程序员"]
};
print("数据对象打印: ${person}");
print("person中键值对个数: ${person.length}");
print("person中的键值对是否为空: ${person.isEmpty}");
print("person中所有的键: ${person.keys}");
print("person中所有的值: ${person.values}");
print("person中是否包含age键值: ${person.containsKey("age")}");
print("person中移除age键值: ${person.remove("age")}");
print("数据对象打印: ${person}");

• 3) 判断类型

使用 is 关键字判断类型

var str = "Hello Dart";
if(str is String){
    print("String类型");
}else if(str is int){
    print("int类型");
}else{
    print("其他类型");
}

3 运算符

3.1 运算符分类

• 1) 算术运算符

+ - * / ~/取整 %取余

var a = 13;
var b = 5;
print("a + b = ${a+b}");
print("a - b = ${a-b}");
print("a * b = ${a*b}");
print("a / b = ${a/b}");
print("a ~/ b = ${a~/b}");
print("a % b = ${a%b}");

• 2) 关系运算符

== != > < >= <=

• 3) 逻辑运算符

! && ||

• 4) 赋值运算符

基础赋值运算符 = ??=

复合赋值运算符 += -= *= /= %= ~/=

int a1 = 10;
a1 ??= 20; //当a1未赋值时，a1赋值为20
print("a1 = ${a1}"); //结果为 10

• 5) 三目运算符

var result = a 关系运算符 b ? 表达式1 : 表达式2

如果 a 关系运算符 b 结果为 true, result = 表达式1

如果 a 关系运算符 b 结果为false, result = 表达式2

int a = 10;
int b = 5;
var result1 = a > b ? a+10 : b*5;
print("result = ${result1}"); //结果 result = 20
int score = 65;
var result2 = score >=90 ? "A": (score>=80 ? "B":"C")
print("result = ${result2}")

• 6) 条件运算符

var score = 60;
if(score>=90){
    print("A");
}else if(score >=80){
    print("B");
}else{
    print("C");
}
var n = score~/10;
switch(n){
    case 9:
        print("A");
        break;
    case 8:
        print("B");
        break;
    default:
        print("C");
        break;
}

3.2 类型转换

• 1) 数值型和字符串类型的转化

转String类型 -> toString()

转数值类型 -> parse()

String str1="123";
var mynum1=int.parse(str1);
if(mynum1 is int){
    print("字符串转整数");
}else{
    print("字符串未转整数");
}
String str2="3.14";
var mynum2=double.parse(str2);
if(mynum2 is doube){
    print("字符串转浮点数");
}else{
    print("字符串未转浮点数");
}
var mynum3 = 3.14;
var str3=mynum3.toString();
if(str3 is String){
    print("浮点数转字符串");
}else{
    print("浮点数未转字符串");
}

• 2) 类型转化存在异常会报错

String str1="123";
try{
    var mynum1=int.parse(str1);
    if(mynum1 is int){
      print("字符串转整数");
    }else{
       print("字符串未转整数");
    }
}catch(err){
   print("类型转化出错");
}

• 3) 其他类型和布尔类型转化

//如果数值为空，转为true
var mynum4=0/0;
var str4=mynum4.isNaN ? true:false;
print(str4);

• 4) Json与List互转

//Json转List
import 'dart:convert';
void main(){
    String jsonStr = '[{"id":"1","name":"张三"},{"id":"2","name":"李四"}]';
    List list = json.decode(jsonStr);
    print(list);
}

//List转Json
import 'dart:convert';
void main(){
    List list = [{"id":"1","name":"张三"},{"id":"2","name":"李四"}];
    String jsonStr = json.encode(list);
    print(jsonStr);
}

• 5) Map与Json互转

//Json转Map
import 'dart:convert';
void main(){
    String jsonStr = '{"id":"1","name":"张三"}';
    Map map = json.decode(jsonStr);
    print('id: ${map["id"]}');
    print('name: ${map["name"]}');
}

//Map转Json
import 'dart:convert';
void main(){
    Map map = {"id":"1","name":"张三"};
    String jsonStr = json.encode(map);
    print(jsonStr);
}

3.3 循环运算

• 1) for循环

var sum=0;
for(int i=1;i<=10;i++){
    sum=sum+i;
}
print(sum);
sum=0;
for(int i=0;i<=10;i+=2){
    sum=sum+i;
}
print(sum);
List list = [{"id":"1","name":"张三"},{"id":"2","name":"李四"}];
for(int i=0;i

• 2) while

List news = [
  {
    "type":"民生",
    "list":[
      {"title":"新冠结束","content":"终于可以出游了"},
      {"title":"国家发钱","content":"快去领钱"}
    ]
  },
  {
    "type":"体育",
    "list":[
      {"title":"国足挺进2026年世界杯","content":"我们出线啦"},
      {"title":"XX团队WCG夺冠","content":"不感兴趣"}
    ]
  }
];
int i=0;
while(i

• 3) do while

void main(){
List news = [
  {
    "type":"民生",
    "list":[
      {"title":"新冠结束","content":"终于可以出游了"},
      {"title":"国家发钱","content":"快去领钱"}
    ]
  },
  {
    "type":"体育",
    "list":[
      {"title":"国足挺进2026年世界杯","content":"我们出线啦"},
      {"title":"XX团队WCG夺冠","content":"不感兴趣"}
    ]
  }
];
int i=0;
do{
    Map mapType = news[i];
    print('type: ${mapType["type"]}');
    print("--------");
    int j=0;
    do{
        Map mapNews = mapType["list"][j];
        print('title: ${mapNews["title"]} content: ${mapNews["content"]} ');
        j++;
    }while(j

• 4) break与continue

break 跳出当前循环，只能跳出一层循环，如果存在多层循环，在外层循环需要再判断是否跳出

continue 进入下一次循环

3.4 set

• 1) set

集合数据类型，不能存在重复数据

//Set对象初始化
var s1 = {};
s1.add("Hello");
s1.add("Dart");
s1.add("Hello");
print(s1); //打印出 ('Hello','Dart')
print(s1.toList()); //集合转数组
//使用set实现列表去重
List list = ['Hello','Dart','Hello'];
var s2 = list.toSet();
print(s1.toList()); //列出去重

• 2) 循环方法

List list = ['Hello','Dart','Hello'];
//迭代
for(var item in list){
    print(item);
}
list.forEach((value){
    print(value);
});
//迭代产生一个新的数组
var newList1 = list.map((value){
    return "${value}-new"; //每一个元素拼接 new
});
print(newList1.toList());
//过滤出符合要求的元素并生成一个新数组
var newList2 = list.where((value){
    return value.startsWith('H'); //找出list中以H开头的元素
});
print(newList2.toList());
//检查数组中是否含有符合条件的元素，是就返回true，否则返回false
var f1 = list.any((value){
    return value.startsWith('H');
});
print(f1); //这是true
//检查数组中是否每个元素都符合过滤条件，是就返回true，否则返回false
var f2 = list.every((value){
    return value.startsWith('H');
});
print(f2); //这里是false
//循环set
var s1 = {'1','2','3'};
s.forEach((value){
    print(value); 
});
//循环map
Map person = {
    'id':'1',
    'name':'张三'
};
person.forEach((key,value){
    print("${key}:${value}");
});

4 自定义方法

4.1 格式

返回类型 方法名称 (参数类型 参数1,参数类型 参数2,...参数类型 参数n){

方法体;

return 返回值;

}

可以在方法内再定义方法

void main(){
  String getScore(double score){
    String result = "";
    if(score >= 90){
      result = 'A';
    }else if(score>=80){
      result = 'B';
    }else if(score >=60){
      result = "C";
    }else{
      result = 'D';
    }
    return result;
  }
  print(getScore(75.5));
}
void main(){
  print(testFunc(3.14));
}
String testFunc(var object){

  void prinValue(var value){
    print(value);
  }
//这个内置函数只能当前函数体内调用
  prinValue(object);
  return object.toString();
}

4.2 可选参数

String testFunc(String param1, [var param2]){
//param2为可选参数
  if(param2!=null){
    return "${param1}---${param2}";
  }
  return "${param1}";
}
print(testFunc("Hello","Dart"));
print(testFunc("Hello"));
//打印结果
Hello---Dart
Hello

4.3 默认参数

String testFunc(String param1, {var param2,var param3="Flutter"}){
//param2为可选参数
  if(param2!=null){
    return "${param1}---${param2}---${param3}";
  }
   return "${param1}---${param3}";
}
print(testFunc("Hello"));
print(testFunc("Hello",param2: "Dart",param3: "Web"));
print(testFunc("Hello",param3: "Web"));

4.4 方法作为参数

void func1(){
    print("func1");
}
void func2(var func){
    func();
}
func2(func1); //将方法作为参数

4.5 箭头函数

List list1 = ['Hello','Dart','Flutter'];
list1.forEach((value)=>print(value)); //箭头函数体中只能运行一行代码
//或者这样
list1.forEach((value)=>{
print(value)
});
List list2 = [90,80,80,45]; //按成绩生成最后所在评级，A B C D
var score2 = list2.map((value){
  if(value >= 90){
    eturn 'A';
  }else if(value >= 80){
    return 'B';
  }else if(value >= 60){
    return 'C';
  }else{
    return 'D';
  }
});
print(score2.toList());
//使用箭头函数实现
List list3 = [90,80,80,45]; //按成绩生成最后所在评级，A B C D
var score3 = list3.map((value)=>value>=90?'A':(value>=80?'B':(value>=60?'C':'D')));
print(score3.toList());
//打印结果
[A, B, B, D]

4.6 自执行方法

void main() {
    ((){
        print("我是自执行方法");
    })();
}
//运行main函数就会运行该方法，不用对函数进行调用，一般用于程序的初始化

4.7 递归函数

void main() {
  var sum=1;
  int func(int n){
    sum = sum * n;
    if(n!=1){
      func(n-1);
    }
    return sum;
  }
  func(5);
  print(sum);
}

void main() {
  int func(int n){
    if(n==1){
      return 1;
    }
    return n+func(n-1);
  }
  print(func(100));
}

4.8 闭包

全局变量的特点: 全局变量常驻内存，全局变量会污染全局

局部变量的特点: 不常驻内存会被垃圾机制回收，不会污染内存

要实现的效果：常驻内存，不污染全局，通过闭包解决

void main() {
  func(){
    var a=1;
    return (){
      a++;
      print(a);
    };
  }
  var f = func();
  f();
  f();
  f();
}

5 类与对象

Dart是一门使用类和单继承的面向对象语言，所有的对象都是类的实例，并且所有的类都是Object的子类

5.1 创建类

class Person {
  String id = '1';
  String name = 'zhangsan';
  Map getInfo() {
    Map map = {};
    map["id"] = this.id;
    map["name"] = this.name;
    return map;
  }
  void setId(String id){
    this.id = id;
  }
  void setName(String name){
    this.name = name;
  }
  String getName(){
    return this.name;
  }
  String getId(){
    return this.Id;
  }
//默认构造函数
  Person(){
    print("初始化Person对象");
  }
  Person(String id, String name){
    this.id = id;
    this.name = name;
    print("初始化Person对象, ${this.name}");
  }
//构建对象也可以简写
//Person(this.id, this.name);
}
void main() {
  Person p = new Person();
  print(p.getInfo());
}

5.2 命名构造函数

class Person {
String id = '1';
String name = 'zhangsan';
Map getInfo() {
Map map = {};
map["id"] = this.id;
map["name"] = this.name;
return map;
}
void setId(String id){
this.id = id;
}
void setName(String name){
this.name = name;
}
String getName(){
return this.name;
}
String getId(){
return this.Id;
}
//命名构造函数
Person.create(String id, String name){
this.id = id;
this.name = name;
print("已通过命名构造函数初始化实例");
}
}
void main() {
Person p = new Person.create('1001','Tony'); //通过命名构造函数实例化对象
print(p.getInfo());
}

将类抽离为文件

//将 Person 保存为一个文件，在lib目录下

import 'lib/Person.dart';
void main() {
Person p = new Person.create('1001','Tony'); //通过命名构造函数实例化对象
print(p.getInfo());
}

5.3 私有属性和方法

class Person {
String _id = '1'; //设置私有属性
String _name = 'zhangsan'; //设置私有属性
Map getInfo() {
Map map = {};
map["id"] = this._id;
map["name"] = this._name;
this._init(); //在公有方法中调用私有方法
return map;
}
void setId(String id){
this._id = id;
}
void setName(String name){
this._name = name;
}
String getName(){
return this._name;
}
String getId(){
return this._id;
}
//命名构造函数
Person.create(String id, String name){
this.id = id;
this.name = name;
print("已通过命名构造函数初始化实例");
}
//私有方法
void _init(){
print("这是私有方法");
}
}

5.4 get与set修饰符

class Person {
String _id = '1'; //设置私有属性
String _name = 'zhangsan'; //设置私有属性
Map getInfo() {
Map map = {};
map["id"] = this._id;
map["name"] = this._name;
return map;
}
Person.create(String id, String name){
this.id = id;
this.name = name;
print("已通过命名构造函数初始化实例");
}
//get方法
get getId{
return this._id;
}
get getName{
return this._name;
}
//set方法
set setId(value){
this._id = value;
}
set setName(value){
this._name = value;
}
}
import 'lib/Person.dart';
void main() {
Person p = new Person.create('1001','Tony'); //通过命名构造函数实例化对象
print(p.getInfo());
p.setId = '1002'; //设置属性
p.setName = 'Tom';
print(p.getId); //获取属性值
print(p.getName);
}

5.5 构造函数之前初始化操作

// lib/Person.dart
class Person {
String _id = '1'; //设置私有属性
String _name = 'zhangsan'; //设置私有属性
Person():_id='1001',_name='Tony'{ 
//先赋值，之后执行构造函数
print('已使用默认值进行实例初始化');
}
Map getInfo() {
Map map = {};
map["id"] = this._id;
map["name"] = this._name;
return map;
}
}
import 'lib/Person.dart';
void main() {
Person p = new Person();
print(p.getInfo()); //打印结果 {id: 1001, name: Tony}
}

5.6 静态成员

class Person{
static String _id = '1'; //设置静态私有属性
static String _name = 'zhangsan'; //设置静态私有属性
static Map getInfo() { //静态方法不能访问非静态成员
Map map = {};
map["id"] = _id;
map["name"] = _name;
return map;
}
void printInfo(){ //非静态方法可以访问静态成员
print(_id);
print(_name);
}
}
import 'lib/Person.dart';
void main() {
print(Person.getInfo()); //使用类名直接访问
new Person().printInfo();
}

5.7 类型转换

import 'lib/Person.dart';
void main() {
Object obj = new Person();
print((obj as Person).getInfo()) //使用 as 将Object类型转为Person类型
}

5.8 级联操作

class Person {
String _id = '1'; //设置私有属性
String _name = 'zhangsan'; //设置私有属性
Map getInfo() {
Map map = {};
map["id"] = this._id;
map["name"] = this._name;
return map;
}
set setId(value){
this._id = value;
}
set setName(value){
this._name = value;
}
}
import 'lib/Person.dart';
void main() {
Person p = new Person();
p..setId='1001'
..setName='Tony'; //级联操作，一次进行多项赋值
print(p.getInfo());
}

5.9 继承

//使用extends实现继承
class Person {
String _id = '1'; 
String _name = 'zhangsan';
Map getInfo() {
Map map = {};
map["id"] = this._id;
map["name"] = this._name;
return map;
}
Person(this._id,this._name);
set setId(value){
this._id = value;
}
set setName(value){
this._name = value;
}
get getId{
return this._id;
}
get getName{
return this._name;
}
}
class Student extends Person{
String _xid = '';
int _score = 0;
//子类的构造函数
Student(String id,String name,String xid, int score) : super(id,name){
this._xid = xid;
this._score = score;
}
Map getScore(){
Map map = {};
map['xid']=this._xid;
map['name']=this.getName;
map['score']=this._score;
return map;
}
}
void main() {
Student stu = Student('1001','Tony','20221001',89);
print(stu.getInfo());
print(stu.getScore());
}
//继承使用命名构造函数
class Person {
String _id = '1'; 
String _name = 'zhangsan';
Map getInfo() {
Map map = {};
map["id"] = this._id;
map["name"] = this._name;
return map;
}
Person.create(this._id,this._name);
set setId(value){
this._id = value;
}
set setName(value){
this._name = value;
}
get getId{
return this._id;
}
get getName{
return this._name;
}
}
class Student extends Person{
String _xid = '';
int _score = 0;
//子类的构造函数
Student(String id,String name,String xid, int score) : super.create(id,name){
this._xid = xid;
this._score = score;
}
Map getScore(){
Map map = {};
map['xid']=this._xid;
map['name']=this.getName;
map['score']=this._score;
return map;
}
}
void main() {
Student stu = Student('1001','Tony','20221001',89);
print(stu.getInfo());
print(stu.getScore());
}
//子类重新父类的方法
class Student extends Person{
String _xid = '';
int _score = 0;
//子类的构造函数
Student(String id,String name,String xid, int score) : super.create(id,name){
this._xid = xid;
this._score = score;
}
Map getScore(){
Map map = {};
map['xid']=this._xid;
map['name']=this.getName;
map['score']=this._score;
return map;
}
//重新父类方法
@override
Map getInfo(){ 
print("这是重写的方法");
return super.getInfo(); //子类调用父类的方法
}
}
void main() {
Student stu = Student('1001','Tony','20221001',89);
print(stu.getInfo());
}

6 抽象类与接口

6.1 抽象类

使用 abstract 定义 抽象类，同java一致

//定义与使用 抽象类 抽象方法
abstract class Human{
void eat();
void play();
void sleep();
}
class PrimitiveMan extends Human{
@override
void eat(){
print('吃生肉');
}
@override
void play(){
print("玩石头");
}
@override
void sleep(){
print("睡山洞");
}
}
class ModelMan extend Human{
@override
void eat(){
print('吃火锅');
}
@override
void play(){
print("玩王者荣耀");
}
@override
void sleep(){
print("睡别墅");
}
}
void main(){
var man1 = PrimitiveMan();
var man2 = ModelMan();
man1.eat();
man2.eat();
}
//多态应用
abstract class Human{
void eat();
void play();
void sleep();
//抽象类中的非抽象方法
void work(){ 
print("打工是不可能打工的");
}
}
void main(){
Human man1 = PrimitiveMan(); //多态
Human man2 = ModelMan(); //多态
man1.work();
man2.work();
man1.eat();
man2.eat();
}

6.2 接口

接口定义与实现

//定义一个接口，支持访问mysql mongodb
abstract class Db{
String url = '';
void save();
void read();
void delete();
}
class Mysql implements Db{
@override
String url = '';
Mysql(String url){
this.url = url;
print("mysql 连接成功");
}
@override
void save(){
print('mysql-save');
}
@override
void read(){
print('mysql-read');
}
@override
void delete(){
print('mysql-delete');
}
}
class MongoDB implements Db{
@override
String url = '';
MongoDB(String url){
this.url = url;
print("mongo 连接成功");
}
@override
void save(){
print('mongo-save');
}
@override
void read(){
print('mongo-read');
}
@override
void delete(){
print('mongo-delete');
}
}
void main(){
Db mysql = Mysql("连接地址");
Db mongo = MongoDB("连接地址");
mysql.save();
mysql.read();
mysql.delete();
mongo.save();
mongo.read();
mongo.delete();
}

6.3 类实现多个接口

abstract class Human{
void eat();
void play();
void sleep();
}
abstract class Student{
void learn();
void exam();
}
class ChinaStudent implements Human,Student{
@override
void eat() {
print("吃火锅");
}
@override
void exam() {
print("参加高考");
}
@override
void learn() {
print("学习各种文化课");
}
@override
void play() {
print("玩王者荣耀");
}
@override
void sleep() {
print("睡在住宅楼");
}
}
class EnglandStudent implements Human,Student{
@override
void eat() {
print("吃汉堡");
}
@override
void exam() {
print("参加A-Level");
}
@override
void learn() {
print("学习各种生存技能");
}
@override
void play() {
print("玩足球");
}
@override
void sleep() {
print("睡在自家house");
}
}
void main(){
Student chinaStudent = ChinaStudent(); //实例一个Student
Student englandStudent = EnglandStudent(); //实例一个Student
chinaStudent.learn();
chinaStudent.exam();
englandStudent.learn();
englandStudent.exam();
}

6.4 with实现多继承

不能实现多重继承

//with 实现多继承的效果
class A {
void printA(){
print('A');
}
}
class B {
void printB(){
print('B');
}
}
class C with A,B { //实现多继承
}
void main(){
var c = C();
c.printA();
c.printB();
}

7 泛型

解决代码复用

7.1 泛型方法

//泛型方法
//对返回类型和参数类型分别进行校验
T getData(T value){
return value;
}
//只对输入参数进行校验
void setData(String key, T value)
{
print("key=${key}" + " value=${value}");
}
void main(){
setData("name", "hello dart!"); // string类型
setData("name", 123); // int 类型
print(getData("name")); // string类型
print(getData(123)); // int 类型
}

7.2 泛型类

//泛型类
class MyList{
List list = [];
void add(T value){
this.list.add(value);
}
void printInfo(){
for(var item in this.list){
print(item);
}
}
}
void main(){
MyList myList1 = MyList(); //做类型约束
myList1.add('Hello');
myList1.add('Dart');
myList1.printInfo();

MyList myList2 = MyList(); //不做类型约束
myList2.add(3.14);
myList2.add(110);
myList2.add('Hello Dart');
myList2.printInfo();
}

7.3 泛型接口

//泛型接口
abstract class Cache{
getByKey(String key);
void setByKey(String key, T value);
}
class MemoryCache implements Cache{
Map map = {};
@override
getByKey(String key) {
return map[key];
}
@override
void setByKey(String key, T value) {
map[key]=value;
print("${key}->${value} 写入缓存");
}
}
void main(){
MemoryCache memoryCache = MemoryCache();
memoryCache.setByKey('1001', 'Hello Dart');
memoryCache.setByKey('1002', 'Hello Flutter');
print(memoryCache.getByKey('1001'));
}

8 Dart库

8.1 导入自定义的库

//抽离到 lib/Cache.dart
abstract class Cache{
getByKey(String key);
void setByKey(String key, T value);
}
//抽离到 lib/MemoryCache.dart
import 'Cache.dart';
class MemoryCache implements Cache{
Map map = {};
@override
getByKey(String key) {
return map[key];
}
@override
void setByKey(String key, T value) {
map[key]=value;
print("${key}->${value} 写入缓存");
}
}
//引用库中要用的文件
import 'lib/Cache.dart';
import 'lib/MemoryCache.dart';
void main(){
Cache memoryCache = MemoryCache();
memoryCache.setByKey('1001', 'Hello Dart');
memoryCache.setByKey('1002', 'Hello Flutter');
print(memoryCache.getByKey('1001'));
}

8.2 导入系统内置的库

import 'dart:io';
import 'dart:math';
import 'dart:convert';
void main() async{
//print(min(12,13));
//print(max(12,13));
var result = await getDataFromAPI();
print(result);
}
getDataFromAPI() async{
//1.创建httpClient对象
var httpClient = HttpClient();
//2.创建Uri对象
var uri = Uri.http('news-at.zhihu.com','/api/3/stories/latest');
//3.发起请求，等待请求
var request = await httpClient.getUrl(uri);
//4.关闭请求等待响应
var response = await request.close();
//5.解码响应的内容
return await response.transform(utf8.decoder).join();
}
//async 方法变为异步
//await 等待异步方法执行完成
//只有 async 方法 才能使用 await 关键词

8.3 导入Pub包管理系统的第三方库

• 1) 从以下网址找到要用的库

/*
* https://pub.dev/packages
* https://pub.flutter-io.cn/packages
* https://pub.dartlang.org/flutter/
*/

• 2) 在项目的根目录下的 pubspec.yaml中添加

dependencies:
    http: ^0.13.4 #要添加的第三方库
    date_format: ^2.0.6

• 3) 安装，在项目所在目录，cmd

dart pub get

• 4) 在项目中导入

import 'dart:convert' as convert;
import 'package:http/http.dart' as http;
void main(List arguments) async {
var url =
Uri.https('news-at.zhihu.com', '/api/3/stories/latest', {'q': '{http}'});
var response = await http.get(url);
if (response.statusCode == 200) {
var jsonResponse =
convert.jsonDecode(response.body);
var itemCount = jsonResponse['totalItems'];
print(jsonResponse);
} else {
print('Request failed with status: ${response.statusCe}.');
}
}

支付宝打赏

微信打赏

入门   基础   Dart

发表评论

留言与评论（共有 0 条评论） “”

验证码：