Dart 总结

王睿丶

已于 2023-03-03 16:47:48 修改

阅读量1.3k

点赞数 2

分类专栏： Dart 文章标签： dart flutter android 王睿丶

于 2021-08-08 12:52:35 首次发布

本文链接：https://blog.csdn.net/qq_27494201/article/details/119486431

版权

Dart 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

文章目录

1、Dart 介绍

一丶Dart 概述

Dart 是 Google 发布的一门开源编程语言
Dart 初期目标是称为下一代的 web 开发语言
Dart 目前已可用于全平台开发
Dart 是一门面向对象的编程语言

二丶为什么使用Dart

高校
Dart 语法清晰简洁，工具简单而强大。输入检测可帮助您尽早识别细微错误。Dart 拥有久经考验的核心库和一个已经拥有数以千计的 packages 生态系统
快速
Dart 提供提前编译优化，以在移动设备和 web 上实现可预测的高性能和快速启动。
可移植
Dart 可以编译成 ARM 和 x86 代码，因此 Dart 移动应用程序可以在 iOS，Android 及更高版本上实现本地运行。对于 web 应用程序，Dart 可以转化为 JavaScript。
易学
Dart 是面向对象的编程语言，语法风格对于许多现有的开发人员来说都很熟悉。如果您已经了解C++，C# 或 Java，那么使用 Dart 也就是分分钟的事情。
响应式
Dart 可以便捷的进行响应式编程。由于快速对象分配和垃圾收集器的实现，对于管理短期对象（比如 UI 小部件），Dart 更加高效。Dart 可以通过 Future 和 Stream 的特性和 API 实现异步编程。

三丶Dart 语言特性

单进程异步事件模型
强类型，可以类型推断
DartVM，具有极高的运行效率和优秀的代码运行优化，根据早前的基准测试，性能比肩 Java7 的 JVM
独特的隔离区（lsolate），可以实现多线程
面向对象编程，一切数据类型均派生自Object
运算符重载，泛型支持
强大的 Future 和 Stream 模型，可以简单实现高效的代码
Minix 特性，可以更好的实现方法复用
全平台语言，可以很好地胜任移动和前后端的开发
在语法上，Dart 提供了很多便捷的操作，可以明显减少代码量。比如字符连接，可以直接“my name is $name,age is
$age”，无需+号拼接，也无需做类型转换

四丶应用场景

服务端开发
1、命令行应用
2、HTTP 服务端
Web 开发
Android 和 iOS 开发

五丶版本

Dart1.x 为稳定版本
Dart2.x 目前为开发版本
课程以 Dart2 最新版本进行讲解

六丶Dart 内置库

包名	描述
dart:async	异步编程，提供Future，Stream 类
dart:collection	集合
dart:convert	不同类型的字符编码解码
dart:core	Dart 语言核心功能，内置类型
dart:html	网页开发用到的库
dart:io	文件读写，IO相关
dart:math	数字常量及函数，随机算法等
dart:svg	事件和动画矢量图支持

七丶输出“Hello World”

main(){
	print('你好dart');
}

八丶学习资料

Dart 官方文档

2、Dart 安装

一丶下载Dart（含SDK）

https://gekorm.com/dart-windows/

二丶设置环境变量
【1】
Name：DART_SDK
Key：D:\program\Dart\Dart\dart-sdk
在这里插入图片描述
【2】
Name：Path
Key：D:\program\Dart\Dart\dart-sdk;

在这里插入图片描述

三丶检测是是否成功
【1】dart --version
在这里插入图片描述

四丶安装VSCode
【1】
可以参考我的博文：如何下载Visual Studio Code及配置教程
【2】
点开左边工具栏，第四个，搜索dart，下载这个插件
在这里插入图片描述
下载Code Runner插件

【3】写代码，运行

在这里插入图片描述

3、知识点

3.1、Dart介绍、Dart环境搭建、Dart开发工具

一丶 Dart介绍
Dart是由谷歌开发的计算机编程语言,它可以被用于web、服务器、移动应用和物联网等领域的开发。
Dart诞生于2011年，号称要取代JavaScript。但是过去的几年中一直不温不火。直到Flutter的出现现在被人们重新重视。
要学Flutter的话我们必须首先得会Dart。
官网：https://dart.dev/

二丶Dart环境搭建

1丶下载Dart（含SDK）

https://gekorm.com/dart-windows/

2丶设置环境变量
【1】
Name：DART_SDK
Key：D:\program\Dart\Dart\dart-sdk
在这里插入图片描述
【2】
Name：Path
Key：D:\program\Dart\Dart\dart-sdk;

在这里插入图片描述

3丶检测是是否成功
【1】dart --version
在这里插入图片描述

4丶安装VSCode
【1】
可以参考我的博文：如何下载Visual Studio Code及配置教程
【2】
点开左边工具栏，第四个，搜索dart，下载这个插件
在这里插入图片描述
下载Code Runner插件

【3】写代码，运行

在这里插入图片描述

三丶 Dart开发工具
Dart的开发工具有很多： IntelliJ IDEA 、 WebStorm、 Atom、Vscode等

这里我们主要给大家讲解的是如果在Vscode中配置Dart。

1、找到vscode插件安装dart

2、找到vscode插件安装code runner Code Runner 可以运行我们的文件

3.2、变量、常量、命名规则、入口方法的两种定义方式

一丶入口方法的两种定义方式
方式一：

main(){
	print('你好dart');
}

方式二：

void main(){
 print('你好dart');
}

二丶变量
1、变量的概念

dart是一个强大的脚本类语言，可以不预先定义变量类型，自动会类型推倒

dart中定义变量可以通过var关键字可以通过类型来申明变量

如：

    var str='this is var';
    String str='this is var';
    int str=123;

注意： var 后就不要写类型，写了类型不要var 两者都写 var a int = 5; 报错

2、定义变量

void main(){
   
       var str='你好dart';
       var myNum=1234;
       print(str);
       print(myNum);
       
    //字符串
       String str='你好dart';
       print(str);

    //数字类型
       int myNum=12354;
       print(myNum);

  	//dart里面有类型校验
  
       var str='';
       str=1234;
       print(str);
       String str="2131242";
       print(str);
       
       int myNum=1243214;
       print(myNum);

三丶常量

1、常量的概念

final 和 const修饰符

const值不变一开始就得赋值
final 可以开始不赋值只能赋一次 ; 而final不仅有const的编译时常量的特性，最重要的它是运行时常量，并且final是惰性初始化，即在运行时第一次使用前才初始化

永远不改量的量，请使用final或const修饰它，而不是使用var或其他变量类型。

2、定义常量

void main(){


 
  var str='this is a str';

  str='你好 str';

  print(str);


  int myNum=1234;

  myNum=4567;

  print(myNum);
 

//const常量
   const PI=3.14159;
   PI=123.1243; //错误的写法 常量不可以修改
   print(PI);

// final 常量
     final PI=3.14159;
     PI=124214.214124;   //错误写法
     print(PI);


    final a=new DateTime.now();

    print(a);   //2019-05-10 15:59:02.966122

    //const a=new DateTime.now();   //报错了

  //区别：final 可以开始不赋值 只能赋一次 ; 而final不仅有const的编译时常量的特性，最重要的它是运行时常量，并且final是惰性初始化，即在运行时第一次使用前才初始化

}

四丶命名规则
1、变量名称必须由数字、字母、下划线和美元符($)组成。

2、注意：标识符开头不能是数字

3、标识符不能是保留字和关键字。

4、变量的名字是区分大小写的如: age和Age是不同的变量。在实际的运用中,也建议,不要用一个单词大小写区分两个变量。

5、标识符(变量名称)一定要见名思意：变量名称建议用名词，方法名称建议用动词

3.3、常用数据类型、字符串类型、数值类型、布尔类型、List集合类型、Maps类型

一丶数据类型

常用数据类型：
Numbers（数值）:
int
double
Strings（字符串）
String
Booleans(布尔)
bool
List（数组）
在Dart中，数组是列表对象，所以大多数人只是称它们为列表
Maps（字典）
通常来说，Map 是一个键值对相关的对象。键和值可以是任何类型的对象。每个键只出现一次，而一个值则可以出现多次

项目中用不到的数据类型（用不到）：
Runes
Rune是UTF-32编码的字符串。它可以通过文字转换成符号表情或者代表特定的文字。

  main() {
          var clapping = '\u{1f44f}';
          print(clapping);
          print(clapping.codeUnits);
          print(clapping.runes.toList());
        
          Runes input = new Runes(
              '\u2665  \u{1f605}  \u{1f60e}  \u{1f47b}  \u{1f596}  \u{1f44d}');
          print(new String.fromCharCodes(input));
        }

Symbols
Symbol对象表示在Dart程序中声明的运算符或标识符。您可能永远不需要使用符号，但它们对于按名称引用标识符的API非常有用，因为缩小会更改标识符名称而不会更改标识符符号。要获取标识符的符号，请使用符号文字，它只是＃后跟标识符：

在 Dart 中符号用 # 开头来表示，入门阶段不需要了解这东西，可能永远也用不上。
http://dart.goodev.org/guides/libraries/library-tour#dartmirrors—reflection

二丶字符串类型
Dart数据类型：字符串类型

void main(){

  //1、字符串定义的几种方式
   var str1='this is str1';
   var str2="this is str2";
   print(str1);
   print(str2);

   String str1='this is str1';
   String str2="this is str2";
   print(str1);
   print(str2);

   String str1='''this is str1
   this is str1
   this is str1
   ''';
    print(str1);
    
     String str1="""
     this is str1
     this is str1
     this is str1
     """;
    print(str1);

  //2、字符串的拼接
  String str1='你好';
  String str2='Dart';
  print("$str1 $str2");
  print(str1 + str2);
  print(str1 +" "+ str2);

三丶数值类型
Dart数据类型：数值类型
int
double

void main(){
  //1、int   必须是整型
    int a=123;
    a=45;
    print(a);

  //2、double  既可以是整型 也可是浮点型
    double b=23.5;
    b=24;
    print(b);

  //3、运算符
    // + - * / %
    var c=a+b;
    print(c);
}

四丶布尔类型
Dart数据类型：布尔类型

bool 值true/false

void main(){
  //1、bool
         bool flag1=true;
         print(flag1);
         bool flag2=false;
         print(flag2);


  //2、条件判断语句
      var flag=true;
      if(flag){
        print('真');
      }else{
        print('假');
      }
       var a=123;
       var b='123';
       if(a==b){
         print('a=b');
       }else{
          print('a!=b');
       }
      var a=123;
      var b=123;
      if(a==b){
        print('a=b');
      }else{
         print('a!=b');
      }
}

五丶 List集合类型
Dart数据类型： List（数组/集合）

void main(){
    //1、第一种定义List的方式
      var l1=['aaa','bbbb','cccc'];
      print(l1);
      print(l1.length);
      print(l1[1]);
  
    //2、第二种定义List的方式
     var l2=new List();
     l2.add('张三');
     l2.add('李四');
     l2.add('王五');
     print(l2);
     print(l2[2]);
    
    //3、定义List指定类型
    var l3=new List<String>();
    l3.add('张三');
    l3.add(123);
    print(l3);
}

六丶 Maps类型
Dart数据类型： Maps（字典）

void main(){
  //第一种定义 Maps的方式
     var person={
       "name":"张三",
       "age":20,
       "work":["程序员","送外卖"]
     };
     print(person);
     print(person["name"]);
     print(person["age"]);
     print(person["work"]);

   //第二种定义 Maps的方式
    var p=new Map();
    p["name"]="李四";
    p["age"]=22;
    p["work"]=["程序员","送外卖"];
    print(p);
    print(p["age"]);  
}

七丶类型判断
Dart判断数据类型：
是通过is 关键词来判断类型

void main(){
   var str='1234';
   if(str is String){
     print('是string类型');
   }else if(str is int){
      print('int');
   }else{
      print('其他类型');
   }

  var str=123;
  if(str is String){
    print('是string类型');
  }else if(str is int){
     print('int');
  }else{
     print('其他类型');
  }
}

3.4、运算符、条件判断、类型转换

一丶运算符

算术运算符

+    -    *    /     ~/ (取整)     %（取余）

关系运算符

== ！= > < >= <=

逻辑运算符

! && ||

赋值运算符

基础赋值运算符 = ??=

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

条件表达式
if else switch case
三目运算符
??运算符：

二丶算术运算符

void main(){

  int a=13;
  int b=5;

  print(a+b);   //加
  print(a-b);   //减
  print(a*b);   //乘
  print(a/b);   //除
  print(a%b);   //其余
  print(a~/b);  //取整

  var c=a*b;
  print('--------');
  print(c);

三丶关系运算符

void main(){
  //  ==    ！=   >    <    >=    <=

  int a=5;
  int b=3;

  print(a==b);   //判断是否相等
  print(a!=b);   //判断是否不等
  print(a>b);   //判断是否大于
  print(a<b);   //判断是否小于
  print(a>=b);   //判断是否大于等于
  print(a<=b);   //判断是否小于等于
  
  if(a>b){
    print('a大于b');
  }else{
    print('a小于b');
  }
}

四丶逻辑运算符

void main(){

  /* ! 取反 */ 
   bool flag=false;
   print(!flag);   //取反

 /* &&并且:全部为true的话值为true 否则值为false */ 
   bool a=true;
   bool b=true;
   print(a && b);

 /* ||或者：全为false的话值为false 否则值为true */ 
   bool a=false;
   bool b=false;
   print(a || b);

//如果一个人的年龄是20 并且 sex是女的话我们打印这个人
   int age=20;
   String sex="女";
   if(age==20 && sex=="女"){
     print("$age --- $sex");
   }else{
     print("不打印");
   }

//如果一个人的年龄是20 或者 sex是女的话我们打印这个人
  int age=23;
  String sex="女";
  if(age==20 || sex=="女"){
    print("$age --- $sex");
  }else{
    print("不打印");
  }
}

五丶基础赋值运算符&复合赋值运算符

void main(){

 
//  1、基础赋值运算符   =   ??=      
         int a=10;
         int b=3;
         print(a);
         int c=a+b;   //从右向左

     b??=23;  表示如果b为空的话把 23赋值给b
         int b=6;
         b??=23;
         print(b);

         int b;
         b??=23;
         print(b);

//2、  复合赋值运算符   +=  -=  *=   /=   %=  ~/=
     var a=12;
     a=a+10;
     print(a);

     var a=13;
     a+=10;   //表示a=a+10
     print(a);
    
   var a=4;
   a*=3;  //a=a*3;
   print(a);
}

六丶条件表达式

void main(){

  //1、if  else   switch case 
     bool flag=true;
     if(flag){
       print('true');
     }else{
       print('false');
     }

  //判断一个人的成绩 如果大于60 显示及格   如果大于 70显示良好  如果大于90显示优秀
   var score=41;
   if(score>90){
     print('优秀');
   }else if(score>70){
      print('良好');
   }else if(score>=60){
     print('及格');
   }else{
     print('不及格');
   }

   var sex="女";
   switch(sex){
     case "男":
      print('性别是男');
       break;
     case "女":
       print('性别是女');
       print('性别是女');
       break;
      default:
       print('传入参数错误');
       break;
   }

  //2、三目运算符 
   var falg=true;
   var c;
   if(falg){
       c='我是true';
   }else{
     c="我是false";
   }
   print(c);

  bool flag=false;
  String c=flag?'我是true':'我是false';
  print(c);

  //3  ??运算符
   var a;
   var b= a ?? 10;
   print(b);   10
   
   var a=22;
   var b= a ?? 10;
   print(b);
}

3.5、自增自减运算符、for、while、do…while循环、continue、break、多维列表循环

一丶自增自减运算符

void main(){

  //   ++  --   表示自增 自减 1

  //   在赋值运算里面 如果++ -- 写在前面 这时候先运算 再赋值，如果++ --写在后面 先赋值后运行运算
    var a=10;
    var b=a--;
    print(a);  //9
    print(b);  //10
  
     var a=10;
     a++;   //a=a+1;
     print(a);

     var a=10;
     a--;    //a=a-1;
     print(a);
    
     var a=10;
     var b=a++;
     print(a);  //11
     print(b);  //10
    
     var a=10;
     var b=++a;
     print(a);  //11
     print(b);  //11
    
     var a=10;
     var b=--a;
     print(a);  //9
     print(b);  //9
     
     var a=10;
     var b=a--;
     print(a);  //9
     print(b);  //10

    var a=10;
    ++a;
    print(a);
}

二丶 for循环

// for基本语法
          for (int i = 1; i<=100; i++) {   
            print(i);
          }

        	//第一步，声明变量int i = 1;
        	//第二步，判断i <=100
        	//第三步，print(i);
        	//第四步，i++
        	//第五步 从第二步再来，直到判断为false

void main(){

   for(int i=1;i<=10;i++){
       print(i);
   }

  //1、打印0-50所有的偶数
     for(int i=0;i<=50;i++){
         if(i%2==0){
           print(i);
         }
     }

  //2、求 1+2+3+4 +...100的和
     var sum=0;
     for(var i=1;i<=100;i++){
         sum+=i;
     }
     print(sum);
      sum=0+1;
      sum=0+1+2;
      sum=0+1+2+3+...+100;

  // 3、计算5的阶乘   (1*2*3*4*5    n的阶乘1*2……*n)
     var sum=1;
     for(var i=1;i<=5;i++){
         sum*=i;
     }
     print(sum);

    sum=1*1;
    sum=1*1*2;
    sum=1*1*3;
    sum=1*1*3*4*5;
    
  //4、打印List  ['张三','李四','王五'] 里面的内容
     List list=['张三','李四','王五'];

      print(list[1]);

     for(var i=0;i<list.length;i++){

       print(list[i]);
     }

  //5、打印List 
     List list=[{
       "title":"新闻111"
     },
     {
       "title":"新闻222"
     },
     {
       "title":"新闻333"
     }];

      print(list[1]);

     for(var i=0;i<list.length;i++){

       print(list[i]['title']);
     }

  //4、定义一个二维数组 打印里面的内容
        List list=[
          {
              "cate":'国内',
              "news":[
                {"title":"国内新闻1"},
                {"title":"国内新闻2"},
                {"title":"国内新闻3"}
              ]
          },
          {
              "cate":'国际',
              "news":[
                {"title":"国际新闻1"},
                {"title":"国际新闻2"},
                {"title":"国际新闻3"}
              ]
          }
        ];

        /*
        国内
            国内新闻1
            国内新闻2
            国内新闻3
        国际
            国际新闻1
            国际新闻2
        */

        for(var i=0;i<list.length;i++){
            print(list[i]["cate"]);
            print('-------------');
            for(var j=0;j<list[i]["news"].length;j++){
                print(list[i]["news"][j]["title"]);
            }
        }
}

三丶 while、do…while循环

	语法格式:	
		while(表达式/循环条件){				
		}			
		do{
			语句/循环体		
		}while(表达式/循环条件);
		注意: 1、最后的分号不要忘记
			  2、循环条件中使用的变量需要经过初始化
		      3、循环体中，应有结束循环的条件，否则会造成死循环。

void main(){

    int i=1;
    while(i<=10){
       print(i);
    }
    //死循环

     int i=1;
     while(i<=10){
         print(i);
         i++;
     }

//1、求1+2+3+4 ...+100的和
     int i=1;
     var sum=0;
     while(i<=100){
        sum+=i;
        i++;
     }
     print(sum);

     int i=1;
     var sum=0;
     do{
        sum+=i;
        i++;
     }while(i<=100);
     print(sum);

  while 和 do while的区别   第一次循环条件不成立的情况下
     int i=10;
	   while(i<2){
	   	print('执行代码');
	   }
	   
	  var j=10;	  
	  do{
	  	print('执行代码');
	  }while(j<2);
}

四丶 break和continue

			break语句功能:
          1、在switch语句中使流程跳出switch结构。
          2、在循环语句中使流程跳出当前循环,遇到break 循环终止，后面代码也不会执行
          
          强调:
          1、如果在循环中已经执行了break语句,就不会执行循环体中位于break后的语句。
          2、在多层循环中,一个break语句只能向外跳出一层

        break可以用在switch case中 也可以用在 for 循环和 while循环中

      continue语句的功能:
			  
        【注】只能在循环语句中使用,使本次循环结束，即跳过循环体重下面尚未执行的语句，接着进行下次的是否执行循环的判断。

        continue可以用在for循环以及 while循环中，但是不建议用在while循环中，不小心容易死循环

main() {
    for(var i=1;i<=10;i++){
      print(i);
    }

    //1、如果i等于4的话跳过
    for(var i=1;i<=10;i++){
      if(i==4){
        continue;  /*跳过当前循环体 然后循环还会继续执行*/
      }
      print(i);
    }

    //2、如果 i等于4的话跳出循环
    for(var i=1;i<=10;i++){
      if(i==4){
        break;  /*跳出循环体*/
      }
      print(i);
    }
      
    //3、break语句只能向外跳出一层
    	 for(var i=0;i<5;i++){	 	    	
			  	print('外层---$i');
          for(var j=0;j<3;j++){	
            
            if(j==1){
              break;
            }
            print('里层$j');		 	
          }	
			 }
			 
  //4、while循环 break跳出循环
  var i=1;
  while(i<=10){
    if(i==4){
      break;
    }
    print(i);
    i++;
  }

  var sex="男";
  switch (sex) {
    case "男":
      print('男');
      break;
    case "女":
      print('男');
      break;
    default:
  }
}

3.6、集合类型List Set Map详解以及循环语句 forEach map where any every

一丶 list集合
常用属性：
length 长度
reversed 翻转
isEmpty 是否为空
isNotEmpty 是否不为空
常用方法：
add 增加
addAll 拼接数组
indexOf 查找传入具体值
remove 删除传入具体值
removeAt 删除传入索引值
fillRange 修改
insert(index,value); 指定位置插入
insertAll(index,list) 指定位置插入List
toList() 其他类型转换成List
join() List转换成字符串
split() 字符串转化成List
forEach
map
where
any
every

void main(){

   List myList=['香蕉','苹果','西瓜'];
   print(myList[1]);

   var list=new List();
   list.add('111');
   list.add('222');
   print(list);

//List里面的属性：
     List myList=['香蕉','苹果','西瓜'];
     print(myList.length);
     print(myList.isEmpty);
     print(myList.isNotEmpty);
     print(myList.reversed);  //对列表倒序排序
     var newMyList=myList.reversed.toList();
     print(newMyList);

//List里面的方法：
     List myList=['香蕉','苹果','西瓜'];
     myList.add('桃子');   //增加数据  增加一个
     myList.addAll(['桃子','葡萄']);  //拼接数组
     print(myList);
     print(myList.indexOf('苹x果'));    //indexOf查找数据 查找不到返回-1  查找到返回索引值
     myList.remove('西瓜');
     myList.removeAt(1);
     print(myList);
 
     List myList=['香蕉','苹果','西瓜'];
     myList.fillRange(1, 2,'aaa');  //修改
     myList.fillRange(1, 3,'aaa');  
     
     myList.insert(1,'aaa');      //插入  一个
     
     myList.insertAll(1, ['aaa','bbb']);  //插入 多个
     print(myList);






    // List myList=['香蕉','苹果','西瓜'];

    // var str=myList.join('-');   //list转换成字符串

    // print(str);

    // print(str is String);  //true


    var str='香蕉-苹果-西瓜';

    var list=str.split('-');

    print(list);

    print(list is List);

  


  


}

3.7、函数的定义可选参数默认参数命名参数

一丶方法的定义变量方法的作用域

内置方法/函数：
print();
自定义方法：
自定义方法的基本格式：
返回类型方法名称（参数1，参数2,…）{
方法体
return 返回值;
}

void printInfo(){
  print('我是一个自定义方法');
}

int getNum(){
  var myNum=123;
  return myNum;
}

String printUserInfo(){

  return 'this is str';
}


List getList(){

  return ['111','2222','333'];
}

void main(){

   print('调用系统内置的方法');

   printInfo();
   var n=getNum();
   print(n);

   print(printUserInfo());

   print(getList());

   print(getList());
  
//演示方法的作用域
  void xxx(){

      aaa(){
          print(getList());
          print('aaa');
      }
      aaa();
  }
  // aaa();  错误写法 
  
  xxx();  //调用方法
}

二丶方法传参、默认参数、可选参数、命名参数、方法作为参数

//调用方法传参

main() {
 
//1、定义一个方法 求1到这个数的所有数的和      60    1+2+3+。。。+60
 
    int sumNum(int n){
      var sum=0;
      for(var i=1;i<=n;i++)
      {
        sum+=i;
      }
      return sum;
    } 

    var n1=sumNum(5);
    print(n1);
    var n2=sumNum(100);
    print(n2);

//2、定义一个方法然后打印用户信息
     String printUserInfo(String username,int age){  //行参
         return "姓名:$username---年龄:$age";
     }

     print(printUserInfo('张三',20)); //实参

//3、定义一个带可选参数的方法
    

     String printUserInfo(String username,[int age]){  //行参

       if(age!=null){
         return "姓名:$username---年龄:$age";
       }
       return "姓名:$username---年龄保密";
    
     }

     print(printUserInfo('张三',21)); //实参

     print(printUserInfo('张三'));

//4、定义一个带默认参数的方法


     String printUserInfo(String username,[String sex='男',int age]){  //行参

       if(age!=null){
         return "姓名:$username---性别:$sex--年龄:$age";
       }
       return "姓名:$username---性别:$sex--年龄保密";

     }

   print(printUserInfo('张三'));

   print(printUserInfo('小李','女'));

   print(printUserInfo('小李','女',30));



//5、定义一个命名参数的方法

   String printUserInfo(String username,{int age,String sex='男'}){  //行参

       if(age!=null){
         return "姓名:$username---性别:$sex--年龄:$age";
       }
       return "姓名:$username---性别:$sex--年龄保密";
   }

   print(printUserInfo('张三',age:20,sex:'未知'));



//6、实现一个 把方法当做参数的方法
   var fn=(){

     print('我是一个匿名方法');
   };      
   fn();

  //方法
  fn1(){
    print('fn1');
  }

  //方法
  fn2(fn){
    
    fn();
  }

  //调用fn2这个方法 把fn1这个方法当做参数传入
  fn2(fn1);

}

3.8、函数、箭头函数匿名函数闭包等

一丶箭头函数函数的相互调用

void main(){

/*需求：使用forEach打印下面List里面的数据*/
     List list=['苹果','香蕉','西瓜'];

     list.forEach((value){
       print(value);
     });

     list.forEach((value)=>print(value));
    
     list.forEach((value)=>{
       print(value)
     });
    
/*需求：修改下面List里面的数据，让数组中大于2的值乘以2*/
	List list=[4,1,2,3,4];
    
    var newList=list.map((value){
         if(value>2){
           return value*2;
         }
         return value;

     });
     print(newList.toList());
     
    var newList=list.map((value)=>value>2?value*2:value);
    print(newList.toList());

/*
需求：    1、定义一个方法isEvenNumber来判断一个数是否是偶数  
         2、定义一个方法打印1-n以内的所有偶数
*/

//定义一个方法isEvenNumber来判断一个数是否是偶数  
    bool isEvenNumber(int n){
      if(n%2==0){
        return true;
      }
      return false;
    }

    printNum(int n){
        for(var i=1;i<=n;i++){
            if(isEvenNumber(i)){
              print(i);
            }
        }
    }
    printNum(10);
}

3.9、对象、类

一丶面向对象的介绍以及Data内置对象

面向对象编程(OOP)的三个基本特征是：封装、继承、多态

封装：封装是对象和类概念的主要特性。封装，把客观事物封装成抽象的类，并且把自己的部分属性和方法提供给其他对象调用, 而一部分属性和方法则隐藏。

继承：面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

多态：允许将子类类型的指针赋值给父类类型的指针, 同一个函数调用会有不同的执行效果。

Dart所有的东西都是对象，所有的对象都继承自Object类。

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

一个类通常由属性和方法组成。

void main(){    
   
    List list=new List();
    list.isEmpty;
    list.add('香蕉');
    list.add('香蕉1');

    Map m=new Map();
    m["username"]="张三";
    m.addAll({"age":20});
    m.isEmpty;

    Object a=123;
    Object v=true;
    print(a);
    print(v);
}

二丶创建类使用类

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

class Person{
  String name="张三";
  int age=23;
  void getInfo(){
      // print("$name----$age");
      print("${this.name}----${this.age}");
  }
  void setInfo(int age){
    this.age=age;
  }
}
void main(){

  //实例化
   var p1=new Person();
   print(p1.name);
   p1.getInfo();

  Person p1=new Person();
   print(p1.name);

  p1.setInfo(28);
  p1.getInfo();
  
}

三丶自定义类的默认构造函数

class Person{
  String name='张三';
  int age=20; 
  //默认构造函数
  Person(){
    print('这是构造函数里面的内容  这个方法在实例化的时候触发');
  }
  void printInfo(){   
    print("${this.name}----${this.age}");
  }
}

//张三  李四  王五

class Person{
  String name;
  int age; 
  //默认构造函数
  Person(String name,int age){
      this.name=name;
      this.age=age;
  }
  void printInfo(){   
    print("${this.name}----${this.age}");
  }
}


class Person{
  String name;
  int age; 
  //默认构造函数的简写
  Person(this.name,this.age);
  void printInfo(){   
    print("${this.name}----${this.age}");
  }
}


void main(){
  
  Person p1=new Person('张三',20);
  p1.printInfo();


  Person p2=new Person('李四',25);
  p2.printInfo();

}

四丶自定义类的命名构造函数
dart里面构造函数可以写多个

class Person{
  String name;
  int age; 
  //默认构造函数的简写
  Person(this.name,this.age);
  
  Person.now(){
    print('我是命名构造函数');
  }

  Person.setInfo(String name,int age){
    this.name=name;
    this.age=age;
  }

  void printInfo(){   
    print("${this.name}----${this.age}");
  }
}

void main(){

   var d=new DateTime.now();   //实例化DateTime调用它的命名构造函数
   print(d);

  Person p1=new Person('张三', 20);   //默认实例化类的时候调用的是 默认构造函数
  Person p1=new Person.now();   //命名构造函数

  Person p1=new Person.setInfo('李四',30);
  p1.printInfo(); 
}

五丶把类单独抽离成一个模块
Person.dart

class Person{
  String name;
  int age; 
  //默认构造函数的简写
  Person(this.name,this.age);
  
  Person.now(){
    print('我是命名构造函数');
  }

  Person.setInfo(String name,int age){
    this.name=name;
    this.age=age;
  }

  void printInfo(){   
    print("${this.name}----${this.age}");
  }
}

main.dart

import 'lib/Person.dart';

void main(){
  Person p1=new Person.setInfo('李四1',30);
  p1.printInfo(); 
}

六丶私有方法和私有属性

Animal.dart

class Animal{
  String _name;   //私有属性
  int age; 
  //默认构造函数的简写
  Animal(this._name,this.age);

  void printInfo(){   
    print("${this._name}----${this.age}");
  }

  String getName(){ 
    return this._name;
  } 
  void _run(){
    print('这是一个私有方法');
  }

  execRun(){
    this._run();  //类里面方法的相互调用
  }
}

main.dart

/*
Dart和其他面向对象语言不一样，Data中没有 public  private protected这些访问修饰符合

但是我们可以使用_把一个属性或者方法定义成私有。

*/

import 'lib/Animal.dart';

void main(){
 
 Animal a=new Animal('小狗', 3);

 print(a.getName());
  a.execRun();   //间接的调用私有方法
}

七丶getter和setter修饰符的用法


class Rect{

  int height;
  int width;
 
  getArea(){
    return this.height*this.width;
  } 
}

class Rect{
  num height;
  num width; 
  
  Rect(this.height,this.width);
  area(){
    return this.height*this.width;
  }
}

void main(){
  Rect r=new Rect(10,4);
  print("面积:${r.area()}");   
}

class Rect{
  num height;
  num width;   
  Rect(this.height,this.width);
  get area{
    return this.height*this.width;
  }
}

void main(){
  Rect r=new Rect(10,2);
  print("面积:${r.area}");      //注意调用直接通过访问属性的方式访问area
}

class Rect{
  num height;
  num width; 
  
  Rect(this.height,this.width);
  get area{
    return this.height*this.width;
  }
  set areaHeight(value){
    this.height=value;
  }
}

void main(){
  Rect r=new Rect(10,4);
  // print("面积:${r.area()}");   
  r.areaHeight=6;

  print(r.area);

}

八丶类中的初始化列表

// Dart中我们也可以在构造函数体运行之前初始化实例变量

class Rect{

  int height;
  int width;
  Rect():height=2,width=10{
    
    print("${this.height}---${this.width}");
  }
  getArea(){
    return this.height*this.width;
  } 
}

void main(){
  Rect r=new Rect();
  print(r.getArea()); 
   
}

3.10、类静态成员操作符类的继承

一丶静态成员静态方法

Dart中的静态成员:

1、使用static 关键字来实现类级别的变量和函数

2、静态方法不能访问非静态成员，非静态方法可以访问静态成员

class Person {
  static String name = '张三';
  static void show() {
    print(name);
  }
}

main(){
  print(Person.name);
  Person.show();  
}

class Person {
  static String name = '张三';
  int age=20;
  
  static void show() {
    print(name);
  }
  void printInfo(){  /*非静态方法可以访问静态成员以及非静态成员*/

       print(name);  //访问静态属性
       print(this.age);  //访问非静态属性

      show();   //调用静态方法
  }
  static void printUserInfo(){//静态方法

        print(name);   //静态属性
        show();        //静态方法

        print(this.age);     //静态方法没法访问非静态的属性

         this.printInfo();   //静态方法没法访问非静态的方法
         printInfo();
  }
}

main(){
   print(Person.name);
   Person.show(); 

   Person p=new Person();
   p.printInfo(); 

  Person.printUserInfo();
}

二丶对象操作符

Dart中的对象操作符:

? 条件运算符（了解）
as 类型转换
is 类型判断
… 级联操作（连缀） (记住)

class Person {
  String name;
  num age;
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  } 
}

main(){ 
   Person p;
   p?.printInfo();

    Person p=new Person('张三', 20);
    p?.printInfo();
    
     Person p=new Person('张三', 20);
    
     if(p is Person){
         p.name="李四";
     } 
     p.printInfo();
     print(p is Object);

     var p1;

     p1='';

     p1=new Person('张三1', 20);

      p1.printInfo();
     (p1 as Person).printInfo();

    Person p1=new Person('张三1', 20);
    p1.printInfo();
    p1.name='张三222';
    p1.age=40;
    p1.printInfo();
  
   Person p1=new Person('张三1', 20);
   p1.printInfo();
   p1..name="李四"
     ..age=30
     ..printInfo();
}

三丶类的继承-简单继承

面向对象的三大特性：封装、继承、多态

Dart中的类的继承：
1、子类使用extends关键词来继承父类
2、子类会继承父类里面可见的属性和方法但是不会继承构造函数
3、子类能复写父类的方法 getter和setter

class Person {
  String name='张三';
  num age=20; 
  void printInfo() {
    print("${this.name}---${this.age}");  
  } 
}
class Web extends Person{

}

main(){   

  Web w=new Web();
  print(w.name);
  w.printInfo();
 
}

四丶 super关键词的使用实例化自类给父类构造函数传参

面向对象的三大特性：封装、继承、多态

class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
}

class Web extends Person{
  Web(String name, num age) : super(name, age){

  }
}

main(){ 

   Person p=new Person('李四',20);
   p.printInfo();

   Person p1=new Person('张三',20);
   p1.printInfo();

  Web w=new Web('张三', 12);
  w.printInfo();
}

五丶 super关键词的使用实例化自类给父类构造函数传参

class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
}


class Web extends Person{
  String sex;
  Web(String name, num age,String sex) : super(name, age){
    this.sex=sex;
  }
  run(){
   print("${this.name}---${this.age}--${this.sex}");  
  }
}

main(){ 

   Person p=new Person('李四',20);
   p.printInfo();

   Person p1=new Person('张三',20);
   p1.printInfo();

  Web w=new Web('张三', 12,"男");
  w.printInfo();
  w.run();
}

六丶实例化自类给命名构造函数传参

class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  Person.xxx(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
}

class Web extends Person{
  String sex;
  Web(String name, num age,String sex) : super.xxx(name, age){
    this.sex=sex;
  }
  run(){
   print("${this.name}---${this.age}--${this.sex}");  
  }
}

main(){ 

   Person p=new Person('李四',20);
   p.printInfo();

   Person p1=new Person('张三',20);
   p1.printInfo();

  Web w=new Web('张三', 12,"男");
  w.printInfo();
  w.run();
}

七丶覆写父类的方法

class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
  work(){
    print("${this.name}在工作...");
  }
}

class Web extends Person{
  Web(String name, num age) : super(name, age);

  run(){
    print('run');
  }
  //覆写父类的方法
  @override       //可以写也可以不写  建议在覆写父类方法的时候加上 @override 
  void printInfo(){
     print("姓名：${this.name}---年龄：${this.age}"); 
  }
  @override
  work(){
    print("${this.name}的工作是写代码");
  }
}

main(){ 

  Web w=new Web('李四',20);
  w.printInfo();
  w.work();
}

八丶自类里面调用父类的方法

class Person {
  String name;
  num age; 
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");  
  }
  work(){
    print("${this.name}在工作...");
  }
}

class Web extends Person{
  Web(String name, num age) : super(name, age);

  run(){
    print('run');
    super.work();  //自类调用父类的方法
  }
  //覆写父类的方法
  @override       //可以写也可以不写  建议在覆写父类方法的时候加上 @override 
  void printInfo(){
     print("姓名：${this.name}---年龄：${this.age}"); 
  }
}

main(){ 

  Web w=new Web('李四',20);
  // w.printInfo();
  w.run();
}

3.11、抽象类多态以及接口

一丶抽象类

Dart中抽象类: Dart抽象类主要用于定义标准，子类可以继承抽象类，也可以实现抽象类接口。

1、抽象类通过abstract 关键字来定义

2、Dart中的抽象方法不能用abstract声明，Dart中没有方法体的方法我们称为抽象方法。

3、如果子类继承抽象类必须得实现里面的抽象方法

4、如果把抽象类当做接口实现的话必须得实现抽象类里面定义的所有属性和方法。

5、抽象类不能被实例化，只有继承它的子类可以

extends抽象类和 implements的区别：

1、如果要复用抽象类里面的方法，并且要用抽象方法约束自类的话我们就用extends继承抽象类

2、如果只是把抽象类当做标准的话我们就用implements实现抽象类

案例：定义一个Animal 类要求它的子类必须包含eat方法

abstract class Animal{
  eat();   //抽象方法
  run();  //抽象方法  
  printInfo(){
    print('我是一个抽象类里面的普通方法');
  }
}

class Dog extends Animal{
  @override
  eat() {
     print('小狗在吃骨头');
  }

  @override
  run() {
    // TODO: implement run
    print('小狗在跑');
  }  
}
class Cat extends Animal{
  @override
  eat() {
    // TODO: implement eat
    print('小猫在吃老鼠');
  }

  @override
  run() {
    // TODO: implement run
    print('小猫在跑');
  }
}

main(){

  Dog d=new Dog();
  d.eat();
  d.printInfo();
  Cat c=new Cat();
  c.eat();
  c.printInfo();
  // Animal a=new Animal();   //抽象类没法直接被实例化
}

3.12、一个类实现多个接口以及Dart中的Mixins

一丶 implements实现多个接口

abstract class A{
  String name;
  printA();
}

abstract class B{
  printB();
}

class C implements A,B{  
  @override
  String name;  
  @override
  printA() {
    print('printA');
  }
  @override
  printB() {
    // TODO: implement printB
    return null;
  }
}

void main(){

  C c=new C();
  c.printA();
  
}

二丶 mixins

mixins的中文意思是混入，就是在类中混入其他功能。

在Dart中可以使用mixins实现类似多继承的功能

因为mixins使用的条件，随着Dart版本一直在变，这里讲的是Dart2.x中使用mixins的条件：

1、作为mixins的类只能继承自Object，不能继承其他类
2、作为mixins的类不能有构造函数
3、一个类可以mixins多个mixins类
4、mixins绝不是继承，也不是接口，而是一种全新的特性

上：

class A {
  String info="this is A";
  void printA(){
    print("A");
  }
}

class B {
  void printB(){
    print("B");
  }
}

class C with A,B{
  
}

void main(){
  
  var c=new C();  
  c.printA();
  c.printB();
  print(c.info);
}

下：

class Person{
  String name;
  num age;
  Person(this.name,this.age);
  printInfo(){
    print('${this.name}----${this.age}');
  }
  void run(){
    print("Person Run");
  }
}

class A {
  String info="this is A";
  void printA(){
    print("A");
  }
  void run(){
    print("A Run");
  }
}

class B {  
  void printB(){
    print("B");
  }
  void run(){
    print("B Run");
  }
}

class C extends Person with B,A{
  C(String name, num age) : super(name, age);
  
}

三丶 mixins 的类型

mixins的实例类型是什么？

很简单，mixins的类型就是其超类的子类型。

class A {
  String info="this is A";
  void printA(){
    print("A");
  }
}

class B {
  void printB(){
    print("B");
  }
}

class C with A,B{
  
}

void main(){  
   var c=new C();  
   
  print(c is C);    //true
  print(c is A);    //true
  print(c is B);   //true

  // var a=new A();

  // print(a is Object);

}

3.13、泛型、泛型方法、泛型类、泛型接口

一丶泛型方法

通俗理解：泛型就是解决类接口方法的复用性、以及对不特定数据类型的支持(类型校验)

只能返回string类型的数据

  String getData(String value){
      return value;
  }
  

同时支持返回 string类型 和int类型  （代码冗余）

  String getData1(String value){
      return value;
  }

  int getData2(int value){
      return value;
  }

同时返回 string类型 和number类型       不指定类型可以解决这个问题

  getData(value){
      return value;
  }

//不指定类型放弃了类型检查。我们现在想实现的是传入什么 返回什么。比如:传入number 类型必须返回number类型  传入 string类型必须返回string类型
 
  T getData<T>(T value){
      return value;
  }

  getData<T>(T value){
      return value;
  }

void main(){

    print(getData(21));

    print(getData('xxx'));

    getData<String>('你好');

    print(getData<int>(12));

}

二丶泛型类

集合List 泛型类的用法

案例：把下面类转换成泛型类，要求List里面可以增加int类型的数据，也可以增加String类型的数据。但是每次调用增加的类型要统一

class PrintClass{
      List list=new List<int>();
      void add(int value){
          this.list.add(value);
      }
      void printInfo(){          
          for(var i=0;i<this.list.length;i++){
            print(this.list[i]);
          }
      }
 }

 PrintClass p=new PrintClass();
    p.add(1);
    p.add(12);
    p.add(5);
    p.printInfo();

 class PrintClass<T>{
      List list=new List<T>();
      void add(T value){
          this.list.add(value);
      }
      void printInfo(){          
          for(var i=0;i<this.list.length;i++){
            print(this.list[i]);
          }
      }
 }

main() {  
    PrintClass p=new PrintClass();
    p.add(11);
    p.add('xxx');
    p.add(5);
    p.printInfo();

  PrintClass p=new PrintClass<String>();

  p.add('你好');
  p.add('哈哈');
  p.printInfo();

  PrintClass p=new PrintClass<int>();

  p.add(12);
  p.add(23);
  p.printInfo();

  List list=new List();
  list.add(12);
  list.add("你好");
  print(list);

  List list=new List<String>();

  // list.add(12);  //错误的写法

  list.add('你好');
  list.add('你好1');

  print(list);

  List list=new List<int>();

  // list.add("你好");  //错误写法
  list.add(12); 

  print(list);
}

三丶泛型接口

实现数据缓存的功能：有文件缓存、和内存缓存。内存缓存和文件缓存按照接口约束实现。

1、定义一个泛型接口约束实现它的子类必须有getByKey(key) 和 setByKey(key,value)

2、要求setByKey的时候的value的类型和实例化子类的时候指定的类型一致

  abstract class ObjectCache {
    getByKey(String key);
    void setByKey(String key, Object value);
  }

  abstract class StringCache {
    getByKey(String key);
    void setByKey(String key, String value);
  }

  abstract class Cache<T> {
    getByKey(String key);
    void setByKey(String key, T value);
  }

abstract class Cache<T>{
  getByKey(String key);
  void setByKey(String key, T value);
}

class FlieCache<T> implements Cache<T>{
  @override
  getByKey(String key) {    
    return null;
  }

  @override
  void setByKey(String key, T value) {
   print("我是文件缓存 把key=${key}  value=${value}的数据写入到了文件中");
  }
}

class MemoryCache<T> implements Cache<T>{
  @override
  getByKey(String key) {   
    return null;
  }

  @override
  void setByKey(String key, T value) {
       print("我是内存缓存 把key=${key}  value=${value} -写入到了内存中");
  }
}
void main(){

    MemoryCache m=new MemoryCache<String>();
     m.setByKey('index', '首页数据');

     MemoryCache m=new MemoryCache<Map>();
     m.setByKey('index', {"name":"张三","age":20});
}

3.14、库自定义库、系统库、第三方库

一丶库

前面介绍Dart基础知识的时候基本上都是在一个文件里面编写Dart代码的，但实际开发中不可能这么写，模块化很重要，所以这就需要使用到库的概念。

在Dart中，库的使用时通过import关键字引入的。

library指令可以创建一个库，每个Dart文件都是一个库，即使没有使用library指令来指定。

Dart中的库主要有三种：

1、我们自定义的库
import ‘lib/xxx.dart’;
2、系统内置库
import ‘dart:math’;
import ‘dart:io’;
import ‘dart:convert’;
3、Pub包管理系统中的库
https://pub.dev/packages
https://pub.flutter-io.cn/packages
https://pub.dartlang.org/flutter/
1、需要在自己想项目根目录新建一个pubspec.yaml
2、在pubspec.yaml文件然后配置名称、描述、依赖等信息
3、然后运行 pub get 获取包下载到本地
4、项目中引入库 import ‘package:http/http.dart’ as http; 看文档使用

二丶导入自己本地库

Animal.dart

class Animal{
  String _name;   //私有属性
  int age; 
  //默认构造函数的简写
  Animal(this._name,this.age);

  void printInfo(){   
    print("${this._name}----${this.age}");
  }

  String getName(){ 
    return this._name;
  } 
  void _run(){
    print('这是一个私有方法');
  }

  execRun(){
    this._run();  //类里面方法的相互调用
  }
}

import 'lib/Animal.dart';
main(){
  var a=new Animal('小黑狗', 20);
  print(a.getName());
}

三丶导入系统内置库 math库

// import 'dart:io';
import "dart:math";
main(){
    print(min(12,23));
    print(max(12,25));
}

四丶导入系统内置库实现请求数据httpClient

import 'dart:io';
import 'dart:convert';

void main() async{
  var result = await getDataFromZhihuAPI();
  print(result);
}

//api接口： http://news-at.zhihu.com/api/3/stories/latest
getDataFromZhihuAPI() async{
  //1、创建HttpClient对象
  var httpClient = new HttpClient();  
  //2、创建Uri对象
  var uri = new 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
这两个关键字的使用只需要记住两点：
只有async方法才能使用await关键字调用方法
如果调用别的async方法必须使用await关键字

async是让方法变成异步。
await是等待异步方法执行完成。

void main() async{
  var result = await testAsync();
  print(result);
}
//异步方法
testAsync() async{
  return 'Hello async';
}

六丶导入Pub包管理系统中的库

pub包管理系统:

1、从下面网址找到要用的库
https://pub.dev/packages
https://pub.flutter-io.cn/packages
https://pub.dartlang.org/flutter/

2、创建一个pubspec.yaml文件，内容如下

name: xxx
description: A new flutter module project.
dependencies:
http: ^0.12.0+2
date_format: ^1.0.6

3、配置dependencies

4、运行pub get 获取远程库

5、看文档引入库使用

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

main() async {
  // var url = "http://www.phonegap100.com/appapi.php?a=getPortalList&catid=20&page=1";

  //   // Await the http get response, then decode the json-formatted responce.
  //   var response = await http.get(url);
  //   if (response.statusCode == 200) {
  //     var jsonResponse = convert.jsonDecode(response.body);
     
  //     print(jsonResponse);
  //   } else {
  //     print("Request failed with status: ${response.statusCode}.");
  //   }
  
    print(formatDate(DateTime(1989, 2, 21), [yyyy, '*', mm, '*', dd]));
}

七丶库的重命名 Dart冲突解决

Person1.dart

class Person{
  String name;
  int age; 
  //默认构造函数的简写
  Person(this.name,this.age);  

  Person.setInfo(String name,int age){
    this.name=name;
    this.age=age;
  }

  void printInfo(){   
    print("Person1:${this.name}----${this.age}");
  }
}

Person2.dart

class Person{
  String name;
  int age; 
  //默认构造函数的简写
  Person(this.name,this.age);  

  Person.setInfo(String name,int age){
    this.name=name;
    this.age=age;
  }

  void printInfo(){   
    print("Person2:${this.name}----${this.age}");
  }
}

import 'lib/Person1.dart';
import 'lib/Person2.dart' as lib;

main(List<String> args) {
  Person p1=new Person('张三', 20);
  p1.printInfo();
  lib.Person p2=new lib.Person('李四', 20);
  p2.printInfo();
}

八丶部分导入

myMath.dart

void getName(){
  print('张三');
}
void getAge(){
  print(20);
}
void getSex(){
  print('男');
}

部分导入
如果只需要导入库的一部分，有两种模式：

模式一：只导入需要的部分，使用show关键字，如下例子所示：
import ‘package:lib1/lib1.dart’ show foo;

模式二：隐藏不需要的部分，使用hide关键字，如下例子所示：
import ‘package:lib2/lib2.dart’ hide foo;

import 'lib/myMath.dart' hide getName;

void main(){
//  getName();
  getAge();
}

九丶延迟加载

也称为懒加载，可以在需要的时候再进行加载。
懒加载的最大好处是可以减少APP的启动时间。

懒加载使用deferred as关键字来指定，如下例子所示：

import 'package:deferred/hello.dart' deferred as hello;

当需要使用的时候，需要使用loadLibrary()方法来加载：

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

4、常见问题

4.1、String和int互转

int.parse("100");
123.toString();

4.2、字符串(String)的相关方法

更多请参考原文

字符串定义
使用单引号或双引号

String a = “abcdefg”;
String b = ‘12345’;
创建多行字符串,保留内在格式
使用三个单引号或三个双引号创建多行字符串,保留内在格式，如换行和缩进等，里面写什么输出就是什么。
三个单引号
String e = ‘’'asd
fdsd
fff

''';

三个双引号　
String f = “”" 1
2
3
4
“”";

4.3、JSON

1.手动序列化JSON
Flutter中基本的JSON序列化非常简单，Flutter有一个内置的dart:convert库，其中包含一个简单的JSON解码器和编码器。下面简单实现一下：
详情请参考原文

4.4、

王睿丶

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
Dart 总结

1、Dart 安装一丶下载Dart（含SDK）https://gekorm.com/dart-windows/二丶设置环境变量【1】Name：DART_SDKKey：D:\program\Dart\Dart\dart-sdk【2】Name：PathKey：D:\program\Dart\Dart\dart-sdk;三丶检测是是否成功【1】dart --version四丶安装VSCode【1】可以参考我的博文：如何下载Visual Studio Code及配置教程【
复制链接

扫一扫