android（JAVA）转Dart的学习笔记

注意：本文仅为个人学习时的笔记，如果有帮助就给点个赞，如果有错误之处还望提出。

1、启动方法是main方法，写法如下：
void main（）{//main方法里面没有参数，同时也可以没有void
    //......
}
2、字符串可以用3个单引号或3个双引号定义一个段落（带换行的）
3、数字类型疑似只有int和double
4、布尔类型为bool
5、数组可以是常规的，也可以是List，比如：
var list= new List(); //也可以指定类型，如：var list= new List<String>();
list.add("111");
print(list);//这里打印出来：[111]

6、循环语句中for可以有两种写法：
1）for(int i=0;i<10;++i)
2）for(var item in list)//这种方法把list中的值一个个的赋值给item下面可以使用它
3）list.forEach((value){...做点啥...});//这方法可以在“做点啥”区域中对list中的每个value取值操作
4）List otherList = list.map((item){..做点啥...}).toList();//map方法可以在“做点啥”处对list中的值进行取值操作【同forEach】
5）List otherList = list.where((item){ return item>5 }).toList();//where方法可以将满足条件的值返回成一个新List
6）bool isTrue = list.any((item){ return item>5 }).toList();//any方法可以判断List中是否有满足条件的值，只要有满足条件的值就返回true（否则false）
7）bool isTrue = list.every((item){ return item>5 }).toList();//every方法同any方法，但是要求每个值都满足条件才返回true（否则false）
8）对于Set类型的循环详见16 （也是用forEach）
9）对于Map类型的循环详见17 （也是用forEach）

7、判断数据类型 用  is  关键字，如下
var aaa="1123";
if(aaa is String){
    print("当前是字符串类型");
}else if(aaa is int){
    print("当前是数字类型");
}

8、运算符中加减乘都跟java一样，但是除（/）得到的是真实的除数，如：13/5=2.6而并非java中的2。但是要想得到取整的除法可以用“~/”如：13~/5=2

9、字符串的判断可以直接用 “==”来判断，如：
String str = '123';
if(str=="123"){
    print("进来");//这时会进来打印
}

10、条件运算符（条件?真值:假值）跟java一样，但是还有个双问号的条件运算符“??”，如：
var a;
var b = a ?? 10;
print(b);//此时打印的值是10
--------
var a = 20;
var b = a ?? 10;
print(b);//此时打印的值是20
=============
有上述可知，双问号的条件运算符用法：如果前面是空，则将后面的返回，如果前面非空，则将前面返回；
【结合上述8，还有个“??=”的运算符用法，可以尝试用下】

11、类型转换的用法
int 转 String则用“int.parse()”，而String转int则用“int.parse(str)”,String转double则用“double.parse(str)”
如：
String str="123";
var number = int.parse(str);
if(number is int){
    print("被转成了数字类型");
}
---------
int num = 123;
String strNum = num.toString();//通过这个方式将数字转成字符串

12、try{}cache(err){}这里主要想说，cache后面接收参数时是没有数据类型的，这也许是dat语言类似JS的一个特性

13、判断字符串是否为空字符串用 isEmpty() 方法，如：
var str = "";
if(str.isEmpty()){
    print("字符串为空字符串");//这里会被打印
}
---------
var str;
if(str == null)){
    print("字符串为null");//这里会被打印
}
----------
有一种情况不会报错而是报“NaN”,如：
var nanErr = 0/0;
print(nanErr);//此时并不会报错，而是会打印“NaN”
要判断是不是“NaN”可以用 isNaN 属性（注意，这个不是方法，后面没有括号），如：
if(nanErr.isNaN){
    print("nanErr是NaN");//此时会打印
}

14、List的一些常用方法
List myList = ["111","222","333"];
1）print(myList.length);//打印出List数组的长度：3
2）print(myList.isEmpty);//打印出List是否有值：true
3）print(myList.isNotEmpty);//打印出List是否没有值：false
4）print(myList.reversed);//打印出List数组的倒叙：(333, 222, 111)    【注意，这里已经不是List类型了】
5）List myListReversed = myList.reversed.toList();//通过toList()方法将上述倒叙的值又转成了List类型
   print(myListReversed);//打印出：[333, 222, 111]    【注意，这里是List类型，结果是中括号括起来的】
6）添加一个值用add()方法，如：myList.add("444"); 此时List后面就加了个值
7）myList.addAll(["444","555"]); 通过这个方法可以拼接两个数组到myList数组中
8）print(myList.indexOf("222"));//打印出内容“222”所在的下标位置（查不到数据就返回：-1）
9）myList.remove('111');//该方法可以删除“111”的值
10）myList.removeAt(2);//该方法可以删除下标为2的值
11）myList.fillRange(1,3,"aaa");//该方法将myList数组中下标1~3的所有数据都替换成“aaa”
12）myList.insert(2,"aaa");//该方法将在myList数组的2下标处插入一个“aaa”的值
13）myList.insertAll(2,['aaa','bbb']);//该方法将后面['aaa','bbb']的值都插入下标2位置
14）var str = myList.join("分隔符");//该方法将myList的值转化成字符串并以“分隔符”隔开（如分隔符是逗号的话那么：str就等于111,222,333）

15、字符串也有split方法，同JAVA

16、Set的一些常用方法
1）Set的特性同java都是可以相同值只留一个
var set= new Set();
set.add('a');
set.add('b');
set.add('b');
print(set);//打印出{'a','b'}【注意是大括号】
2）print(set.toList());//打印出['a','b']  【注意是中括号，转成List了】
3）set.addAll(['c','d']);//一次性添加一个数组
4）循环打印Set中的值：
set.forEach((item)=>print(item));//这样就把set中的值一个个的取出赋值给item并打印

17、Map的用法
var myMap = {
    "key1":"value1",
    "key2":123
}
1）print(myMap);//打印出：{key1:value1, key2:123}
2）//要打印单个值，则这么写：
print(myMap["key1"]);//打印出：value1
--------------
3）Map的第二种用法：
var myMap = new Map();
myMap["key1"]="123";
myMap["key2"]=123;
myMap["key3"]=["亿号","二号","三好"];
print(myMap);//打印出{key1:123,key2:123,key3:[亿号,二号,三好]}
--------------
4）获取Map的Key列表用myMap.keys.toList();方法可以获取个List类型的Map的Key列表如["key1","key2","key3"]
5）同上，可以通过myMap.values.toList();方法将value值转化成List类型
6）可以通过myMap.isEmpty()方法和maMap.isNotEmpty()方法判断Map是否为空
7）可以通过myMap.addAll(Map)方法添加另一个Map到当前Map中
8）可以通过myMap.remove('key1');方法删除一个值
9）可以通过myMap.containsValue('key1');方法判断Map中是否含有某个值
10）循环打印Map的值：
myMap.forEach((key,value){
    print("$key >> $value");//打印出了每个key-value的值【这里“$key”的用法实际上是字符串拼接的一种（占位符法）】
});

18、方法中也可以嵌套方法。方法也可以不写返回值但是有返回内容。
1）被嵌套的方法只能在父方法作用域中调用，如：
void fun1(){
    void fou2(){
      print('111');
    }
    fou2();//这里调用局部方法。打印了“111”
}
2）方法可以不写返回类型，建议写上返回类型，如：
fun1(String str){
    return str;
}
String num = fun1('111');
print(num);//这里打印“111”字符串
3）方法中定义可选参数的方式，如：
fun1(String str,[int num]){
    if(num != null){
        print("当前数字是：$num");//这里，如果num传值的话会打印，不传值的话就进不来
    }
}
//调用方式如下两种
fun1("只传一个值");//可以不传num的值
fun1("传两个值",123);//也可以传num的值
4）方法中的可以选参数可以给他附上一个默认值，做人如下：
fun1(String str,[int num=2]){
    if(num == 2){
        print("当前数字是：$num");//这里，如果num传值的话会打印传入的值，不传值的话就打印默认值“2”
    }
}
//调用方式如下两种
fun1("只传一个值");//可以不传num的值，这时会打印默认值“2”
fun1("传两个值",123);//也可以传num的值，这时会打印“123”
5）方法中也可以有命名参数，写法跟可选参数的写法不同点在意中括号改成大括号，如下：
fun1(String str,{int num=2}){
    if(num == 2){
        print("当前数字是：$num");//这里，如果num传值的话会打印传入的值，不传值的话就打印默认值“2”
    }
}
//调用方式如下两种
fun1("传两个值", num:123);//这里命名参数的调用方式要注意，传参的时候要带上参数名冒号值
6）方法中的参数可以传入另一个方法，如下：
fun1(funName){
    funName();//这里执行一下传入的方法，打印出“123”
}
fun2(){
    print("123");
}
fun1(fun2);//这里将fun2这个方法的整体传给了fun1
7）匿名方法的写法，如下：
var fun = (){print('111');} //这种方式就是把一个方法赋值给了fun。执行fun就是执行了匿名方法
8）只执行方法，不需要调用，程序启动就执行（跟java中的静态域类似）。写法如下：
((int num){    print("我是自执行方法：$num");   })(12);  //就是两个并排的小括号，前面括号里放个匿名方法。【后面的12是传入参数，传给了前面的num】

19、箭头函数。箭头函数只能写一句话，并且不需要“;”结尾，如：
var arr=['1','2','3'];
1）arr.forEach((item)=>print(item));
2）arr.forEach((item)=>{print(item)});//这里即使用大括号括了起来，里面也只能写一句话，也不能有分号结尾

20、闭包的写法，我不想定义全局变量，又想让全局使用，就可以用闭包的写法，如下：
fun(){
  var number = 123;
  reutn (){        //这里返回一个局部方法。
    number ++;
    print(number);
  }
}
//调用
var mFun = fun();
mFun();//此时打印：124
mFun();//此时打印：125
mFun();//此时打印：126

21、类的定义，类用class定义，写法如下：
1）class People{
    String sex = "男";
    int age = 10;
    People(this.sex);//这个是默认构造函数的简写，传入的值会直接赋值给sex属性
    People.getName(){//命名构造函数可以写多个，各种各样的。
        print("我是命名构造函数，调用时这么写：var peo = new People.getName();");
    }
    People():sex='女',age=12{
    //上面构造方面后面可以直接给属性赋值
    }
    People(int zidingyicanshu){
        print("我是构造函数，跟JAVA一样用法");
    }
    void fun(){
        print(sex);
    }
}
//用法
void  main(){
    People people = new People();//初始化
}
---------------
2）私有属性的定义，就是直接在数据名前面加个下划线，要注意，只有将类单独写成一个文件的情况下，私有属性才能起效。如：
在People.dart文件中定义一个类：
class People{
    String _sex = "男";//sex前面加下划线，变成“_sex”这个值就是私有的。外类访问不到
    void _fun(){ //方法名前面加下划线，变成私有方法。外类访问不到
        print(_sex);
    }
}
在另一个dart文件中访问时：
import 'lib/People.dart';
voie main(){
  People peo = new People();
  peo._fun();//这里无法调用
  peo._sex;//这里也无法调用
}
---------------
3）get方法的写法：
class People{
    String _sex = "男";
    get sex{ //不需要小括号
        if(_sex=='男')print(_sex);
    }
    set setSex(s){//set方法写法上需要小括号接受值
        this._sex = s;
    }
}
new People().sex; //外面调用时像属性一样调用
new People().setSex='女';//外面调用时就行属性一样直接等于一个值

22、静态（static）的用法同java

23、运算符：
1）?    条件运算符
如果一个示例是null直接调用时会报错，但是用“?”标记后直接调用就不会报错，同时也不会有调用结果，如：
People peo;
peo?.setSex="未知";//这边peo后面带了个条件运算符“?”则调用时就不会报错【自己理解：先判断问号前面的值是否为空，不为空则执行后面的，为空则不执行】
2）as   类型转换
var peo;
peo = "我是字符串";
peo = new People();
peo.setSex = "男";//这里会报错
(peo as People).setSex = "男";//这里就将peo强制转换成了People类型了。【应该是需要先初始化People的】
3）is   类型判断
判断某；实例是否为某类型。比如：所有类都是Object的子类，那么：print(peo is Object); 这句话就会打印true
4）..   级联操作（联缀）
一般情况下有这样一段代码：
People peo = new People();
peo.setSex='男';
peo.run();//假设People中有这个方法
------
上述写法可以用“..”来级联：
People peo = new People();
peo..setSex='男';
   ..run();//这里前面要有空格（可能是Tab，不记得了）
这样写法就是级联操作。是一种上述方法的简化的写法。

24、Dart中也有封装、继承、多态。同JAVA。
其中继承也是用extends，如果父类中有自定义的有参构造函数，子类中也要有，并且可以这样给父类中的构造函数赋值：
class ZhangSan extends People{
    ZhangSan(String sex):super(sex){ ... } //用super调用父类方法和属性
}

25、接口跟抽象类的写法一致，同一个abstract类可以extends继承，也可以implements去实现接口。
1）单继承用extends来实现，如：class MyClassA extends MyClassB{ ... }
2）多继承通过with来实现（即mixins），如：class MyClassA with MyClassB,MyClassC{ ... }
3）实现接口用implements，如：class MyClassA implements MyClassB,MyClassC{ ... }
4）不能演戏继承，A继承了B，那么B就不能再继承C。同样的abstract类不能继承其他类。
5）作为mixins继承的父类不能有构造函数，否则子类mixins继承时会报错，但是单继承extends是可以的。
那么又想父类有构造函数，又想多继承可以这么写：
class MyClassA extends MyClassD with MyClassB,MyClassC{ ... }//这里继承了一个D，同时mixins了B和C
6）多继承或多实现的各个父类中，如果都有同一方法，那么子类中调用这个方法时会以最后继承或实现的类中的方法为准（后继承的会覆盖先继承的同名方法）
7）print(MyClassA is MyClassB);//打印出来的是true，即：子类类型判断是不是父类类型时，得到的结果为true

26、泛型方法的定义（泛型为调用时指定数据类型的一个功能）
T getValues<T>(T value){
  return value;
}
上面这个就是泛型方法的定义，调用时：
String value = getValues<String>("123"); //这个调用方式是对的
int value = getValues<String>(123); //这个调用方式是错的，因为指定了泛型为String却传了个int，另外返回值也应该是String而不能是int，导致编译错误。
那么，希望返回值是任意值，而传入值是某泛型，则可以去掉返回值的泛型，定义如下
getValues<T>(T value){
  return value;
}
这样，返回值就可以是任何值了。如：
String value = getValues<String>("123"); //调用方式正确，可以赋值给String
int value = getValues<String>("123"); //调用方式正确，可以赋值给int
---------------------
泛型类的写法同JAVA，
泛型接口的写法也参考java跟dart的结合写法。

27、库的定义和使用
1）自定义库
①自定义库，即把自己写的class类存放到单独的文件中（如 MyClass.dart）
②再使用的地方通过import "mypath/MyClass.dart";  方式引入自己写的库。
③当前类中就可以直接初始化并使用这个自定义的库了。
综上：可见，库的概念同java的封装。将一个类的内容单独写到一个代码文件中，在其他类中可以引入并使用。
2）系统自带库
引入系统库的方式如下：
import "dart:math";
①引入系统库的方式是以“dart:”开头的，而并非自定义库的那样引用到某个路径
②引入了系统库后调用math的min方法时无需初始化（new）这个math类，可以直接调用：int minNum = min(2,3); //这里minNum的值为2
3）公开库
公开库被托管到了pub中，可以通过http://pub.dev进行查找自己想要的库，并根据教程下载和引入自己的工程

28、异步
关键词：async（异步），await（等待） 。这两个关键词往往同时使用，然而，只有用了async的情况下才能用await
异步方法用法如下：
//定义异步方法
testAsync async(){
    return "返回一个需要耗时操作的逻辑结果";
}
//调用异步方法
main async(){//只有异步方法才能调用异步方法
    String asyncValue = await testAsync();//调用的时候，需要等待异步方法执行完毕
    print(asyncValue);
}