Flutter日渐火爆，因此在进行Flutter学习前先学习一些其所使用的开发语言dart的基础，这篇文章主要学习了

1. Dart的基础代码示例
2. Dart的概念
3. Dart的关键字

Dart的基础代码示例

// 定义一个方法。printInteger(int aNumber) {  print('The number is $aNumber.'); // Print to console.}// main入口函数。main() {  var number = 42; // 声明并初始化变量。  printInteger(number); // 函数调用。}复制代码

// 注释

dart注释方法，更多注释可以看我的另一篇文章https://www.jianshu.com/p/d1dae0d5c472

int

数据类型，更多数据类型可看https://www.dartlang.org/guides/language/language-tour#built-in-types

print()

一种方便的显示输出方式

'...' (or "...")

字符串，dart中更推荐使用**'...'**

$variableName (or ${expression})

字符串插值：包括字符串文字内部的变量或表达式的字符串

var

一种声明变量而不指定其类型的方法，关键字之一

Dart重要概念

当要学习dart时，请记住以下事实和概念：

• 一切皆为对象，放在变量中的所有内容都是一个对象，每个对象都是一个class的实例，numbers，函数和null都是对象，所有对象都继承自Object类。下面给个图你看一下，没错，连int都是对象：

• 尽管Dart是强类型的，但类型注释是可选的，因为Dart可以推断类型。在上面的代码中，数字被推断为int类型。如果要明确说明不需要任何类型，请使用特殊类型dynamic。

• Dart支持泛型类型，如List(整数列表)或List(任何类型的对象列表)。

• Dart支持顶级函数(例如main())，以及绑定到类或对象的函数(分别是静态和实例方法)，还可以在函数内创建函数(嵌套函数或本地函数)。

• Dart也支持顶级变量，以及绑定到类或对象的变量(静态和实例变量)，实例变量有时称为字段或属性。

• 与Java不同，Dart没有关键字public，protected和private，如果标识符以下划线(_)开头，则它代表是私有的，否则都为公有。

• 标识符可以以字母或下划线(_)开头，后跟这些字符加数字的任意组合。

• Dart有表达式(具有运行时值)和语句(不具有运行时值)。例如，条件表达式"条件? expr1:expr2的值为expr1或expr2"。将其与if-else语句进行比较，该语句没有任何值。语句通常包含一个或多个表达式，但表达式不能直接包含语句。

关键字

dart共有60个关键字，所以以下篇幅可能有点长

abstract2	dynamic2	implements2	show1
as2	else	import2	static2
assert	enum	in	super
async1	export2	in2	super
await3	extends	is	sync1
break	external2	library2	this
case	factory2	mixin2	throw
catch	false	new	true
class	final	null	try
const	finally	on1	typedef2
continue	for	operator2	var
covariant2	Function2	part2	void
default	get2	rethrow	while
deferred2	hide1	return	with
do	if	set2	yield3

• 带有上标1的关键字是上下文关键字，仅在特定位置具有含义。
• 带有上标2的关键字是内置标识符, 为了简化将JavaScript代码移植到Dart的任务，这些关键字在大多数地方都是有效的标识符，但它们不能用作类或类型名称，也不能用作导入前缀。
• 带有上标3的关键字为新版本中的新标识符，是与Dart 1.0发布后添加的异步支持相关的有限保留字。

详细可看下面说明

abstract

使用abstract修饰符定义抽象类即无法实例化的类，抽象类可以自定义一些接口。抽象类通常有抽象方法，下面是一个声明具有抽象方法的抽象类的示例：

// 该类声明为抽象类且不可实例化。abstract class AbstractContainer {  // 定义构造函数，变量，方法等...  // 其他....    // 抽象方法。  void updateChildren(); }复制代码

下面为实现抽象方法的例子：

//抽象类abstract class Doer {  void doSomething(); // 定义一个抽象方法}//继承抽象类实现抽象方法class EffectiveDoer extends Doer {  void doSomething() {    // 实现逻辑  }}复制代码

dynamic

顾名思义，dynamic(动态), 直接先上代码

void judge(dynamic arg){    if (arg is bool){      print('arg is bool');    } else if (arg is String){      print('arg is String');    } else if (arg is int){      print('arg is int');    } else {      print('arg is others');    }}复制代码

dynamic同等于Object, 即上面代码可以等同于下面代码:

void judge(Object arg){    if (arg is bool){      print('arg is bool');    } else if (arg is String){      print('arg is String');    } else if (arg is int){      print('arg is int');    } else {      print('arg is others');    }}复制代码

在Dart中，dynamic和Object可表示所有类型, 这两者区别是使用dynamic可以处理更复杂的不确定类型，例如超出了Dart的类型系统，或者值来自互操作或者在静态类型系统范围之外的情况。

implements

Java中，该关键字用于实现接口类(interface), Dart中亦有相同的意思，实现接口，我们先看代码:

// Person类，包含方法greet().class Person {  //在该类中，属于私有，仅对当前类可见  final _name;  // 不是接口，只是构造函数  Person(this._name);  // 接口  String greet(String who) => 'Hello, $who. I am $_name.';}// 实现Person类接口的类class Impostor implements Person {  //只是一个普通的get方法，可忽略  get _name => '';  //实现Person的greet方法  String greet(String who) => 'Hi $who. Do you know who I am?';}//只是一个测试方法String greetBob(Person person) => person.greet('Bob');void main() {  print(greetBob(Person('Kathy')));  //打印 -> Hello, Bob. I am Kathy.  print(greetBob(Impostor())); //打印 -> Hi Bob. Do you know who I am?}复制代码

Dart中没有Java的interface功能，如果Impostor在不继承Person类的情况想实现Person类的接口的话，可以使用implements关键字。implements可同时实现多个类的接口:

class Point implements Comparable, Location {...}复制代码

show & hide

有时候我们导入一个库，如果只想使用库的一部分，则可以有选择地导入库，例如：

// 只导入fooimport 'package:lib1/lib1.dart' show foo;复制代码

//导入整个库除了fooimport 'package:lib2/lib2.dart' hide foo;复制代码

as, is, is!

as，is，和 !is 运算符在运行时检查类型很方便

• as: 类型转换, 也用于指定库前缀
• is: 类似于java的instanceof
• !is: is操作符的取反, 即不是xxx

代码示例：

if (emp is Person) {  // 类型检查  emp.firstName = 'Bob';}复制代码

// 如果emp为Person，则将firstName改为Bod, 否则会在运行时期报错(emp as Person).firstName = 'Bob';复制代码

如果导入两个具有冲突标识符(class)的库，则可以为一个或两个库指定前缀。 例如，如果library1和library2都有一个Element类，那么as可以这样使用：

import 'package:lib1/lib1.dart';import 'package:lib2/lib2.dart' as lib2; //指定库的前缀为lib2// Uses Element from lib1.Element element1 = Element();// Uses Element from lib2.lib2.Element element2 = lib2.Element();复制代码

if & else

与Java或其他语言一样，Dart支持带有可选else语句的if语句:

if (isRaining()) {  you.bringRainCoat();} else if (isSnowing()) {  you.wearJacket();} else {  car.putTopDown();}复制代码

import

与Java一样，使用import导入其他包。例如，Dart Web应用程序通常使用dart：html库，可以这样导入：

import 'dart:html';复制代码

如果只是想导入某个包下的某个dart文件，可以这样导入：

import 'package:test/test.dart'; //指定导入test.dart(类似于Java中的test.java)复制代码

static

使用static关键字实现类范围的变量和方法

static变量(只有在使用的时候才会进行初始化):

class Queue {  static const initialCapacity = 16;  // ···}void main() {  assert(Queue.initialCapacity == 16);}复制代码

static方法：

import 'dart:math';class Point {  num x, y;  Point(this.x, this.y);  static num distanceBetween(Point a, Point b) {    var dx = a.x - b.x;    var dy = a.y - b.y;    return sqrt(dx * dx + dy * dy);  }}void main() {  var a = Point(2, 2);  var b = Point(4, 4);  var distance = Point.distanceBetween(a, b); //静态方法，不用实例化  assert(2.8 < distance && distance < 2.9);  print(distance);}复制代码

assert

断言assert(条件); 如果条件为返回false，使用assert语句可以中断正常执行, 代码：

// text等于null时中断assert(text != null);// number > 100时中断assert(number < 100);// 如果urlString不是以"https"开头assert(urlString.startsWith('https'));复制代码

如果要附加一个消息到断言，可在第二个参数输入一个字符串：

assert(urlString.startsWith('https'),    'URL ($urlString) should start with "https".');复制代码

enum

枚举类型（通常称为枚举或枚举）是一种特殊类型，用于表示固定数量的常量值。 使用enum关键字声明枚举类型, 例如：

enum Color { red, green, blue }复制代码

枚举中的每个值都有一个索引getter，它返回枚举声明中值的从零开始的位置。 例如，第一个值具有索引0，第二个值具有索引1：

print('red index: \${Color.red.index}'); // -> 打印red index: 0  print('green index: \${Color.green.index}'); // -> 打印: green index: 1  print('blue index: \${Color.blue.index}');· //-> 打印: blue index: 2复制代码

要获取枚举中所有值的列表，可以使用以下方法：

List
    
      colors = Color.values;复制代码
    

您可以在switch语句中使用枚举，如果您不处理所有枚举值，您将收到警告：

var aColor = Color.blue;switch (aColor) {  case Color.red:    print('Red as roses!');    break;  case Color.green:    print('Green as grass!');    break;  default: // 没有这行代码的话，会有一个警告    print(aColor); // 'Color.blue'}复制代码

枚举类型具有以下限制：

1.不能子类化，混合或实现枚举。 2.无法显式实例化枚举。

for & in

可以使用标准for循环进行迭代, 例如：

var message = StringBuffer('Dart is fun');for (var i = 0; i < 5; i++) {  message.write('!');}复制代码

像List和Set这样的可迭代类支持使用的for-in形式迭代：

var list = [0, 1, 2];  for (var x in list) {    print(x); // 0 1 2  }复制代码

等同于:

for (int i = 0; i < list.length; i++){    print(list[i]); // 0 1 2  }复制代码

extend & super

使用extends来继承一个类，使用super来调用父类：

class Television {  void turnOn() {    _illuminateDisplay();    _activateIrSensor();  }  // ···}class SmartTelevision extends Television {  void turnOn() {    super.turnOn(); //调用父类方法    _bootNetworkInterface();    _initializeMemory();    _upgradeApps();  }  // ···}复制代码

async & await

• async -> 异步
• await -> 等待

Dart库中包含许多返回Future或Stream对象的函数，关于Future和Steam会在后续进行讲解，这里暂不深究。 这些函数是异步的：它们在设置可能耗时的操作(例如I/O)后返回，而不等待该操作完成。

async和await关键字用于异步编程

async关键字修饰一个方法，要求必须返回一个Future对象，下面为代码例子：

//async关键字声明该函数内部有代码需要延迟执行Future
    
      getResult() async {   return await getResultFromDb(); //await关键字声明运算为延迟执行，然后返回运算结果}Future
     
       getResultFromDb() {  // 很多延时操作  // 很多延时操作  // 很多延时操作  // 很多延时操作  return new Future((){      return 'This is server...';  });}//打印：result = This is server... print(getResult().then((result){      print('result = $result');  }));复制代码
     
    

export

我们来看一个官方的http库的代码: http: ^0.12.0

我们可以看到该包下面有一个src目录，还有一些其他的dart文件，Dart库中，lib/src下的代码被认为是私有的, lib下的文件为对外公开即外部可以使用的，我们可以看到该http库下browser_client.dart, http.dart, io_client.dart, testing.dart是公开的API，我们拿其中一个，这里我们拿http.dart文件看看

export 'src/base_client.dart';export 'src/base_request.dart';export 'src/base_response.dart';export 'src/byte_stream.dart';export 'src/client.dart';export 'src/exception.dart';export 'src/multipart_file.dart';export 'src/multipart_request.dart';export 'src/request.dart';export 'src/response.dart';export 'src/streamed_request.dart';export 'src/streamed_response.dart';复制代码

可以看到export了几个文件，即导出了这几个文件，使外部这几个文件的api，这时我们导入http来使用一下：

import 'package:http/http.dart' as http;复制代码

可以看到导入的几个文件的类都可用了，那我们再找一个没export的文件来看看外部是否可用，我们拿browser_client.dart来看看，其中有一个类：

我们在外部使用的时候：

是会报错的，因为该类并没有export，即外部不可使用。

interface

已移除

switch & case & default

Dart中的switch语句可使用整数，字符串或编译时常量， 以下为使用字符串代码示例：

var command = 'OPEN';switch (command) {  case 'CLOSED':    executeClosed();    break;  case 'PENDING':    executePending();    break;  case 'APPROVED':    executeApproved();    break;  case 'DENIED':    executeDenied();    break;  case 'OPEN':    executeOpen();    break;  default: //表示其他值的条件    executeUnknown();}复制代码

sync & yield

• sync 同步
• yield 生成

当我们需要懒惰地(不需要很多手动定义可迭代类时复杂的公式化代码)生成一系列值时，可以考虑使用生成器函数， Dart内置支持两种生成器函数：

• 同步生成器：返回一个Iterable对象
• 异步生成器：返回Stream对象

同步生成器：将函数体标记为sync *，并使用yield语句来赋值，下面例子为返回 0-n 的迭代器：

Iterable
    
      naturalsTo(int n) sync* {  print('start');  int k = 0;  while (k < n) yield k++;  print('end');}//使用void main() {  var it = naturalsTo(5).iterator;  while(it.moveNext()) {    print(it.current);  }}//打印startvalue = 0value = 1value = 2value = 3value = 4end复制代码
    

调用方法naturalsTo时，会马上返回Iterable，且可以获取迭代器iterator，但是，在调用遍历之前，naturalsTo函数主体并不会立即执行，这里我们可以看到调用var it = naturalsTo(5).iterator的时候没有任何打印，并且我们可以看到，在遍历打印的时候，先调用start，当把所有值打印完了，再打印end。说明调用naturalsTo得到这个Iterable的iterator的时候，yield会在你每次调用moveNext进行遍历的时候产生一个值。当函数运行到yield的时候，yield这里声明一个求值表达式，返回值后，函数会在下一次moveNext的时候继续执行函数体。

异步生成器函数，将函数体标记为async *，并使用yield语句来传递值：

Stream
    
      asynchronousNaturalsTo(int n) async* {  int k = 0;  while (k < n) yield k++;}//使用void main() {  asynchronousNaturalsTo(5).listen((v) {    print(v);  });}//打印start01234end复制代码
    

使用异步生成器返回数据流string，和sync*一样，调用asynchronousNaturalsTo会立即返回Stream，但是只有在listen监听数据流的时候才会调用asynchronousNaturalsTo函数体，并且通过yield声明求值表达式来计算对应的值。

如果生成器内部使用递归的话，可以使用yield *来提高其性能：

Iterable
    
      naturalsDownFrom(int n) sync* {  if (n > 0) {    yield n;    yield* naturalsDownFrom(n - 1);  }}//使用void main() {  print(naturalsDownFrom(5));}//打印(5, 4, 3, 2, 1)复制代码
    

naturalsDownFrom函数还是返回一个Iterable，当参数为5时，5 > 0时，先执行yield 5, 这时迭代器首先会产生一个值5，然后再通过yield*生成新的值，并且加到当前迭代器中。

break & continue

跳出循环

while (true) {  if (shutDownRequested()) break;  processIncomingRequests();}复制代码

跳到下一个循环迭代

or (int i = 0; i < candidates.length; i++) {  var candidate = candidates[i];  if (candidate.yearsExperience < 5) {    continue;  }  candidate.interview();}复制代码

external

表示代码的实现由外部提供，我们定义一个类：

class Object {  const Object();  external bool operator ==(other);  external int get hashCode;  external String toString();}//使用void main() {  Object object = new Object();  print('to string = ${object.toString()}');}//打印to string = null//但是如果我们将toString去掉的话，则会打印to string = Instance of 'Object' //dart中默认的toString打印复制代码

external声明了这些方法需要由外部去实现，若外部没实现，则会返回null

library & part

使用library关键字可以定义一个库的名字，我们这里自定义一个库来说明一下这两个关键字:

这里分别有3个文件，我们看看： main.dart

library main; //定义当前库的名字为mainimport 'dart:math' as math; //声明以下两个文件属于main库part 'test/lib/liba.dart'; part 'test/lib/libb.dart';class LibMain{    static int max(int a, int b) => math.max(a, b);    static String getParts() => LibA.TAG + ", " + LibB.TAG;}复制代码

liba.dart

part of main;  //声明属于main库class LibA{  static String TAG = 'liba';}复制代码

libb.dart

part of main; //声明属于main库class LibB{  static String TAG = 'libb';}复制代码

再导入main之后，

import 'lib/main.dart';复制代码

liba.dart和libb.dart中声明的类外部可用：

part可以将库拆分为多个Dart文件，但是建议尽量避免使用其来创建库，因为这样会使代码很难阅读和修改。建议直接直接在lib/<包名> .dart下创建一个“main”库文件，用一个main文件来管理所有公共API。

this

和Java中this相类似，用this关键字来引用当前实例

factory

用来修饰构造函数，描述该构造函数作为一个工厂构造函数功能，在实现不用总是创建新实例的构造函数的时候，可以使用factory关键字，例如下面例子中，可能从缓存中返回实例，或者子类的实例。

class Logger {  final String name;  bool mute = false;  //一个维护Logger类的map  static final Map
    
      _cache =      
     
      {};  //根据不同的name获取对应的Logger，  factory Logger(String name) {    if (_cache.containsKey(name)) {      return _cache[name];    } else {      final logger = Logger._internal(name);      _cache[name] = logger;      return logger;    }  }  //一个内部构造函数  Logger._internal(this.name);  void log(String msg) {    if (!mute) print(msg);  }}复制代码
     
    

注意，使用factory修饰的构造函数不能使用this，类似于在Java的static函数中，不能使用this

mixin & with & on

Dart 2.1中引入了对mixin关键字的支持, 我们可以看到官方的描述：Mixins是一种在多个类层次结构中重用类代码的方法。关键信息：

• 多个类层次结构
• 重用类代码

我这里只简单描述下该关键字的作用和使用方法:

• mixin字面意思为混入的意思，要使用mixin的话，需要使用with关键字，后跟一个或多个mixin的名称, 可视为混入多个类
• 有时候我们需要创建一个类，这个类需要使用不同类的不同的方法的时候，就需要使用mixin方法，,因为Dart中只能继承一个类，而且使用接口的话，必须在其他类也实现这个接口，下面我们使用我们看下下面的例子：

//程序员喜欢写代码class Programmer{  code(){    print('I am a programmer, i like coding.');  }}//歌唱家喜欢唱歌class Singer{  singing(){    print('I am a singer, i like singing.');  }}//既爱编码，也爱唱歌class Mixin with Programmer, Singer{}void main() {  Mixin mixin = Mixin();  mixin.code();  mixin.singing();}//打印：I am a programmer, i like coding.I am a musician, i like singing.复制代码

注意：这里类Programmer和Singer不能声明构造函数包括命名函数：

当我们使用mixin调用不同类相同接口结果会是怎样呢，我们看下面代码：

class A {  name(){    print('I am a student.');  }}class B{  name(){    print('I am a teacher.');  }}class AB with A, B{}class BA with B, A{}void main() {  new AB().name();  new BA().name();}//打印：I am a teacher.I am a student.复制代码

可以看到接口相同的情况这里是name，最终会调用with的最后一个类的接口。

如果我们需要限定，什么类才能被混入，可以使用mixin+on的方法限定：

//mixn定义了类Flutter要求只有实现Programmer类的才能被混入mixin Flutter on Programmer{  flu(){    print('This is in flutter.');  }}//会如下面图片报错//class A  with Flutter{//}//可以混入class B extends Programmer with Flutter{}new B ().flu();  //打印This is in flutter.复制代码

最后，关于mixin更详细的解释可以参考:

throw

抛出异常:

throw FormatException('Expected at least 1 section');复制代码

也可以抛出任何任意对象异常：

throw 'Out of llamas!';复制代码

class Throw{  @override  String toString() {    return 'Are you ok?';  }}void main() {  throw new Throw();}复制代码

try & catch & finally & on & rethrow

异常捕获：

//普通使用void main() {  try{    throw "You are wrong.";  }catch (e){    print('catch exception: '+e);  }}//打印：catch exception: You are wrong.复制代码

使用on可以捕获某种异常

class ExceptionA{  @override  String toString() {    return 'This is exception a.';  }}class ExceptionB{  @override  String toString() {    return 'This is exception b.';  }}throwCatchException(Object object){  try{    throw object;  } on ExceptionA{ //指定某种异常类    print("It's exception a.");  } on ExceptionB catch(e){  //指定某种异常类并获取异常对象    print(e);  } on Exception catch (e){    print(e);  }}void main() {  throwCatchException(new ExceptionA());  throwCatchException(new ExceptionB());  throwCatchException(new Exception(''));}//打印：It's exception a.This is exception b.Exception: 复制代码

可以为catch()指定一个或两个参数, 第一个是抛出的异常对象，第二个是堆栈跟踪(StackTrace对象):

void main() {  try{    throw 'This is a exception.';  }catch (e, s){    print('e ${e}');    print('s ${s}');  }}//打印：e This is a exception.s #0      main (file:///E:/flutter/projects/flutter/test/test.dart:5:5)#1      _startIsolate.
    
      (dart:isolate/runtime/libisolate_patch.dart:289:19)#2      _RawReceivePortImpl._handleMessage (dart:isolate/runtime/libisolate_patch.dart:171:12)复制代码
    

如果想异常可传播, 使用rethrow接口

void misbehave() {  try {    dynamic foo = true;    print(foo++); // 运行时出错  } catch (e) {    print('misbehave() partially handled ${e.runtimeType}.');    rethrow;  //允许调用者可以看到异常  }}void main() {  try {    misbehave();  } catch (e) {    print('main() finished handling ${e.runtimeType}.');  }}//打印：misbehave() partially handled NoSuchMethodError.main() finished handling NoSuchMethodError.复制代码

无论是否抛出异常，要确保某些代码运行，请使用finally子句。 如果没有catch子句与异常匹配，则在finally子句运行后抛出异常：

class ExceptionA{  @override  String toString() {    return 'This is exception a.';  }}class ExceptionB{  @override  String toString() {    return 'This is exception b.';  }}finallyMethod(){  print('finally method.');}void main() {  try {    throw new ExceptionA();  } on ExceptionB catch (e) {    print(e);  } finally{    finallyMethod();  }}//打印：finally method.Unhandled exception:This is exception a.#0      main (file:///E:/flutter/projects/flutter/test/test.dart:21:5)#1      _startIsolate.
    
      (dart:isolate/runtime/libisolate_patch.dart:289:19)#2      _RawReceivePortImpl._handleMessage (dart:isolate/runtime/libisolate_patch.dart:171:12)复制代码
    

false & true

为了表示布尔值，Dart有一个名为bool的类型, 只有两个对象具有bool类型： true和false，它们都是编译时常量

new

创建类实例

class

声明一个类

final & const

final声明一个变量只能初始化一次，和java用法相同

const声明一个是编译时常量的变量， 常量变量不能进行赋值，如果const变量在类级别，则将其标记为static const。 当我们想让一个变量不被改变，可以声明为const变量。

typedef

typedef用于给函数类型指定名称，因为在Dart中，函数也是一个对象，通常用Function泛指所有函数，我们来看一下下面的例子(没有使用函数别名)：

class SortedCollection {  Function compare;    //这里需要传递一个返回值为int，参数为(Object, Object)的函数  SortedCollection(int f(Object a, Object b)) {    compare = f;  }}//一个返回值为int，参数为(Object, Object)的函数int sort(Object a, Object b) => 0;void main() {  SortedCollection coll = SortedCollection(sort);  // 我们都知道compare是一个函数  // 但是我们知道它是什么类型的函数吗，意味着我们只知道它是一个函数，但是是什么类型的函数我们不知道  assert(coll.compare is Function); // 这里毫无疑问是true, 即不会中断执行}复制代码

我们可以用typedef来声明一个函数类型：

//定义一个函数类型为compare，其类型为typedef Compare = int Function(Object a, Object b);class SortedCollection {  Compare compare;  SortedCollection(this.compare);}//一个返回值为int，参数为(Object, Object)的函数即类型为Compare的函数int sort(Object a, Object b) => 0;void main() {  SortedCollection coll = SortedCollection(sort);  assert(coll.compare is Function);  //True  assert(coll.compare is Compare); //True}复制代码

目前typedef只能用于声明函数类型，

operator

如果你想定义一个Vector类(向量类)，可以使用以下运算符:

<	+	|	[]
>	/	^	[]=
<=	~/	&	~
>=	*	<<	==
-	%	>>

下面为一个覆盖+和 - 运算符的类的示例：

class Vector {  final int x, y;  Vector(this.x, this.y);  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);  Vector operator -(Vector v) => Vector(x - v.x, y - v.y);// Operator == and hashCode not shown. For details, see note below.// ···}void main() {  final v = Vector(2, 3);  final w = Vector(2, 3);  final vw = v + w;  final ww = v - w;  print('vw -> (${vw.x}, ${vw.y})');  print('ww -> (${ww.x}, ${ww.y})');}//打印：vw -> (4, 6)ww -> (0, 0)复制代码

var

使用var声明一个变量但是不指定其类型

var name = 'Bob'; //声明一个变量为字符串变量复制代码

但是一旦声明赋值了为一个类型候，不能再分配给另一个类型

covariant

我们在继承一个类的时候，在重构一个方法时，强制将其参数由父类缩窄成其子类的话，会提示错误，例子：

//定义一个Animal类，其函数chase参数为Animalclass Animal {  void chase(Animal x) {}}class Mouse extends Animal {  getName(){    return 'mouse';  }}class Cat extends Animal {  //强制将chase函数的Animal参数缩窄成Mouse   void chase(Mouse mouse) {    print('cat chase ${mouse.getName()}');  }}//报错, 提示重写类型不匹配test/test.dart:12:20: Error: The parameter 'mouse' of the method 'Cat::chase' has type #lib1::Mouse, which does not match the corresponding type in the overridden method (#lib1::Animal).Change to a supertype of #lib1::Animal (or, for a covariant parameter, a subtype).  void chase(Mouse mouse) {                   ^test/test.dart:2:8: Context: This is the overridden method ('chase').  void chase(Animal x) {}       ^复制代码

使用covariant关键字后：

class Animal {  void chase(Animal x) {}}class Mouse extends Animal {  getName(){    return 'mouse';  }}class Cat extends Animal {  void chase(covariant Mouse mouse) {    print('cat chase ${mouse.getName()}');  }}void main(){  new Cat().chase(new Mouse());}//打印cat chase mouse复制代码

covariant字义为协变，即我和编译器协商，这个参数缩窄变化是我故意这样做的，你别抛异常了。

Function

Dart是一种真正的面向对象语言，因此即使是函数也是对象并且具有类型Function。 这意味着函数可以分配给变量或作为参数传递给其他函数。

//定义一个add函数int add(int a, int b) => a+b;handle(Function function){  print('handle: ${function(1, 2)}'); //打印function的结果}void main(){  handle(add); //调用handle并传递add函数}//打印handle: 3复制代码

void

在Dart 1中，void仅可用作函数的返回类型(例如void main())，但在Dart 2中它已被推广，并且可在其他地方使用， 例如Future

void类型不能用于任何东西，且将某些东西分配给void类型是无效的：

void foo() {}void main() {  var bar = foo(); // 无效}复制代码

The expression here has a type of 'void', and therefore cannot be used. -> 此表达式的类型为“void”，无法使用

在函数中，表示该函数无需返回值。

在实践中，一般使用void来表示“任何我不关心元素”，或者更常见的是，表示“省略”，例如在Future 或Stream 中。

get & set

在Java中，getter和setter应该是蛮令我们头疼，如果一些类的属性足够多的话，提供getter和setter接口后，文件很轻松可以达到成千上百行。但是在Dart中，提供了set和get关键子来提供对象属性的读写访问权限。

class Rectangle {  num left, top, width, height;  Rectangle(this.left, this.top, this.width, this.height);  //定义两个可计算的属性right 和bottom.  num get right => left + width;  set right(num value) => left = value - width;  num get bottom => top + height;  set bottom(num value) => top = value - height;}void main() {  var rect = Rectangle(3, 4, 20, 15);    print('right: ${rect.right}');  rect.right = 100;  print('right: ${rect.right}');  print('bottom: ${rect.bottom}');  rect.bottom = 120;  print('bottom: ${rect.bottom}');}//打印：right: 23right: 100bottom: 19bottom: 120复制代码

在Dart中，使用get和set实现getter和setter功能，是不是简洁多了呢

使用get和set后，我们可以从实例变量开始，在get/set的方法中用方法封装，而无需更改外部调用的代码。

while & do while

while: 在循环执行之前计算条件

while (!isDone()) {  doSomething();}复制代码

do-while: 在循环开始执行后计算条件

do {  printLine();} while (!atEndOfPage());复制代码

deferred

deferred用于声明一个延迟加载一个库，通常叫懒加载。允许你只有在需要使用该库的时候，再加载该库。

//文件calculate.dartclass Calculate{  static String name = "Cal";  static printf(String s){    print('cal: $s');  }  int add(int a, int b) => a + b;}//文件test.dartimport 'calculate.dart' deferred as cal; //声明该库会延迟加载且命名为calvoid main() {  print('1');  greet();  print('2');  print('3');}//异步加载库calculate.dart//加载完毕后再进行操作Future greet() async {  await cal.loadLibrary();  print('cal name: ${cal.Calculate.name}');  print('add(1, 2) = ${new cal.Calculate().add(1, 2)}');  cal.Calculate.printf('ss');}//打印:123cal name: Caladd(1, 2) = 3cal: ss复制代码

return

用于在函数中返回一个值