void doStuff(
    {List<int> list = const [1, 2, 3],
    Map<String, String> gifts = const {
      'first': 'paper',
      'second': 'cotton',
      'third': 'leather'
    }}) {
  print('list:  $list');
  print('gifts: $gifts');
}

doStuff(list: [123, 344], gifts: {
'first': 'zhangsan'
})

printPerson(String name,{int age = 14,String gender}){
  print("name=$name,age=$age,gender=$gender");
}

printPerson("李四");
printPerson("李四",age: 20);
printPerson("李四",age: 20,gender: "Male");
printPerson("李四",gender: "Male");

printPerson2(String name,[int age = 15,String gender]){
  print("name=$name,age=$age,gender=$gender");
}

printPerson2("张三");
printPerson2("张三",18);
printPerson2("张三",18,"Female");

// 除后向下取整
10 ~/ 2.1 = 2; 

if (emp is Person) {
  // Type check
  emp.firstName = 'Bob';
}

// 使用 as 运算符进行缩写：
(emp as Person).firstName = 'Bob';

// 当 value 为 null 时, 才会赋值给 b
b ??= value;

// 如果实例类 p 成员变量 y 为非 null，则设置它变量 y 的值为 4
p?.y = 4;

querySelector('#confirm') // 获取对象
  ..text = 'Confirm' // 调用成员变量
  ..classes.add('important') // 添加类名
  ..onClick.listen((e) => window.alert('Confirmed!')); // 注册事件

final addressBook = (AddressBookBuilder()
      ..name = 'jenny'
      ..email = '[email protected]'
      ..phone = (PhoneNumberBuilder()
            ..number = '415-555-0100'
            ..label = 'home')
          .build())
    .build();

var a = const ImmutablePoint(1, 1); // 创建一个常量对象
var b = ImmutablePoint(1, 1); // 创建一个非常量对象

assert(!identical(a, b)); // 两者不是同一个实例!

class Point {
  num x; // 声明示例变量 x，初始值为 null 。
  num y; // 声明示例变量 y，初始值为 null 。
  num z = 0; // 声明示例变量 z，初始值为 0 。
}

// 传统方式
class Point {
  num x, y;

  Point(num x, num y) {
    // 还有更好的方式来实现下面代码，敬请关注。
    this.x = x;
    this.y = y;
  }
}

// Dart 自身的语法糖精简了这些代码
class Point {
  num x, y;

  // 在构造函数体执行前，
  // 语法糖已经设置了变量 x 和 y。
  Point(this.x, this.y);
}

class Point {
  num x, y;

  Point(this.x, this.y);

  // 命名构造函数
  Point.origin() {
    x = 0;
    y = 0;
  }
}

class Person {
  String firstName;
  // 命名构造函数
  Person.fromJson(Map data) {
    print('in Person');
  }
}
// Employee 类的构造函数调用了父类 Person 的命名构造函数
class Employee extends Person {
  // Person 没有默认的构造函数, 所以必须要用 super.fromJson(data)手动继承一下
  Employee.fromJson(Map data) : super.fromJson(data) {
    print('in Employee');
  }
}

main() {
  var emp = new Employee.fromJson({});

  // Prints:
  // in Person
  // in Employee
  if (emp is Person) {
    // Type check
    emp.firstName = 'Bob';
  }
  (emp as Person).firstName = 'Bob';
}

import 'dart:math';

class Point {
  // 定义构造函数参数
  final num x;
  final num y;
  final num distanceFromOrigin;
  // 初始化参数
  Point(x, y)
      : x = x,
        y = y,
        distanceFromOrigin = sqrt(x * x + y * y);
}

main() {
  var p = new Point(2, 3);
  print(p.distanceFromOrigin);
}

class Point {
  num x, y;

  // 类的主构造函数。
  Point(this.x, this.y);

  // 指向主构造函数
  Point.alongXAxis(num x) : this(x, 0);
}

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);
  assert(rect.left == 3);
  rect.right = 12;
  assert(rect.left == -8);
}

// person 类。 隐式接口里面包含了 greet() 方法声明。
class Person {
  // 包含在接口里，但只在当前库中可见。
  final _name;

  // 不包含在接口里，因为这是一个构造函数。
  Person(this._name);

  // 包含在接口里。
  String greet(String who) => 'Hello, $who. I am $_name.';
}

// person 接口的实现。
class Impostor implements Person {
  get _name => '';

  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')));
  print(greetBob(Impostor()));
}

void main() {
  var currentSeason  = Season.spring;

  print(currentSeason.index);
  print(Season.values);
  // 如果不处理所有枚举值, 会受到警告:
  switch(currentSeason){
    case Season.spring:
      print("1-3月");
      break;
    case Season.summer:
      print("4-6月");
      break;
    case Season.autumn:
      print("7-9月");
      break;
    case Season.winter:
      print("10-12月");
      break;
  }
}

enum Season{
  spring,
  summer,
  autumn,
  winter
}

class Queue {
  static const initialCapacity = 16;
  // ···
}

void main() {
// 静态变量直到它们被使用的时候才会初始化.
  assert(Queue.initialCapacity == 16);
}

// T 是一个备用类型, 属于类型占位符, 在开发者调用该接口的时候会指定具体类型.
abstract class Cache<T> {
  T getByKey(String key);
  void setByKey(String key, T value);
}

var names = <String>['Seth', 'Kathy', 'Lars'];
var ages = <num>[1,21,2,3];
var aaa = <dynamic>[1,21,2,3, 'sad', {'name': 'zhang'}, [12,21,3]];
var uniqueNames = <String>{'Seth', 'Kathy', 'Lars'};
var pages = <String, String>{
  'index.html': 'Homepage',
  'robots.txt': 'Hints for web robots',
  'humans.txt': 'We are people, not machines'
};

// 定义 Set 数据接口中类型为 string
var nameSet = Set<String>.from(names);
// 创建了一个 key 为 integer, value 为 View 的 map 对象：
var views = Map<int, View>();

T first<T>(List<T> ts) {
  // 做一些初始化工作, 然后...
  T tmp = ts[0];
  // 做一些额外的处理和检查, 然后...
  return tmp;
}

// 引入第三方库文件
import 'package:flutter/material.dart';
// 引入项目中的文件
import './animated_cross_fade_demo.dart';
// 引入 dart 提供的库文件
import 'dart:html

// 当不同库出现同样标识符, 可以用库前缀解决解决命名冲突
import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;

import 'package:lib1/lib1.dart' show foo; // 仅导入 foo
import 'package:lib2/lib2.dart' hide foo; // 除了 foo 外都导出

// 当使用的时候在加载
import 'package:deferred/hello.dart' deferred as hello;

// 使用的时候
hello.loadLibrary();

使用 `library` 加上一个标识符 `point` 定义当前库的名字
library point;

// 主文件 定义一个 math 库。它由 base，random 两部分组成
library math;
part 'base.dart';
part 'random.dart';

// 在 base.dart 文件的开头
part of math

// 在 random.dart 文件的开头
part of math;

// 定义函数参数类型与返回值
typedef int CalFunc(int num1, int num2);
main() {
    int num1 = 1;
    int num2 = 2;
    // 参数调用与传递
    int calculate(CalFunc func) {
        return func(num1, num2);
    };
    int result = calculate((int num1, int num2) {
        return num1 - num2;
    });
    print(result);
}

var name = 'name';
dynamic name1 = 'name1';
String name2 = 'name2';

// 变量的赋值
name = 'a';
name1 = 'a1';
name2 = 'a2';