dart 没有 publiic protect private

变量名以_开头 意味着它是私有的

没有初始化的变量都被声明为空

Dart 是强 bool 类型检查，只有bool 类型的值是true 才被认为是true

• Map的声明

        var hawaiianBeaches = {
            'oahu' : ['waikiki', 'kailua', 'waimanalo'],
            'big island' : ['wailea bay', 'pololu beach'],
            'kauai' : ['hanalei', 'poipu']
        };

• list 声明

  // 使用List的构造函数，也可以添加int参数，表示List固定长度，不能进行添加 删除操作
          var vegetables = new List();
          // 或者简单的用List来赋值
          var fruits = ['apples', 'oranges'];
          // 添加元素
          fruits.add('kiwis');
          // 添加多个元素
          fruits.addAll(['grapes', 'bananas']);
          // 获取第一个元素
          fruits.first;
          // 获取元素最后一个元素
          fruits.last;
          // 查找某个元素的索引号
          assert(fruits.indexOf('apples') == 0);
          // 删除指定位置的元素，返回删除的元素
          fruits.removeAt(index);
          // 删除指定元素,成功返回true，失败返回false
          fruits.remove('apples');
          // 删除最后一个元素，返回删除的元素
          fruits.removeLast();
          // 删除指定范围元素，含头不含尾，成功返回null
          fruits.removeRange(start,end);
          // 删除指定条件的元素，成功返回null
          fruits.removeWhere((item) => item.length >6)；
          // 删除所有的元素
          fruits.clear();
          // sort()对元素进行排序，传入一个函数作为参数，return <0表示由小到大， >0表示由大到小
          fruits.sort((a, b) => a.compareTo(b));
  

函数

• 必选：必须放在参数列表的前面

• 可选：可选参数跟在必须的参数后面，通过[]来制定可选参数

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

    print(say('tangbo', 'woaini','iphone'));
  

  可选参数可以设置默认值，必选参数不可以设置，如果没有传入才使用默认值。

• 函数可以作为另一个函数的参数

printElement(element) {
          print(element);
        }
        var list = [1, 2, 3];
        // Pass printElement as a parameter.
        list.forEach(printElement);

• 函数可以匿名

  var list =  [1,2,322,4,5];
  list.forEach((e){
    print(list.indexOf(e).toString()+':'+e.toString());
  });

运算符

is 运算符，a is b，用于判断 a 对象是否是 b 类的实例，返回 bool 值

is！意义与上面相反

as 运算符；用于检查类型

  (emp as Person).firstName = 'Bob';

如果 emp 为空或者不是 Person 的实例，会抛出异常

??= 运算符

  b ??= value; // 如果 b 为空，把 value 赋值给 b;
               // 否则，b 不变

?? 运算符

  String toString() => msg ?? super.toString();
  //如果 msg 不为空，返回 msg；否则返回后面的

.. 运算符，把对同一对象的不同操作串联起来

  final addressBook = (new AddressBookBuilder()
        ..name = 'jenny'
        ..email = 'jenny@example.com'
        ..phone = (new PhoneNumberBuilder()
              ..number = '415-555-0100'
              ..label = 'home')
            .build())
      .build();

流程控制语句

类

使用.来调用实例的变量或者方法。

使用 ?. 来避免左边操作数为null引发异常。

使用const替代new来创建编译时的常量构造函数。

两个使用const构建的同一个构造函数，实例相等。

获取对象的运行时类型使用：o.runtimeType

使用new语句来构造一个类。构造函数的名字可能是ClassName，也可以是ClassName.identifier

所有实例变量会生成一个隐式的getter方法，不是final或const的实例变量也会生成一个隐式的setter方法

构造函数不能被继承，子类不会继承父类的构造函数。如果不显式提供子类的构造函数，系统就提供默认的构造函数。

class Point {
          num x;
          num y;

          Point(this.x, this.y);

          // 命名构造函数
          Point.fromJson(Map json) {
            x = json['x'];
            y = json['y'];
          }
        }

使用命名构造函数可以实现一个类多个构造函数。构造函数不能被继承，父类中的命名构造函数不能被子类继承。如果想要子类也拥有一个父类一样名字的构造函数，必须在子类实现这个构造函数。

class Employee extends Person {
//父类没有提供无参的非命名构造，必须手动调用一个构造函数,调用的时候先调用父类的。
  Employee.fromJson(Map data) : super.fromJson(data) {
    print('in Employee');
  }
}

工厂构造函数

当实例化了一个构造函数后，不想每次都创建该类的一个新的实例的时候使用factory关键字，定义工厂构造函数，从缓存中返回一个实例，或返回一个子类型的实例。

class Logger {
          final String name;
          bool mute = false;
          static final Map<String, Logger> _cache = <String, Logger>{}; // 缓存保存对象
          factory Logger(String name) {
            if (_cache.containsKey(name)) {
              return _cache[name];
            } else {
              final logger = new Logger._internal(name);
              _cache[name] = logger;
              return logger;
            }
          }
          Logger._internal(this.name);// 命名构造函数
          void log(String msg) {
            if (!mute) {
              print(msg);
            }
          }
        }

        main() {
          var p1 = new Logger("1");
          p1.log("2");

          var p2 = new Logger('22');
          p2.log('3');
          var p3 = new Logger('1');// 相同对象直接访问缓存
        }

抽象类

使用abstract关键字定义一个抽象类，抽象类不能实例化。抽象类通常用来定义接口

隐式接口

每一个类都隐式的定义一个接口，这个接口包含了这个类的所有的实例成员和它实现的所有接口

一个类可以实现一个或者多个接口，通过implements关键字

可调用类

Dart 语言中为了能够让类像函数一样能够被调用，可以实现call()方法。

 class  WannabeFunction{
  call(num a,num b,num c){
   return a+b+c;
  }
}
var wf = new WannabeFunction();
   var out = wf(1,2,3);
   print('$out');
   print(wf.runtimeType);
   print(out.runtimeType);
   print(wf is! Function);