Dart语言简介

Dart 初体验

我们在Android Studio中建立一个main.dart文件，右键Run main.dart

void sayHello(String name) {
  print('Hello world, I am $name');
}
main() {
  String myName = 'xiaoming';
  sayHello(myName);
}

可以看到控制台会输出

Hello world, I am xiaoming

和绝大多数编译型语言一样，Dart 要求以 main 函数作为执行的入口。

Dart 的变量与类型

在 Dart 中，我们可以用 var 或者具体的类型来声明一个变量。当使用 var 定义变量时，表示类型是交由编译器推断决定的，这样的话，类型推断会耗费一些性能，可以用静态类型去定义变量，更清楚地跟编译器表达你的意图，这样编辑器和编译器就能使用这些静态类型，向你提供代码补全或编译警告的提示。

• 在默认情况下，未初始化的变量值都是 null，不用担心JavaScript中未定义的值是undefined的情况。
• Dart 是类型安全的语言，并且所有类型都是对象类型，都继承自顶层类型 Object，因此一切变量的值都是类的实例（即对象），甚至数字、布尔值、函数和 null 也都是继承自 Object 的对象。
• Dart 内置了一些基本类型，如 num、bool、String、List 和 Map，在不引入其他库的情况下可以使用它们去声明变量。

dynamic，var，object的区别

var a = 1;
object b = 1;
dynamic c = 1;

上面的例子中，看起来三者非常相似，但是背后的原理却是非常不同。
var本身是一个语法，并不能说是一种类型，其它的两者object和dynamic是类型。

var声明的变量在赋值的那一刻，就已经决定了它是什么类型。
所以如果你这样使用，就会有编译错误:

var a = 1;
a = "Test";

object之所以能够被赋值为任意类型的原因，是因为所有的类型都派生自object. 所以它可以赋值为任何类型:

object a = 1;
a = "Test";

dynamic不是在编译时候确定实际类型的, 而是在运行时。
所以下面的代码是能够通过编译的，但是会在运行时报错:

dynamic a = "test";
a++;

dynamic类型具有所有可能的属性和方法。Dart语言中函数方法都有dynamic类型作为函数的返回类型，函数的参数也都有dynamic类型。

final和const
如果从未打算更改一个变量，那么使用 final 或 const，不是var，也不是一个类型。 一个 final 变量只能被设置一次，两者区别在于：const 变量是一个编译时常量，final变量在第一次使用时被初始化。被final或者const修饰的变量，变量类型可以省略，如：

//可以省略String这个类型声明
final str1 = "hello world";
//final String str1 = "hello world"; 
const str2 = "hello world";
//const String str2 = "hello world";

函数

Dart是一门真正的面向对象的语言，所以即使是函数也是对象，并且有一个类型Function。这意味着函数可以赋值给变量或作为参数传递给其他函数，这是函数式编程的典型特征。

函数声明

bool isNoble(int atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}

Dart函数声明如果没有显式声明返回值类型时会默认当做dynamic处理。

typedef bool CALLBACK();

//不指定返回类型，此时默认为dynamic，不是bool
isNoble(int atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}

void test(CALLBACK cb){
   print(cb()); 
}
//报错，isNoble不是bool类型
test(isNoble);

函数作为变量

var say = (str){
  print(str);
};
say("hi world");

函数作为参数传递

void execute(var callback) {
    callback();
}
execute(() => print("hello world"))

可选的位置参数

String say(String name, String msg, [String device]) {
  var result = '$name says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  return result;
}

下面是一个不带可选参数调用这个函数的例子：

say('xiaoming', 'hello'); //结果是： xiaoming says hello

下面是用第三个参数调用这个函数的例子：

say('xiaoming', 'hello', 'android'); //结果是：xiaoming says hello with a android

可选的命名参数
定义函数时，使用{param1, param2, …}，放在参数列表的最后面，用于指定命名参数。例如：

//设置[bold]和[hidden]标志
void enableFlags({bool bold, bool hidden}) {
    // ... 
}

调用函数时，可以使用指定命名参数。例如：paramName: value
enableFlags(bold: true, hidden: false);
Flutter 中会大量用到可选命名参数的方式，一定要记住它的用法。

注意，不能同时使用可选的位置参数和可选的命名参数

类

Dart 是面向对象的语言，每个对象都是一个类的实例，都继承自顶层类型 Object。在 Dart 中，实例变量与实例方法、类变量与类方法的声明与 Java 类似，值得一提的是，Dart 中并没有 public、protected、private 这些关键字，我们只要在声明变量与方法时，在前面加上“”即可作为 private 方法使用。如果不加“”，则默认为 public。不过，“_”的限制范围并不是类访问级别的，而是库访问级别。
接下来，我们以一个具体的案例看看Dart 是如何定义和使用类的。建立一个test.dart文件。在 Calc 类中，定义了两个成员变量 x 和 y，通过构造函数语法糖进行初始化，成员函数 printInfo 的作用是打印它们的信息；而类变量 z，则在声明时就已经赋好了默认值 0，类函数 sum 会打印出它的信息。

class Calc {
  int x, y;
  static num z = 0;
  Calc(this.x,this.y); // 语法糖，等同于在函数体内：this.x = x;this.y = y;
  void printInfo() => print('($x, $y)');
  static void sum(int a, int b) => print('result ${a + b }');
}

void main() {
  Calc c = new Calc(100,200); // new 关键字可以省略
  c.printInfo();  // 输出 (100, 200);
  Calc.z = 10;
  Calc.sum(10, 20); // 输出 result 40
}

有时候类的实例化需要根据参数提供多种初始化方式。除了可选命名参数和可选参数之外，Dart 还提供了命名构造函数的方式，使得类的实例化过程语义更清晰。
此外，与 C++ 类似，Dart 支持初始化列表。在构造函数的函数体真正执行之前，你还有机会给实例变量赋值，甚至重定向至另一个构造函数。
如下面实例所示，Calc 类中有两个构造函数 Calc.reDirct 与 Calc，其中：Calc.reDirct将其成员变量的初始化重定向到了 Calc 中，而 Calc 则在初始化列表中为 z 赋上了默认值 0。

class Calc {
  num x, y, z;
  Calc(this.x, this.y) : z = 0; // 初始化变量 z
  Calc.reDirct(num x) : this(x, 0); // 重定向构造函数
  void printInfo() => print('($x,$y,$z)');
}

void main() {
  Calc c1 = Calc(100,200); // new 关键字可以省略
  c1.printInfo();  // 输出 (100,200,0)
  Calc c2 = Calc.reDirct(300);
  c2.printInfo();  // 输出 (300,0,0)
}

复用

在面向对象的编程语言中，将其他类的变量与方法纳入本类中进行复用的方式一般有两种：继承父类和接口实现。当然，在 Dart 也不例外。
在 Dart 中，你可以对同一个父类进行继承或接口实现：

• 继承父类意味着，子类由父类派生，会自动获取父类的成员变量和方法实现，子类可以根据需要覆写构造函数及父类方法；
• 接口实现则意味着，子类获取到的仅仅是接口的成员变量符号和方法符号，需要重新实现成员变量，以及方法的声明和初始化，否则编译器会报错

class Parent {
  num x = 0, y = 0;
  void printInfo() => print('($x,$y)');
}

//Children1 继承自 Parent
class Children1 extends Parent {
  num z = 0;
  @override
  void printInfo() => print('($x,$y,$z)'); // 覆写了 printInfo 实现
}

//Children2 是对 Parent 的接口实现
class Children2 implements Parent {
  num x = 0, y = 0; // 成员变量需要重新声明
  void printInfo() => print('($x,$y)'); // 成员函数需要重新声明实现
}

void main() {
  var xxx = Children1();
  xxx
    ..x = 1
    ..y = 2
    ..z = 3; // 级联运算符，等同于 xxx.x=1; xxx.y=2;xxx.z=3;
  xxx.printInfo(); // 输出 (1,2,3)

  var yyy = Children2();
  yyy
    ..x = 1
    ..y = 2; // 级联运算符，等同于 yyy.x=1; yyy.y=2;
  yyy.printInfo(); // 输出 (1,2)
  print(yyy is Parent); //true
  print(yyy is Children2); //true
}

可以看出，子类 Children2采用接口实现的方式，仅仅是获取到了父类Parent 的一个“空壳子”，只能从语义层面当成接口 Parent 来用，但并不能复用 Parent 的原有实现。那么，我们是否能够找到方法去复用 Parent 的对应方法实现呢？也许你很快就想到了，可以让 Children2 继承 Point，来复用其对应的方法。但如果 Children2 还有其他的父类，我们又该如何处理呢？

除了继承和接口实现之外，Dart 还提供了另一种机制来实现类的复用，即“混入”（Mixin）。混入鼓励代码重用，可以被视为具有实现方法的接口。这样一来，不仅可以解决 Dart 缺少对多重继承的支持问题，还能够避免由于多重继承可能导致的歧义（菱形问题）。

菱形问题，是支持多继承的编程语言中一个相当棘手的问题。当 B 类和 C 类继承自 A 类，而 D 类继承自 B 类和 C 类时会产生歧义。如果 A 中有一个方法在 B 和 C 中已经覆写，而 D 没有覆写它，那么 D 继承的方法的版本是 B 类，还是 C 类的呢？

要使用混入，只需要 with 关键字即可

class Children2 with Parent {
}
 
var yyy = Children2();
print (yyy is Parent); //true
print(yyy is Children2); //true

运算符

Dart 和绝大部分编程语言的运算符一样，你可以用熟悉的方式去执行程序代码运算。不过，Dart 多了几个额外的运算符，用于简化处理变量实例缺失（即 null）的情况。

• ?.运算符：p?.printInfo()表示 p 为 null 的时候跳过，避免抛出异常。
• ??= 运算符：a ??= value 表示，如果 a 为 null，则给 a 赋值 value，否则跳过。
• ??运算符：a ?? b表示如果 a 不为 null，返回 a 的值，否则返回 b。在 Java 中，我们需要通过三元表达式 (a != null)? a : b 来实现这种情况。