说明：
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基本一致，详细如下：
描述 |
运算符 |
一元运算符（后置） |
expr++ expr-- () [] . ?. |
一元运算符（前置） |
-expr !expr ~expr ++expr --expr |
乘法运算符 |
* / % ~/ |
加法运算符 |
+ - |
按位运算符 |
<< >> |
按位与 |
& |
按位异或 |
^ |
按位或 |
| |
关系与类型检测 |
>= > <= < as is is! |
平等 |
== != |
逻辑与 |
&& |
逻辑或 |
|| |
是否为null |
?? |
三目运算符 |
expr1 ? expr2 : expr3 |
级联运算符 |
.. |
赋值运算符 |
= *= /= ~/= %= += -= <<= >>= &= ^= |= ??= |
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(); //调用父类的方法
}
}