✨✨✨✨✨ 魏什么_多喝水 Flutter 之路
abstract: 抽象类
使用 abstract 修饰符来定义 抽象类 — 抽象类不能实例化。 抽象类通常用来定义接口，以及部分实现。 如果希望抽象类能够被实例化，那么可以通过定义一个 工厂构造函数 来实现。
抽象类通常具有 抽象方法。 下面是一个声明具有抽象方法的抽象类示例:
// 这个类被定义为抽象类，
// 所以不能被实例化。
abstract class AbstractContainer {
// 定义构造行数，字段，方法...
void updateChildren(); // 抽象方法。
}
dynamic: 动态的
动态的,我的理解和oc中的id,swift中的Any是一样的
dynamic ，var、object 三种类型的区别
- dynamic:所有dart 对象的基础类型，在大多数情况下，不直接使用它
- 通过它定义的变量会关闭类型检查，这意味着 dynamix x= 'hal'; x.foo();
- 这段贷款静态类型检查不会报错，但是运行时会crash，因为x 并没有foo（） 方法，所以建议大家在编程时不要直接使用dynamic；
- var: 是一个关键字，意思是"我不关心这里的类型是什么"，系统会自动判断类型 runtimeType;
- object: 是Dart 对象的基类，当你定义： object o =xxx ;时这个时候系统会认为o 十个对象，你可以调用o的toString()和hashCode()方法
- 因为Object 提供了这些方法，但是如果你尝试调用o.foo()时，静态类型检查会运行报错。
- 综上不难看出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 关键字实现类范围的变量和方法。
-
静态变量
静态变量（类变量）对于类级别的状态是非常有用的：class Queue { static const initialCapacity = 16; // ··· } void main() { assert(Queue.initialCapacity == 16); }静态变量只到它们被使用的时候才会初始化。
-
静态方法
静态方法（类方法）不能在实例上使用，因此它们不能访问 thisimport '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) 可以让应用在需要的时候再加载库。 下面是一些使用延迟加载库的场景：
- 减少 APP 的启动时间。
- 执行 A/B 测试，例如 尝试各种算法的 不同实现。
- 加载很少使用的功能，例如可选的屏幕和对话框。
要延迟加载一个库，需要先使用 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!
}
