[TOC]
主要介绍dart的一些语言规范和语法。
dart入口函数
main(){
print("hello");
}
void main(){
print("hello");
}
变量
dart可以通过var来定义变量，可以自动推导出变量类型；也可以显示的声明变量类型。
void main(){
var name = "lili";
// name = 123;//这里编译器就会报错，因为dart2.x是强类型语言，有类型校验，之间声明时已经将name自动推导为string，这点和python等弱类型语言不同
String address = "china";
int age = 1;
}
变量命名规则：
- 变量名必须由数字、字母、下划线和美元符号（$）组成。
- 数字不能开头。
- 不能是保留字和关键字。
- 区分大小写。
常量
dart中使用final和const来定义一个常量。
两者的主要区别在于final可以用于修饰运行时常量，它只能被赋值一次，在使用时初始化；而const只能用于修饰编译时常量。
void main() {
const name = "lili";
final age = 11;
//const date_1 = new DateTime.now();//错误：Const variables must be initialized with a constant value.
final date_2 = new DateTime.now();
}
常用数据类型
int：只能是整型
-
double：可以是浮点型或者整型
void main() { int a = 1; double b = 2; double c = 3.5; } -
String
void main() { var name = "lili"; //字符串拼接 print("hello $name"); print("hello " + name); var address = """ 窗前明月光， 疑是地上霜 """; print(address); } bool：true或false
-
List/Set
void main() { var list_1 = [1,2,3]; var list_2 = [1,2,"3"]; var list_3 = new List(); var list_4 = new List<int>();//指定集合类型 var list_5 = new List(3);//指定集合长度 } -
Map
void main() { var map_1 = {"name":"lili","age":18}; var map_2 = new Map(); var map_3 = new Map<int,String>();//key可以不为string map_3[1]="123"; }
可以用is关键字来进行类型判断，等同于java中的instance。
运算符
| 运算符 | 具体符号及代表意义 |
|---|---|
| 算术运算符 | +、-、*、/、%、~/（向下取整） |
| 关系运算符 | == 、!=、>、<、<=、>= |
| 逻辑运算符 | !、&&、|| |
| 赋值运算符 | =、??=（为空才赋值）、+=、-=、*=、/=、%=、~/=、++、-- |
| 条件表达式 | if else、switch case（同java） |
| 三目运算符 | ?:（同java） |
| ??运算符 | ?? |
void main() {
var a = 2;
var b = 3;
print(a ~/ b); //0
print(1 / 0); //Infinity
a ??= 4;
print(a); //2 因为a不为空，所以没有赋值为4
var c = a ?? 5;
print(c); //2 如果a为空，则c=5，否则c=a
var e;
print(a); //2
e ?? a++;
print(a); //3
}
循环
- for循环
- while循环
- do...while循环
三者的使用方式基本同其他编程语言，这里简单介绍下。
for
void main() {
for (int i = 0; i < 10; i++) {
print(i);
}
var list = [1,2,3];
for(var item in list){
print(item);
}
}
while和do...while
void main() {
int i = 0;
while(i<10){
print(i);
i++;
}
i = 0;
do{
print(i);
}while(i<10);
}
break和continue
- break：停止当前循环
- continue：跳过当前循环体，继续下一次循环
函数
函数的定义
返回类型 方法名称（参数列表）{
方法体；
return 返回值；
}
返回类型可以省略，会自动推导。
函数的嵌套
dart中的方法是可以嵌套的，此时内部方法只能在外部方法内调用：
void main() {
int sum(int a,int b){
return a+b;
}
print(sum(1, 2));//3
}
可选参数
通过[]可以声明一组可选参数，可选参数可以有默认值。如果调用方法时没有传入该可选参数，则会使用它的默认值，如果没有默认值则默认为null。
注意可选参数必须写在参数列表的末尾。
void main() {
printInfo(String a,[String b,String c = "c"]){
print("$a $b $c");
}
printInfo("a");//a null c
printInfo("a","b");//a b c
printInfo("a","b","d");//a b d
}
命名参数
通过{}可以声明一组命名参数，命名参数也可以有默认值。
注意命名参数也必须写在参数列表的末尾。
void main() {
printInfo(String a, {String b, String c = "c"}) {
print("$a $b $c");
}
printInfo("a"); //a null c
printInfo("a", b: "b"); //a b c
printInfo("a", c: "d"); //a null d 可以跳过参数b直接传参数c
}
命名参数比可选参数一个方便的地方在于可以指定要传入的参数，而可选参数只能从前到后依次传入。
函数参数
dart中函数可以作为一个参数传入另一个函数。
void main() {
fn1(){
print("fn1");
}
fn2(f){
f();
}
fn2(fn1);//fn1
}
箭头函数
对于一些简单的函数，可以使用箭头函数来进行简化。需要注意的是箭头函数后面只能写一句代码，并且它会把这句代码的值返回。
void main() {
printInfo(Object info) => print(info);
sum(int a,int b) => a+b;
printInfo(sum(1, 2));//3
var list = [1,2,3];
var newList = list.map((item) => item*2);
print(newList.toList());//[2, 4, 6]
}
匿名函数
匿名函数一般作为一个参数传入另一个方法，也可以使用一个变量来接收，方便之后调用。
void main() {
var list = [1,2,3];
list.map((item) => item*2);//(item) => item*2就是一个匿名方法
var f1 = (){
print("匿名方法");
};
f1();//匿名方法
var f2 = (int a){
print("匿名方法$a");
};
f2(2);//匿名方法2
}
自执行函数
自执行函数指不需要开发者调用，程序执行到这里就会自动运行的方法。
void main() {
(() {
print("123");
})();//123
((int n) {
print(n);
})(456);//456
}
闭包
闭包可以用来在一个函数与一组“私有”变量之间创建关联关系。在给定函数被多次调用的过程中，这些私有变量能够保持其持久性。变量的作用域仅限于包含它们的函数，因此无法从其它程序代码部分进行访问。不过，变量的生存期是可以很长，在一次函数调用期间所创建所生成的值在下次函数调用时仍然存在。正因为这一特点，闭包可以用来完成信息隐藏，并进而应用于需要状态表达的某些编程范型中。
在一些语言中，在函数中可以（嵌套）定义另一个函数时，如果内部的函数引用了外部的函数的变量，则可能产生闭包。
void main() {
f(){
var num = 1;
return (){
print(num);
num++;
};
}
f()();//1
f()();//1
f()();//1
var a = f();
a();//1
a();//2
a();//3
}
类与对象
dart是一门面向对象编程（OOP）的语言。它同样有封装、继承、多态三大特征。
- 所有能够使用变量引用的都是对象， 每个对象都是一个类的实例。在 Dart 中 甚至连 数字、方法和 null都是对象。dart中所有对象都继承于Object。
- dart支持顶级函数和在类中定义函数（可以理解为静态函数和实例函数）。
- dart同样也支持顶级变量。
默认构造函数
dart中默认构造函数只能有一个。
以下两种写法是等价的：
class Student {
String name;
int age;
Student(String name, int age) {
this.name = name;
this.age = age;
}
}
class Student {
String name;
int age;
Student(this.name, this.age);
}
命名构造函数
dart中命名构造函数可以有多个。
dart中类实例化时new关键字是可以省略的。
void main() {
var student_1 = Student("lili", 18);//调用默认构造函数
var student_2 = Student.name("tom");
var student_3 = Student.newInstance("lili", 18);
}
class Student {
String name;
int age;
Student(this.name, this.age);
Student.name(this.name);
Student.age(this.age);
Student.newInstance(this.name, this.age);
}
类的初始化列表
类的初始化列表运行在构造函数体运行之前。
class Student {
String name;
int age;
String address;
Student(this.name)
: this.age = 18,
assert(name != null);
}
import 'Student.dart';
void main() {
var student_1 = Student("lili");
print(student_1.name);//lili
var student_2 = Student(null);// Failed assertion: line 8 pos 16: 'name != null': is not true.
print(student_2.name);
}
访问修饰符
dart中是没有public、private这些访问修饰符的，我们可以通过将属性或方法名以_开头来表示私有。
import 'Student.dart';
void main() {
var student_1 = Student("lili", 18);//调用默认构造函数
print(student_1.name);//lili
// print(student_1._age);//报错
}
class Student {
String name;
int _age;
Student(this.name, this._age);
study(){
print("学习");
}
}
getter/setter
class Student {
String name;
int _age;
get age => this._age;
set age(int age) {
this._age = age;
}
}
静态成员
- 使用static关键字来实现类级别的属性和方法。
- 静态方法不能访问非静态属性，非静态方法可以访问静态属性。
class Student {
static String name = "lili";
int age;
String address;
static study(){
print("学习");
}
}
import 'Student.dart';
void main() {
print(Student.name);//lili
Student.study();//学习
}
对象操作符
- ？ 条件运算符
- as 类型转换
- is 类型判断
- .. 级联操作
class Student {
String name;
int age;
printInfo(){
print("$name $age");
}
}
import 'Student.dart';
void main() {
Student student;
// student.printInfo();//报错 空指针异常
student?.printInfo(); //不会执行study方法，但是也不会报错
Object object = Student();
(object as Student).printInfo(); //null null
if (object is Student) object.printInfo(); //null null
student = Student();
student.name = "lili";
student.age = 18;
student.printInfo(); //lili 18
student
..name = "tom"
..age = 20
..printInfo();//tom 20
}
继承
- 子类使用extends关键字继承父类
- 子类会继承父类里面可见的属性和方法，但不会继承构造函数（如果父类构造函数有参数的话，子类构造函数必须调用父类的构造函数并传入参数）
- 子类能复写父类方法，包括getter和setter
class Person{
String name;
int age;
Person(this.name, this.age){
print("Person构造函数");
}
Person.name(this.name);
run(){
print("走路");
}
}
class Student extends Person{
String school;
Student(String name, int age) : super(name, age);
Student.school(String name, int age,this.school) : super(name, age);
Student.school2(String name,this.school) : super.name(name);
@override
run() {
// TODO: implement run
return super.run();
}
}
抽象类
- 抽象类通过abstract关键字来定义
- 抽象方法不能使用abstract声明，dart中没有方法体的方法我们称为抽象方法
- 继承抽象类必须实现里面的所有抽象方法
- 抽象类不能直接实例化
abstract class Person{
eat();//抽象方法
printInfo(){
print("Person printInfo");
}
}
class Student extends Person{
@override
eat() {
// TODO: implement eat
return null;
}
}
接口
dart中也有接口的概念，但是和Java中的接口有所不同：
- dart中没有interface关键字
- 普通类和抽象类都可以作为接口通过implements关键字被实现
- 一个类作为接口的话，它的实现类需要将接口类中所有的属性和方法都复写一遍
- 一个类可以实现多个接口
abstract class Person{//接口一般用于定义规范、标准
String name;
work();//抽象方法
}
abstract class Anim{
eat();
}
class Student implements Person,Anim{
@override
String name;
@override
eat() {
// TODO: implement eat
return null;
}
@override
work() {
// TODO: implement work
return null;
}
}
mixins
dart中可以使用mixins实现类似多继承的功能。
- 作为mixins的类只能继承自Object，不能继承其他类
- 作为mixins的类不能有构造函数
- 一个类可以mixins多个mixins类
- 使用with关键字
- 可以先extends，再with
- mixins不是继承，也不是接口，而是一种新的特性
abstract class Person {
//接口一般用于定义规范、标准
String name;
work(); //抽象方法
}
abstract class Anim {
eat();
}
class Student with Person, Anim {
@override
eat() {
// TODO: implement eat
return null;
}
@override
work() {
// TODO: implement work
return null;
}
}
泛型
泛型的使用基本同Java。
class Person<T extends Object> {
List<T> list;
T getData<T>(T value) {
return value;
}
}
异常处理
dart中的异常处理可以使用 try/on/catch/finally 块。
try异常块嵌入代码，有可能会导致异常。需要指定异常类型时使用on块。catch块，需要捕捉异常时使用。
test() {
try {
Person p;
p.getData(1);
} on NoSuchMethodError {//如果发生的是NoSuchMethodError异常，则会执行on代码块，其他异常则会执行catch代码块
print("on Exception");
} catch (e) {
print("catch Exception");
} finally {//无论是否发生异常都会执行
print("finally");
}
}
