设计思想无非是两个问题：如何表达信息、如何处理信息、
作为一门真正面向对象的编程语言、Dart将处理信息的过程抽象为了对象。以结构化的方式将功能分解。而函数、类与运算符就是抽象中最重要的手段。
从函数、类与运算符的角度、进一步和你讲述Dart面向对象设计的基本思路。

函数

  1. 定义一个判断整数是否为0的isZero函数，并把它传递给另一个printInfo函数，完成格式化打印出判断结果的功能。
  2. bool isZero(int number) {
  3. // 判断整数是否为0
  4.  return number == 0;
  5. }
  7. void printInfo(int number, Function check) {
  8. // 用check函数来判断整数是否为0
  9.  print（"$number is Zero: ${check(number)}"）;
  10. }
  12. Function f = isZero;
  13. int x = 10;
  14. int y = 0;
  15. printInfo(x,f); // 输出 10 is Zero: false
  16. printInfo(y,f); // 输出0 is Zero：true
  18. 如果函数体只有一行表达式、就比如上面示例中的isZero、printInfo函数、我们可以向javaScript语言那样用箭头函数来简化这个函数
  19. bool isZero(int number) => nuber == 0;
  20. void printInfo(int number,Function check) => print("$number is Zero: ${check(number)}");
  22. 函数需要传递多个参数。Dart认为重载会导致混乱、因此设计之初不支持重载、提供了可选命名参数和可选参数。具体方式、再声明函数时：
  23. 给参数增加{},以paramName：value的方式指定调用参数，也就是可选命名参数。
  24. 给参数增加【】，则意味着这些参数是可以忽略的，也就是可选参数。
  25. 使用这两种方式定义函数时，还可以在参数末传递时设置默认值，以一个只有两个参数的简单函数为例。具体用法
  26. // 要达到可选命名参数的用法、就在定义函数的时候给参数加上{}
  27. void enableFlags({bool bold, bool hidden}) => print("$bold, $hidden");
  28. // 定义可选命名参数时增加默认值。
  29. void enable2Flags({bool bold = true, bool hidden = false}) => print("$bold, $hidden");
  30. // 可忽略的参数在函数定义时使用【】符号指定。
  31. void enable3Flags({bool bold, [bool hidden]}) => printf("$bold,$hidden");
  32. // 定义可忽略参数时增加默认值
  33. void enable4Flags(bool bold, [bool hidden = false]) => print("$bold, $hidden");
  35. // 可选命名参数函数调用
  36. enable1Flags(bold: true，hidden: false); // true，false
  37. enable1Flags(bold: true); // true、null
  38. enable2Flags(bold: false); // false，false
  40. // 可忽略参数函数调用
  41. enable3Flags(true,false); // true,false
  42. enable3Flags(true);   // true, null
  43. enable4Flags(true); // true，false
  44. enable4Flags(true,true); // true,true
  46. 在Flutter中会大量用到可选命名参数的方式。

类

类是特定类型的数据和方法的集合，也是创建对象的模板。与其他语言一样、Dart为类概念提供了内置支持。
Dart是面向对象的语言、每个对象都是一个类的实例，都继承自顶层类型Object。在Dart中，实例变量和实例方法
、类变量和类方法的声明与Java类似。Dart中没有public、protected、private这些关键字、只需要在声明变量和方法
时，在前面加上”“即可作为private方法使用。如果不加’’“，则默认为public。不过”_”的限制范围并不是类访问级别，而是库
访问级别。

  1. class Point{
  2.   num x, y;
  3.   static num factor = 0;
  4.   // 语法糖、等同于在函数体内: this.x = x; this.y = y;
  5.   Point(this.x,this.y);
  6.   void printInfo() => print('($x,4 $y)');
  7.   static void printZvalue() => print('$factor');
  8. }
  10. var p = new Point(100,200); // new 关键字可以省略
  11. p.printInfo(); // 输出（100，200);
  12. Point.factor = 10;
  13. Point.printZValue(); // 输出 10
  15. 在Point类中，定义两个成员变量x和y，通过构造函数语法糖进行初始化，成员函数PrintInfo的作用是打印他们的信息。
  16. 而类变量factor，则在声明时就已经赋好了默认值0，类函数printZValue会打印出他的信息。
  18. 有时候类的实例化需要根据参数提供多种初始化方式，除了可选命名参数和可选参数之外，Dart还提供了命名构造函数的方式。使得类的实例化过程
  19. 语义更清晰。
  21. Dart支持初始化列表。在构造函数的函数体真正执行之前、还有机会给实例变量赋值，甚至重定向至另一个构造函数。
  23. class Point {
  24.   num x,y,z;
  25.   Point(this,x, this.y) : z = 0; //初始化变量 z
  26.   Point.bottom(num x) : this(x, 0); // 重定向构造函数
  27.   void printInfo() => print('($x,$y,$z)');
  28. }
  29. var p = Point.bottom(100);
  30. p.printInfo(); //输出（100，0，0）;

复用

在面向对象的编程语言中、将其他类的变量和方法纳入本类中进行复用的方式一般有两种。继承父类和接口实现。当然。在Dart也不例外。
在Dart中，可以对同一个父类进行继承或接口实现。继承父类意味,子类由父类派生、会自动获取父类的成员变量和方法实现，子类可以根据需要覆写构造函数和父类方法。
接口实现意味着，子类获取到的仅仅是接口的成员变量符号和方法符号。需要重新实现成员变量，以及方法的声明和初始化。否则编译器会报错。

  1. Dart中继承和接口的差别
  2. class Point {
  3.  num x = 0, y = 0;
  4.  void printInfo => print('($x,$y)');
  5. }
  7. // Vector 继承自 Point
  8. class Vector extends Point{
  9.   num z = 0;
  10.   @override
  11.   void printInfo() => print('($x,$y,$z)'); // 覆写了printInfo 实现。
  12. }
  14. // Coordinate 是对Point的接口的实现
  15. class Coordinate implements Point {
  16.   num x = 0,y = 0; //成员变量需要重新声明
  17.   void printInfo() => print('($x,$y)'); // 成员函数需要重新声明实现
  18. }
  20. var xxx = Vector();
  21. xxx
  22.  ..x = 1
  23.  ..y = 2
  24.  ..z = 3; // 级联运算符、等同于 xxx.x = 1; xxx.y = 2,xxx.z = 3;
  25.  xxx.printInfo(); // 输出（1，2，3）
  27.  var yyy = Coordonate();
  28.  yyy
  29.    ..x = 1
  30.    ..y = 2; // 级联运算符，等同于yyy.x = 1; yyy.y = 2;
  31.  yyy.printInfo(); // 输出（1,2）
  32.  print (yyy is Point); // true
  33.  print (yyy is Coordinate); // true
  35.  子类Coordinator采用接口实现的方式、仅仅只是获取到父类的Point的一个空壳。只能从语义层面当成接口Point来用。并不能
  36. 复用Point的原有实现，除了继承和接口实现外，Dart还提供了另一种机制来实现类的复用，即"混入（Mixin）"混入鼓励