Flutter：Dart语言笔记

说明：

Dart没有关键字public、protected、private
以下只列出java的不同之处：

一、变量：
任何保存在变量中的都是一个对象

1.变量定义：
默认值为null

2.final与const：
(1)final：
定义变量时可以不赋值，后面只能赋值一次。

例：
final String a;
a = “值”;
或
final String a = “值”;

(2) const：
定义变量时必须赋值，后面不能更改。

例：
const String a = ‘值’;
const a = ‘值’;  //与上面等同
List<int> list = const [1, 2]; //定义为常量，list[position]的值不能修改
final map = const { //定义为常量，map[‘key’]的值不能修改
  ‘key’: ‘value’
};

二、类型：
1.字符串与数值互转：
(1)字符串转int：
int a = int.parse(‘1’);

(2)字符串转double：
double a = double.parse(‘1’);

(3)int转字符串：
String a = 1.toString();

(4)double转字符串，并保留2位小数：
String a = 3.14159.toStringAsFixed(2);

2.泛型(根据值自动转换)：
var a = “值”;
dynamic a = “值”;

3.字符串：
(1)使用单引号或者双引号创建。
(2)== 运算符比较两个是否相等。
(3)可以用+连接多个字符串，每行首尾单/双引号实现多行字符串的创建：

String str = 'a’
’b’;

(4)三个连续单引号或者三个连续双引号实现多行字符串的创建：
String str = '''a
b’’’;
String str = '' '' ''a
b’’ '' '';

(5)$实现插值：
int a = 0;
String b = '$a';  //b的值为'0’

(6)使用 r 前缀，可以创建 “原始 raw” 字符串不进行字符串转义：
var a = r''a \n b'';

4.布尔，bool：
不能用在if与assert中

5. List：
(1)创建，取值，value可以为其他类型：
List<int> list = [1, 2]; //创建List
list[0];  //取值

(2)遍历循环：
list.forEach((item) {
    list.indexOf(item);  //item在list中的position位置
    Item;  //获取当前position所在的值
});

6.Map，key和value可以为其他类型：
Map<String, String> map = {  //创建有值的Map
  ‘key1’: ‘value1’,
  ‘key2’: ‘value2’
};
map[‘key1’];  //取值
Map<String, String> map = Map(); //创建空Map
map[‘key1’] = ‘value1’;  //设值
map.length;  //获取Map键值对个数

7. Rune：
runes 用来表示字符串中的 UTF-32 编码字符

8 Symbol：
标识符前面添加一个 # 号，来获取标识符的 Symbol
例：#radix

三、运算符：
和java基本一致
1.类型检查运算符：
(1)as，指定对象类型(类似Java：(User)user)：
(user as User).name = “值”;

(2)is和!is，判断类型(类似Java：user instanceof User)：
if(user is User){
}
和
if(user !is User){
}

2.赋值运算符：
a ??= “值”   //a为null时，才进行赋值

3.条件表达式：
a ?? b  //a不为null返回a，a为null返回b

4.级联运算符：
Glide..with()..load()等同于：
Glide g = Glide.with();
g.load();

5.其他运算符：
?. 运算符：
User user = null;
user?.getName();  //不会抛异常

四、流程控制：
1.switch：
语句使用 == 比较，每个case必须带break或return或continue或throw。
可以使用字符串作为switch中的值，例：
Var str = ‘字符串’;
switch(str){
      case ‘值1’:
       break;
}

2.断言 Assert：
assert括号中的值为false时，中断程序，
例：assert(str != null);

五、函数：
1.方法可以不声明返回类型和参数类型：
setName(name) {
  表达式;
}

2.方法中只有一句表达式时，可以用=>：
在箭头 (=>) 和分号 ( ; ) 之间只能使用一个表达式
格式：
返回值类型  函数名(型参)  =>  表达式;
例：
String getName() => 表达式;
等同于：
String getName() {
   return 表达式;
}

3.命名参数(定义与调用时都指定参数名)：
(1)定义方法时，指定命名参数：
格式：
返回值类型 方法名({类型1 参数名1，类型2 参数名2}){
}
例：
void setValue({bool a, int b}){
}

(2)调用方法时，指定命名参数：
格式：
方法名(参数名1: 值1, 参数名2: 值2…);

例：
setValue(a: true, b: 123);

4.可选参数(调用方法时，参数值可传可不传)：
格式：
返回值类型 方法名(类型1 参数名1，[类型2 参数名2, 类型3 参数名3]){
}

定义例子：
void setValue(bool a, [int b]){  //类似java中的…
}

调用例子：
setValue(true);
setValue(true, 123);

5.默认参数值(定义时给参数设置默认值)：
返回值类型 方法名(类型 参数名 = 值]){
}

定义例子：
void setValue(bool a = false){
}

6. main函数，有两种：
void main() {}
void main(List<String> args) {}

7.函数作为对象使用：
(1)函数作为参数传递给另一个函数：
String getName(){
       return “名称”;
}
setName(getName());

(2)函数赋值给变量：
String name =  getName() => “名称”;

8.匿名函数(没有名称，没有定义返回类型的函数)：
(类型 参数名){
     表达式;
}
或
(类型 参数名) => 表达式;
例如：
setName((String a) => a);

9.闭包：

10.返回值：
所有函数都返回一个值。如果未指定返回值，则将语句 return null; 隐式附加到函数体。 也就是说，如果函数不添加返回值。 则默认返回null;

六、异常：
Exception 和 Error 类型
1. throw抛出异常，可以抛出任何非 null 对象：
throw ‘异常描述’;
throw 异常类(‘异常描述’);

2. catch和finally：
try {
  表达式;
} on Exception {//捕获此异常，和下面同个效果
} on Exception catch (e) {// 捕获此异常，和上面同个效果
} catch (e) {// 没有指定的类型，捕获所有异常
} finally {//不管是否抛出异常， finally 中的代码都会被执行
}

七、类：
1.类定义：
说明：所有对象中的变量都生成隐式 getter 方法。 非 final 的实例变量同样会生成隐式 setter 方法。
class User{
     var name;   //类变量
}

2.创建对象(new可省略)：
(1)创建普通对象：
var a = new A();
var a = A(); //等同上面

(2)调用常量构造函数，创建常量：
var a = const A();  //a为常量，A为常量构造函数

3.对象调用属性或方法：
user.name
user?.name   //这种方式防止对象为null导致异常

4.获取对象的类型：
对象名.runtimeType

5.构造函数：
(1)定义构造函数：
class User{
     var name;   //类变量
     User(var name){  //构造函数，默认有一个无参的构造函数，子类不会继承父类的构造函数
          this.name = name;
     }
}
或如下这种，等同上面
class User{
     var name;   //类变量
     User(this.name);  //构造函数
}

(2)命名构造函数：
class BaseUser {
  var name;
  BaseUser.create(this.name) ;  // 给构造函数设定一个名称叫create，自定义
}

(3)调用父类非默认构造函数：
class User extends BaseUser {
  User() : super.create(“先生”);  //create为父类命名构造函数
}

(4)初始化实例变量列表(在调用父类构造之前执行)：
// 在构造函数体执行之前，
// 通过初始列表设置实例变量。
User.create(String str) : name = str{
}

(5)重定向构造函数(调用本对象的this构造函数)：
User.toThis() : this();

(6)常量构造函数：
class User{
    final String name;  //所有字段为final
     const User(this.name);  //加const定义为常量构造函数
}

(7)工厂构造函数：
已经创建的返回实例，没有的创建后缓存着，供下次使用，返回方法使用 factory 关键字修饰。
class User{
    static User user;
    factory User(){ //加factory定义为工厂构造函数
            if(user == null){
                    user = User();
            }
            return user;
      }
}

6.抽象类和抽象方法：
abstract class A {//抽象类
  void a(); // 抽象类类中的方法为抽象方法
}

7.隐式接口：
每个类都隐式的定义了一个接口，接口包含了该类所有的实例成员及其实现的接口。

8.继承和重写：
class B{
    void b1(){}
}
class  A extends B{//继承
    @override //重写
    void b1(){
     }
    void a1(){
         super.b1(); //调用父类的方法
    }
}

八、dart:core库使用：
1. 打印日志：
print(‘内容’);

2.类型转换;
(1)字符串转为数值型：
int.parse(‘字符串数字’);
double.parse(‘字符串数字’);
num.parse(‘字符串数字’);

(2)数值转为字符串：
数字.toString();
带小数数字.toStringAsFixed(2);  //转为字符串，并且指定小数保留位数
数字.toStringAsPrecision(2);   //转为字符串，并且定字符串中的有效数字的位数

3.String字符串操作：
(1)ab是否包含a：
’a’.contains(‘a’);

(2)ab是否以a开头：
‘ab’.startsWith(‘a’);

(3)ab是否以b结尾：
‘ ab’.endsWith(‘b’);

(4)查找a在ab中的位置：
’ab’.indexOf(‘a’);

(5)字符串截取：
‘abcdef’.substring(0, 2);  //值为ab

(6)字符串以分隔符进行分组：
var list = ‘a.b’.split(‘.’);

(7)取字符串所有 UTF-16 编码单元：
‘ab’.codeUnits.toList();

(8)转为大写字母：
‘a’.toUpperCase();  //结果为A

(9)转为小写字母：
‘A’.toLowerCase();  //结果为a

(10)去除字符串前后空格：
‘  a  ’.trim();  //结果为a

(11)检查字符串是否为空：
''.isEmpty);  //为空
‘a’. isNotEmpty() //不为空

(12)替换部分字符串：
‘aba’.replaceAll(‘a’, ‘x’);  //结果为xbx

4.StringBuffer操作：
//结果为ab-c
var sb = StringBuffer();
sb..write(‘a’)
..writeAll([‘b’, ‘c’], ‘-’);  //第2个参数为分隔符，将字符串数组加入到sb中，每个item以分隔符隔开

5.正则函数：
String regStr = RegExp(‘正则表达式’);  //正则字符串
‘abc’.hasMatch(regStr));  // abc中是否有匹配正则字符串的
// 迭代所有匹配
for (var item in ‘abc’.allMatches(regStr)) {
}

6. List常用API：
var list = List();  //创建一个List
var list = [‘a’, ‘b’];  //创建一个List
list.add(‘a’);  // 添加一个元素到 list 。
list.addAll([‘a’, ‘b’]);  // 添加多个元素到 list 。
list.length   //获取 list 长度
int position = flist.indexOf(‘a’);  //a在list中的位置
list.removeAt(0);  //移除第0个
list.clear(); //清空列表
list.sort((a, b) => a.compareTo(b));  //排序
list.forEach((item) => //表达式); //循环List
list.where((item) => //表达式); //循环List

7. Set常用API：
var set = Set();  //创建一个Set
Set.from(['a', ‘b’]); //创建一个Set
set.add(‘a’);  // 添加一个元素到 set
set.addAll([‘a’, ‘b’]);  // 添加多个元素到 set
set.contains(‘a’); //set中是否有a元素
set.containsAll([‘a’, ‘b’]);//set中是否有a和b元素
set.remove(‘a’);  //移除元素
var set3 = set1.intersection(set2);  //对set1和set2进行交集，创建set3

8. Map常用API：
var hawaiianBeaches = { //创建一个Map
  ‘key1’: [‘a’, ‘b’,],
  ‘Key2’: [‘a’, ‘b’]
};
var map = {}; //创建一个Map
var map = Map(); //创建一个Map
var map = Map<String, String>(); //创建一个Map
var map = {‘key1’: ‘value1’};  //添加一个元素到 Map
map[‘key1’];  //获取元素值
map.containsKey(‘key1’);  //是否包含此key
map.remove(‘key1’); // 移除元素
Iterable keys = map.keys; //获取map中所有key列表
Iterable values = map.values; //获取map中所有value列表
map.putIfAbsent(‘key1’, () => pickToughestKid()); //当不存在key1时，才能用这种方式
map.forEach((key, value) {//循环map
  //表达式;
});

9. Iterable：
var list = …;
var list2 = list.map((item) => //表达式).toList;//将所有结果返回到一个对象中
var set = list.map((item) => //表达式).toSet;//将所有结果返回到一个对象中

10.集合通用：
list.any(true)  //使用 any() 来检查集合中是否至少有一个元素满足条件。
list.every(true); //使用 every() 来检查集合中是否所有元素满足条件。