Flutter 常用语法详解

1.abstract

abstract被用统一定义一个抽象类，不可以被实例化，Abstract classes 常被用于定义接口和相关实现。

//abstract定义抽象类，一般用于定义接口和实现
abstract class IInfo {
  dynamic getValue();
}

abstract class IStorage {
  bool save(IInfo info);
  bool contains(IInfo info);
  List<IInfo> getAll();
  void clear();
}
//CommonStorage 
class CommonStorage implements IStorage {
}

总结 : abstract常用于抽离类的API或者公共功能，对于逻辑复杂也可以抽离，我们常用的类都需要有这样的意识。

2.extends 、 implements 、 mixins的用法与区别

2.1 extends继承

Flutter 的继承是单继承；构造函数不可以继承;子类重写超类的方法要使用@override；子类调用超类的方法要是有super;

比如下面自定义FpmOverlayEntry类

class FpmOverlayEntry extends OverlayEntry {
  final WidgetBuilder builder;
  var show = false;

  FpmOverlayEntry({
    @required this.builder,
    bool opaque = false,
    bool maintainState = false,
  }) : super(builder: builder, opaque: opaque, maintainState: maintainState);

  @override
  void remove() {
    show = false;
    super.remove();
  }
}

2.2 implements接口实现

什么叫做接口实现？就是如果有一个类 A,你想让类B拥有类A的API，但又不想拥有A里的实现，那么你就应该把A当做接口，类B implements 类A.

注意:需要在子类里重新实现，在子类实现的时候要加@override，成员变量重新实现同样需要加@override。

下面以上面的例子说明

//CommonStorage 
class CommonStorage implements IStorage {
  @override
  List<IInfo> getAll() {
    return items.toList();
  }
   @override
  bool save(IInfo info) {
    if (items.length >= maxCount) {
      items.removeFirst();
    }
    items.add(info);
    return true;
  }

  @override
  bool contains(IInfo info) {
    return items.contains(info);
  }

  @override
  void clear() {
    return items.clear();
  }
}

2.3 mixins(with)混合

mixins的中文意思是混入，就是在类中混入其他功能。需要注意的是mixins是要通过非继承的方式来复用类中的代码，这是和继承是不一样的。

有一个类A，A中有一个方法a()，还有一个方法B，也想使用a()方法，而且不能用继承，那么这时候就需要用到mixins,类A就是mixins类(混入类)，类B就是要被mixins的类，对应的Dart代码如下:

class A {
  String content = 'A Class';
  void a(){
    print("a");
  }
}

class B with A{
}

B b = new B();
print(b.content);
b.a();

总结 : 这三种关系可以同时存在，但是有前后顺序：extends -> mixins -> implements。extends就是正常的java或者swift的继承，implements等于是只要对应接口的声明，不需实现，mixins就是你不想继承的时候又想使用其他类的功能。

3.extension扩展

extension的主要功能是主要功能给已经存在的类添加新的member function，往里面增加新的函数。对某个类可以有多个 扩展extension,但是 扩展extension 中方法不能重名,否则会造成crash.

extension ListExtension<T> on List<T> {
  T getSafeItem(int index) {
    if (this != null && index < this.length) {
      return this[index];
    }
    return null;
  }

  addIf(T t) {
    if (this != null && t != null) {
      this.add(t);
    }
  }
}

4.dart语法小技巧

4.1 static

使用 static 关键字来实现类级别的变量和函数 , static 修饰的静态变量不能访问 非static 修饰的成员.

class PrefixManger {
  void initData() {
    var prefix = Prefix();
    prefix.removeCount();
  }
}

class Prefix {
  static int pageCount = 0;

  static void addCount() {
    pageCount = 1;
  }
  //不合理写法
  void removeCount() {
    pageCount --;
  }
  //正确写法
  staic void removeCount() {
    pageCount --;
  }
}

类中的常量用 static const修饰. 不可修改

static const int pageCount = 0;

4.2 T泛型

使用泛型可以精简代码 ，不必要关注对象类型

//不用泛型，存储 Object
abstract class ObjectCache {
  Object getByKey(String key);
  void setByKey(String key, Object value);
}
//不用泛型，存储 String
abstract class StringCache {
  String getByKey(String key);
  void setByKey(String key, String value);
}
//使用泛型，则可以省去为每一种类型单独编写代码
abstract class Cache<T> {
  T getByKey(String key);
  void setByKey(String key, T value);
}

4.3 可选参数

下面中的y和z都是有默认值的可选参数

int test(int x, {int y = 1, int z =1}) {
  return x + y + z;
}

4.4 factory关键字

简单来说就是创建单例使用的关键字，详细见下面方法

class Manager {
  // 工厂模式 : 单例公开访问点
  factory Manager() => _getInstance();

  static Manager get instance => _getInstance();

  // 静态私有成员，没有初始化
  static Manager _instance;

  // 私有构造函数
  Manager._internal() {
    // 初始化
  }

  // 静态、同步、私有访问点
  static Manager _getInstance() {
    if (_instance == null) {
      _instance = new Manager._internal();
    }
    return _instance;
  }
}