✨✨✨✨✨ 魏什么_多喝水 Flutter 之路

abstract: 抽象类

使用 abstract 修饰符来定义 抽象类 — 抽象类不能实例化。 抽象类通常用来定义接口，以及部分实现。 如果希望抽象类能够被实例化，那么可以通过定义一个 工厂构造函数 来实现。

抽象类通常具有 抽象方法。 下面是一个声明具有抽象方法的抽象类示例:

// 这个类被定义为抽象类，
// 所以不能被实例化。
abstract class AbstractContainer {
  // 定义构造行数，字段，方法...

  void updateChildren(); // 抽象方法。
}

dynamic: 动态的

动态的,我的理解和oc中的id,swift中的Any是一样的

dynamic ，var、object 三种类型的区别

1. dynamic:所有dart 对象的基础类型，在大多数情况下，不直接使用它
2. 通过它定义的变量会关闭类型检查，这意味着 dynamix x= 'hal'; x.foo();
3. 这段贷款静态类型检查不会报错，但是运行时会crash，因为x 并没有foo（） 方法，所以建议大家在编程时不要直接使用dynamic；
4. var: 是一个关键字，意思是"我不关心这里的类型是什么"，系统会自动判断类型 runtimeType;
5. object: 是Dart 对象的基类，当你定义： object o =xxx ;时这个时候系统会认为o 十个对象，你可以调用o的toString()和hashCode()方法
6. 因为Object 提供了这些方法，但是如果你尝试调用o.foo()时，静态类型检查会运行报错。
7. 综上不难看出dynamic 与object 的最大的区别是在静态类型检查上。

implements: 隐式接口

每个类都隐式的定义了一个接口，接口包含了该类所有的实例成员及其实现的接口。 如果要创建一个 A 类，A 要支持 B 类的 API ，但是不需要继承 B 的实现， 那么可以通过 A 实现 B 的接口。

一个类可以通过 implements 关键字来实现一个或者多个接口， 并实现每个接口要求的 API。 例如：

// 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()));
}

下面示例演示一个类如何实现多个接口： Here’s an example of specifying that a class implements multiple interfaces:

class Point implements Comparable, Location {...}

show 导入库的一部分

如果你只使用库的一部分功能，则可以选择需要导入的 内容。例如：

// Import only foo.
import 'package:lib1/lib1.dart' show foo;

// Import all names EXCEPT foo.
import 'package:lib2/lib2.dart' hide foo;

as 类型转换

is 类型检查

如果对象具有指定的类型，则为True

is！类型检查

如果对象具有指定的类型，则为False

static 类变量和方法

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

1. 静态变量
   静态变量（类变量）对于类级别的状态是非常有用的：

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

   静态变量只到它们被使用的时候才会初始化。

2. 静态方法
   静态方法（类方法）不能在实例上使用，因此它们不能访问 this

   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);
   }
   

   对于常见或广泛使用的工具和函数， 应该考虑使用顶级函数而不是静态方法。

   静态函数可以当做编译时常量使用。 例如，可以将静态方法作为参数传递给常量构造函数。

assent 断言

如果 assert 语句中的布尔条件为 false ， 那么正常的程序执行流程会被中断。 在本章中包含部分 assert 的使用， 下面是一些示例：

// 确认变量值不为空。
assert(text != null);

// 确认变量值小于100。
assert(number < 100);

// 确认 URL 是否是 https 类型。
assert(urlString.startsWith('https'));

assert 语句只在开发环境中有效， 在生产环境是无效的； Flutter 中的 assert 只在 debug 模式 中有效。

assert 的第二个参数可以为其添加一个字符串消息。

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

assert 的第一个参数可以是解析为布尔值的任何表达式。 如果表达式结果为 true ， 则断言成功，并继续执行。 如果表达式结果为 false ， 则断言失败，并抛出异常 (AssertionError) 。

async await 处理 Future 异步

extends 扩展类

使用 extends 关键字来创建子类， 使用 super 关键字来引用父类：

class Television {
  void turnOn() {
    _illuminateDisplay();
    _activateIrSensor();
  }
  // ···
}

class SmartTelevision extends Television {
  void turnOn() {
    super.turnOn();
    _bootNetworkInterface();
    _initializeMemory();
    _upgradeApps();
  }
  // ···
}

sync* yield 生成器 （简单标记下,会有专门说生成器的）

通过在函数体标记 sync*， 可以实现一个同步生成器函数。 使用 yield 语句来传递值：

Iterable<int> naturalsTo(int n) sync* {
  int k = 0;
  while (k < n) yield k++;
}

factory: 工厂构造函数 （单例）

工厂构造函数

class Class06{
  int a;
  static Class06 instance ;  
  factory Class06(int a){
    if(instance==null){
      instance = new Class06.fun1(a);
    }
    return instance;
  }
  Class06.fun1(this.a);
}

void main(){
    var class07 = new Class06(3);
    print(class07.a);
}

Final 和 Const： 从来不会被修改的变量

使用过程中从来不会被修改的变量， 可以使用 final 或 const, 而不是 var 或者其他类型， Final 变量的值只能被设置一次； Const 变量在编译时就已经固定 (Const 变量 是隐式 Final 的类型.) 最高级 final 变量或类变量在第一次使用时被初始化。

实例变量可以是 final 类型但不能是 const 类型。 必须在构造函数体执行之前初始化 final 实例变量 —— 在变量声明中，参数构造函数中或构造函数的初始化列表中进行初始化。

创建和设置一个 Final 变量：

final name = 'Bob'; // 不可在修改,如果再次赋值直接报错
final String nickname = 'Bobby';

如果需要在编译时就固定变量的值，可以使用 const 类型变量。 如果 Const 变量是类级别的，需要标记为 static const。 在这些地方可以使用在编译时就已经固定不变的值，字面量的数字和字符串， 固定的变量，或者是用于计算的固定数字：

const bar = 1000000; // 压力单位 (dynes/cm2)
const double atm = 1.01325 * bar; // 标准气压

非 Final ， 非 const 的变量是可以被修改的，即使这些变量 曾经引用过 const 值。

foo = [1, 2, 3]; // 曾经引用过 const [] 常量值。

finally

不管是否抛出异常， finally 中的代码都会被执行。 如果 catch 没有匹配到异常， 异常会在 finally 执行完成后，再次被抛出：

try {
  breedMoreLlamas();
} finally {
  // Always clean up, even if an exception is thrown.
  cleanLlamaStalls();
}

任何匹配的 catch 执行完成后，再执行 finally ：

try {
  breedMoreLlamas();
} catch (e) {
  print('Error: $e'); // Handle the exception first.
} finally {
  cleanLlamaStalls(); // Then clean up.
}

deferred : 延迟加载库

Deferred loading (也称之为 lazy loading) 可以让应用在需要的时候再加载库。 下面是一些使用延迟加载库的场景：

1. 减少 APP 的启动时间。
2. 执行 A/B 测试，例如 尝试各种算法的 不同实现。
3. 加载很少使用的功能，例如可选的屏幕和对话框。

要延迟加载一个库，需要先使用 deferred as 来导入：

import 'package:greetings/hello.dart' deferred as hello;

当需要使用的时候，使用库标识符调用 loadLibrary() 函数来加载库：

Future greet() async {
  await hello.loadLibrary();
  hello.printGreeting();
}

在一个库上你可以多次调用 loadLibrary() 函数。但是该库只是载入一次。
使用延迟加载库的时候，请注意一下问题：

• 延迟加载库的常量在导入的时候是不可用的。 只有当库加载完毕的时候，库中常量才可以使用。
• 在导入文件的时候无法使用延迟库中的类型。 如果你需要使用类型，则考虑把接口类型移动到另外一个库中， 让两个库都分别导入这个接口库。
• Dart 隐含的把 loadLibrary() 函数导入到使用 deferred as 的命名空间 中。 loadLibrary() 方法返回一个 Future。

Typedefs: 别名 给闭包(函数)重新命名

在 Dart 中，函数也是对象，就想字符和数字对象一样。 使用 typedef ，或者 function-type alias 为函数起一个别名， 别名可以用来声明字段及返回值类型。 当函数类型分配给变量时，typedef会保留类型信息。

请考虑以下代码，代码中未使用 typedef ：

class SortedCollection {
  Function compare;

  SortedCollection(int f(Object a, Object b)) {
    compare = f;
  }
}

// Initial, broken implementation. // broken ？
int sort(Object a, Object b) => 0;

void main() {
  SortedCollection coll = SortedCollection(sort);

  // 虽然知道 compare 是函数，
  // 但是函数是什么类型 ？
  assert(coll.compare is Function);
}

当把 f 赋值给 compare 的时候，类型信息丢失了。 f 的类型是 (Object, Object) → int (这里 → 代表返回值类型)， 但是 compare 得到的类型是 Function 。如果我们使用显式的名字并保留类型信息， 这样开发者和工具都可以使用这些信息：

typedef Compare = int Function(Object a, Object b);

class SortedCollection {
  Compare compare;

  SortedCollection(this.compare);
}

// Initial, broken implementation.
int sort(Object a, Object b) => 0;

void main() {
  SortedCollection coll = SortedCollection(sort);
  assert(coll.compare is Function);
  assert(coll.compare is Compare);
}

目前，typedefs 只能使用在函数类型上， 我们希望将来这种情况有所改变。

由于 typedefs 只是别名， 他们还提供了一种方式来判断任意函数的类型。例如：

typedef Compare<T> = int Function(T a, T b);

int sort(int a, int b) => a - b;

void main() {
  assert(sort is Compare<int>); // True!
}