Dart 学习笔记一（操作符、方法与异常）

Dart变量

声明一个变量，可以用var、dynamic以及Object来声明变量，通过这几种类型声明的的变量赋任何类型的值，也可以指定类型String、int来声明变量,未初始化的变量值为null。

通过var、Object和dynamic三个类型声明的变量区别：
var：变量在赋值的时候，就决定了它的类型，如图
Object：与java一样Object是所有类的基类，它声明的变量可以是任意类，如图
dynamic：声明这样的变量，不是在编译时候确定类型，而是在运行时确定，dynamic声明的变量和使用与Object一样，关键在于运行时原理不同。

dynamic a;
 Object b;
 main() {
     a = "";
     b = "";
     printLengths();
 }   

 printLengths() {
     // no warning
     print(a.length);
     // warning:
     // The getter 'length' is not defined for the class 'Object'
     print(b.length);
 }
 //变量a不会报错, 变量b编译器会报错

声明变量注意事项：
没有初始化的变量自动获取一个默认值为null（类型为数字int和double变量如果没有初始化其值也是null）;
在声明变量的时候，也是可以选择加上具体类型String a = “name”;
对于局部变量，按照Dart代码风格推荐，使用var而不是具体的类型来定义局部变量。
dynamic与 var一样都是关键词,声明的变量可以赋值任意对象

dynamic与Object区别：
相同之处在于,他们声明的变量可以在后期改变赋值类型。
不同的是,dynamic声明的对象编译器会提供所有可能的组合, 而Object声明的对象只能使用Object的属性与方法, 否则编译器会报错。

final和const修饰符

• 在声明的变量中，如果不打算更改一个它，可以使用final和const来修饰变量，只能在声明时初始化且不能修改
  
• 从上图可以看出，final和const在使用上根本看不出区别，但是final是运行时常量，而const是编译器常量，它的值在编译期就可以确定，编译时常量能够让代码运行的更高效。
  
• 在类中可以用final类型来声明变量，但是不可以用const声明，如果想用const在类中声明变量，需要定义为static const静态常量。
  

Dart的内置类型

dart语言内置有一下几种类型：

• numbers
• strings
• booleans
• lists (也被称之为 arrays)
• maps
• runes (用于在字符串中表示 Unicode 字符)
• symbols

numbers

在Dart语言中num是数字类型的父类，包括两个子类 int(整数) 和 double(双精度)。
Dart的num（数值）类型，在编码的时候，可以将num当成java中的short 、int与long类使用，如果写的dart代码超过4个字节，那么dart会将其编译成类似java中的long，否侧编译成java中的short或者int。

Strings

• Dart的字符串是UTF-16编码单元的序列。字符串可以使用单引号或者双引号来创建。单引号和双引号可以嵌套使用，否侧就需要使用\进行转义。在Dart语言中，字符串还可以引用变量和表达式。
  
• 和java一样可以使用+操作符来把字符串拼接起来，也可以把多个字符串放到一起来实现同样的功能：
  
• 使用三个单引号或者双引号可以创建多行字符串对象。
  
• Dart还提供一个r前缀来创建一个“原始raw”的字符串。
  

Booleans

Dart 语言中有一个名字为 bool 的类型。 只有两个对象是布尔类型的：true 和 false 。这一点和Java一样。

Lists（列表）

Dart语言中，数组就是用List表示，也就是列表对象，对List遍历也是和java一样。

Maps（映射集合）

Map：键值对相关的对象。 键和值可以是任何类型的对象。每个键只能出现一次， 而一个值则可以出现多次。与List一样，在 map字面量之前添加 const 关键字，可以定义一个编译时常量的map。

Runes（用于在字符串中表示Unicode字符）

Unicode为世界上所有的书写系统中使用的每个字母，数字和符号定义了唯一的数值。 Dart 字符串是 UTF-16 位代码单元字符序列， 所以在字符串中表达 32位 Unicode 值需要 新的语法。Runes就是UTF-32字符集的string 对象。
表达Unicode代码点的常用方法是\uXXXX，其中XXXX是4位十六进制值。要指定多于或少于4个十六进制数字，需要将值放在大括号中。

Symbols

操作符标识符，可以看作C中的宏。表示编译时的一个常量

操作符和控制语句

和java不一样的操作符：
as、 is、 和 is! 操作符是在运行时判定对象 类型的操作符

操作符	解释
as	类型转换
is	如果对象是指定的类型返回 True
is!	如果对象是指定的类型返回 False

as 操作符把对象转换为特定的类型，但是如果无法完成转换则会抛出一个异常

  num j = 1;
  //类型转换 不支持 java： (int)强转写法
  int i = j as int;

is 和Java中的 instanceof 相同

Object o = 1;
if (o is int) {} //像java一样，判断int是否是Object类型
if (o is! int) {} //判断是否不是Object类型

赋值操作符

=、+=、\=、*=这些和java一样，还有一个 ??= 操作符是用来指定值为 null 的时候，将其赋值

   a ??= value; // 如果a是null，则value赋值给 a；
                // 如果不是null，则a的值保持不变

条件表达式

Dart 有两个特殊的操作符可以用来替代 if-else 语句：

• condition ? expr1 : expr2
• 如果 condition 是 true，执行 expr1 (并返回执行的结果)； 否则执行 expr2 并返回其结果。

  var a = 1 < 2 ? "1" : "2";
  print(a);//1<2为ture，打印：1

• expr1 ?? expr2
• 如果 expr1 不为null，返回其值； 否则执行 expr2 并返回其结果。

  var a;
  var b = a ?? "1";
  print(b); //a为null，打印：1

取整操作符

取整可以使用操作符（~/），如：

int a = 5；
int b = 2；
print(a~/b); //打印 2

级联操作符

级联操作符 (..)可以在同一个对象上连续访问成员变量和调用函数，使用级联操作符可以避免创建临时变量。

  Book()..title = "book_name"
    ..desc = "book_desc"
    ..toString();
    
  //StringBuffer write就像是Java的appends
  var sb = StringBuffer();
  sb..write('String')..write('Buffer');
  print(sb.toString()); //打印 StringBuffer

安全操作符

Dart语言提供了 ?.操作符。左边的操作对象如果为 null 则返回 null

  //在java中经常出现空指针异常，dart提供?.来进行对象判空处理
  String a;
  print(a.length); //空指针异常
  print(a?.length); //打印 null

循环

for、while和do-while和java使用一样，dart还有不一样的，如果迭代的对象是容器，那么可以使用forEach或者for-in：

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

var collection = [0, 1, 2];
collection.forEach((x) => print(x));//forEach的参数为Function
for(var x in collection) {
  print(x);
}

Switch and Case

与java有一些不同，Swith的参数可以是num，或者String

var fruits = 'APPLE';
switch (fruits) {
  case 'BANANA':
    break;
  case 'APPLE':
    break;
  default:
    print('Default');
}

注意，如果分句的内容为空，想要fall-through（落空），可以省略break，如果分句的内容不为空，那么必须加break，否则抛出异常：

var fruits = 'APPLE';
switch (fruits) {
  case 'BANANA':
  	print('BANANA');
    break;
  case 'APPLE'://产生落空效果，执行下一分句
  case 'ORANGE':
  	print('ORANGE');
    break;
  default:
    print('Default');
}// 打印 ORANGE

如果想要fall-through，case语句内容又不为空，而又不是按顺序落空，那么可以使用continue和标签：

 var fruits = 'BANANA';
  switch (fruits) {
    case 'BANANA':
      print('BANANA');
      continue nowClosed; //继续在nowClosed标签上执行.
    case 'APPLE':
      print('APPLE');
      break;
    nowClosed:
    case 'ORANGE':
      print('ORANGE');
      break;
  }//打印： BANANA  
           ORANGE

函数

Dart 是面向对象语言，函数（或方法）也是对象并且具有一种类型 Function。 这意味函数可以赋值给变量，也可以当做其他函数的参数。

函数定义

	int add(int i,int j) {
  		return i + j;
	}
	//也可以选择忽略类型(不推荐)
	add( i, j) {
 		 return i + j;
	}
	//对于只有一个表达式的方法，可以选择使用缩写语法来定义：
	add(i, j) => i + j; //在箭头(=>)和分号(;)之间只能使用一个表达式

注意：
函数也是对象，没有指定void来修饰，函数都有返回值。
在没有指定返回值的时候，函数会返回 null。
如果在函数指定了void来修饰，则函数真的没有返回值。

函数参数

方法可以有两种类型的参数：必需的和可选的。 必需的参数需要在参数列表前面， 后面再定义可选参数。

可选命名参数

把方法的参数放到 {} 中就变成可选 命名参数。

   String add({int i, String s}) {
		 return "$i $s";
   }

调用方法的时候，可以使用这种形式 paramName: value 来指定命名参数。例如：

String add({int i, String s}) {
 		 return "$i $s";
	}
	
void main(){
	//无必须参数
	print(add()) //打印  null null
	//选择传递参数
	print(add(i:1)) //打印  1 null
	//传入参数与位置无关
	print(add(i:1, s:"a")) //打印  1 a
	print(add(s:"a", i:2)) //打印   1 a
}

可选位置参数

把方法的参数放到 [] 中就变成可选 位置参数，传值时按照参数位置顺序传递。

String add([int i, String s])
{
	return "$i $s";
}
   
void mian(){
   // 1赋值给i
   print(add(1));  //打印  1 null
   // 正确 按照顺序赋值
   print(add(1, "a"));  //打印  1 a
   //编译错误
   print(add("a", 1));
}

默认参数值

在定义方法的时候，可选参数可以使用 = 来定义可选参数的默认值。

	//可选命名参数 设置默认参数和调用方式
	String add(int i, {String s = "a", int j = 0}) {
     	return "i: $i s: $s j: $j";
	}
	//调用方式：
	print(add(1, s:"b"));//打印 i:1 s:b j:0
	print(add(1, s:"b"，j:=2));//打印 i:1  s:b  j:2
	
	//可选位置参数 设置默认参数和调用方式
	String add(int i, [String s = "a", int j = 0]) {
     	return "i: $i s: $s j: $j";
	}
	print(add(1,  "b"));//打印 i:1  s:b  j:0
	print(add(1,  "b", 2));//打印 i:1  s:b  j:2

区别：
可选命名参数：参数与顺序无关，无需按顺序传参，且传参数时需使用冒号。
可选位置参数：参数与顺序相关，传参必须依照顺序。

匿名函数

和java一样，dart语言也是有无名字的函数，称之为匿名方法，也可以称之为 lambda 或者 closure 闭包。

	([Type] param1, …) { 
 	 	codeBlock; 
	}; 

如：

var list = ['A', 'B', 'C', 'D', 'E'];
list.forEach((i) {
  print(list[i]);
});

注意，匿名函数与普通函数基本相同，也有参数列表，函数体，只是省去了函数名而已。

异常

和 Java 不同的是，所有的 Dart 异常是非检查异常。 函数不一定声明了他们所抛出的异常， 并且不要求你捕获任何异常。
Dart 提供了 Exception和Error 类型， 以及一些子类型。你还 可以定义自己的异常类型。但是， Dart 代码可以 抛出任何非 null 对象为异常，不仅仅是实现了 Exception 或者Error 的对象。

	//抛出固定类型的异常
	throw new Exception('This is a Exception');
	//抛出任意类型的异常
	throw '这是一个异常';
	throw 111;

​ 与Java不同之处在于捕获异常部分，Dart中捕获异常同样是使用catch语句，但是Dart中的catch无法指定异常类型。需要结合on来使用，如下：

try {
	throw 123;
} on int catch(e){
	//使用 on 指定捕获int类型的异常对象       
} catch(e,s){
    //函数 catch() 可以带有一个或者两个参数， 第一个参数为抛出的异常对象， 第二个为堆栈信息 ( StackTrace 对象)
    rethrow; //使用 `rethrow` 关键字可以 把捕获的异常给 重新抛出
} finally{
	//Dart的finally用来执行那些无论异常是否发生都执行的操作,并且在所有匹配到的catch子句之后运行。
	
}

’

Dart 学习笔记二（ 类与构造函数 )
Dart 学习笔记三（ 异步编程 ）