Flutter技术与实战(3)

Dart语言基础

基础语法与类型变量

Dart初体验
printInteger(int a) {
  print('Hello world, this is $a.'); 
}

main() {
  var number = 2019; 
  printInteger(number); 
}
——————————————————————————————————————————————————————————————————————————————
Hello world, this is 2019. 
Dart的变量与类型
  • 在 Dart 中,我们可以用 var 或者具体的类型来声明一个变量。当使用 var 定义变量时,表示类型是交由编译器推断决定的,当然你也可以用静态类型去定义变量,更清楚地跟编译器表达你的意图,这样编辑器和编译器就能使用这些静态类型,向你提供代码补全或编译警告的提示了。
  • 在默认情况下,未初始化的变量的值都是 null,因此我们不用担心无法判定一个传递过来的、未定义变量到底是 undefined,还是烫烫烫而写一堆冗长的判断语句了。
  • Dart 是类型安全的语言,并且所有类型都是对象类型,都继承自顶层类型 Object,因此一切变量的值都是类的实例(即对象),甚至数字、布尔值、函数和 null 也都是继承自 Object 的对象。
  • Dart 内置了一些基本类型,如 num、bool、String、List 和 Map,在不引入其他库的情况下可以使用它们去声明变量。
num、bool与String
  • Dart 的数值类型 num,只有两种子类:即 64 位 int 和符合 IEEE 754 标准的 64 位 double。前者代表整数类型,而后者则是浮点数的抽象。
  • 有其他高级运算方法的需求 num 无法满足,你可以试用一下 dart:math 库。这个库提供了诸如三角函数、指数、对数、平方根等高级函数。
int x = 1;
int hex = 0xEEADBEEF;
double y = 1.1;
double exponents = 1.13e5;
int roundY = y.round();
  • 为了表示布尔值,Dart 使用了一种名为 bool 的类型。在 Dart 里,只有两个对象具有 bool 类型:true 和 false,它们都是编译时常量。
  • Dart 是类型安全的,因此我们不能使用 if(nonbooleanValue) 或 assert(nonbooleanValue) 之类的在 JavaScript 可以正常工作的代码,而应该显式地检查值。
// 检查是否为0,在 Dart 中需要显示地与 0 做比较
var number = 0;
assert(number == 0);
// assert(number); 错误
  • Dart 的 String 由 UTF-16 的字符串组成。和 JavaScript 一样,构造字符串字面量时既能使用单引号也能使用双引号,还能在字符串中嵌入变量或表达式:你可以使用 ${express} 把一个表达式的值放进字符串。而如果是一个标识符,你可以省略{}。
var s = 'cat';
var s1 = 'this is a uppercased string: ${s.toUpperCase()}';
  • 常见字符串的拼接,Dart 则通过内置运算符“+”实现。
var s2 = 'Hello' + ' ' + 'World!' ;
  • 对于多行字符串的构建,你可以通过三个单引号或三个双引号的方式声明,这与 Python 是一致的。
var s3 = """This is a
multi-line string.""";
List与Map
  • 其他编程语言中常见的数组和字典类型,在 Dart 中的对应实现是 List 和 Map,统称为集合类型。它们的声明和使用很简单,和 JavaScript 中的用法类似。
var arr1 = ["Tom", "Andy", "Jack"];
var arr2 = List.of([1,2,3]);
arr2.add(499);
arr2.forEach((v) => print('${v}'));
  
var map1 = {"name": "Tom", 'sex': 'male'}; 
var map2 = new Map();
map2['name'] = 'Tom';
map2['sex'] = 'male';
map2.forEach((k,v) => print('${k}: ${v}')); 
  • 容器里的元素也需要有类型,比如上述代码中 arr2 的类型是 List,map2 的类型则为 Map。Dart 会自动根据上下文进行类型推断,所以你后续往容器内添加的元素也必须遵照这一类型。
  • 如果编译器自动推断的类型不符合预期,我们当然可以在声明时显式地把类型标记出来,不仅可以让代码提示更友好一些,更重要的是可以让静态分析器帮忙检查字面量中的错误,解除类型不匹配带来的安全隐患或是 Bug。
  • 如果往 arr2 集合中添加一个浮点数 arr2.add(1.1),尽管语义上合法,但编译器会提示类型不匹配,从而导致编译失败。
  • 和 Java 语言类似,在初始化集合实例对象时,你可以为它的类型添加约束,也可以用于后续判断集合类型。
var arr1 = <String>['Tom', 'Andy', 'Jack'];
var arr2 = new List<int>.of([1,2,3]);
arr2.add(499);
arr2.forEach((v) => print('${v}'));
print(arr2 is List<int>); // true

var map1 = <String, String>{'name': 'Tom','sex': 'male',};
var map2 = new Map<String, String>();
map2['name'] = 'Tom';
map2['sex'] = 'male';
map2.forEach((k,v) => print('${k}: ${v}')); 
print(map2 is Map<String, String>); // true
常量定义
  • 如果你想定义不可变的变量,则需要在定义变量前加上 final 或 const 关键字。
    • const,表示变量在编译期间即能确定的值;
    • final 则不太一样,用它定义的变量可以在运行时确定值,而一旦确定后就不可再变。
final name = 'Andy';
const count = 3;

var x = 70;  
var y = 30;
final z = x / y;
  • const 适用于定义编译常量(字面量固定值)的场景,而 final 适用于定义运行时常量的场景。
流程控制语法
  • 对于流程控制语法:如 if-else、for、while、do-while、break/continue、switch-case、assert,由于与其他编程语言类似。
  • 官方文档:https://api.dart.dev/stable/2.2.0/index.html

函数、类与运算符

函数
  • 函数是一段用来独立地完成某个功能的代码。在 Dart 中,所有类型都是对象类型,函数也是对象,它的类型叫作 Function。这意味着函数也可以被定义为变量,甚至可以被定义为参数传递给另一个函数。
bool isZero(int number) { //判断整数是否为0
  return number == 0; 
}

void printInfo(int number,Function check) { //用check函数来判断整数是否为0
  print("$number is Zero: ${check(number)}");
}

Function f = isZero;
int x = 10;
int y = 0;
printInfo(x,f);  // 输出 10 is Zero: false
printInfo(y,f);  // 输出 0 is Zero: true
  • 如果函数体只有一行表达式,就比如上面示例中的 isZero 和 printInfo 函数,我们还可以像 JavaScript 语言那样用箭头函数来简化这个函数。
bool isZero(int number) => number == 0;

void printInfo(int number,Function check) => print("$number is Zero: ${check(number)}");
  • 有时,一个函数中可能需要传递多个参数。那么,如何让这类函数的参数声明变得更加优雅、可维护,同时降低调用者的使用成本呢?
  • C++ 与 Java 的做法是,提供函数的重载,即提供同名但参数不同的函数。但 Dart 认为重载会导致混乱,因此从设计之初就不支持重载,而是提供了可选命名参数和可选参数。具体方式是,在声明函数时:
    • 给参数增加{},以 paramName: value 的方式指定调用参数,也就是可选命名参数;
    • 给参数增加[],则意味着这些参数是可以忽略的,也就是可选参数。
  • 在使用这两种方式定义函数时,我们还可以在参数未传递时设置默认值。
//要达到可选命名参数的用法,那就在定义函数的时候给参数加上 {}
void enable1Flags({bool bold, bool hidden}) => print("$bold , $hidden");

//定义可选命名参数时增加默认值
void enable2Flags({bool bold = true, bool hidden = false}) => print("$bold ,$hidden");

//可忽略的参数在函数定义时用[]符号指定
void enable3Flags(bool bold, [bool hidden]) => print("$bold ,$hidden");

//定义可忽略参数时增加默认值
void enable4Flags(bool bold, [bool hidden = false]) => print("$bold ,$hidden");

//可选命名参数函数调用
enable1Flags(bold: true, hidden: false); //true, false
enable1Flags(bold: true); //true, null
enable2Flags(bold: false); //false, false

//可忽略参数函数调用
enable3Flags(true, false); //true, false
enable3Flags(true,); //true, null
enable4Flags(true); //true, false
enable4Flags(true,true); // true, true
  • 类是特定类型的数据和方法的集合,也是创建对象的模板。与其他语言一样,Dart 为类概念提供了内置支持。
类的定义和初始化
  • Dart 是面向对象的语言,每个对象都是一个类的实例,都继承自顶层类型 Object。在 Dart 中,实例变量与实例方法、类变量与类方法的声明与 Java 类似。
  • 值得一提的是,Dart 中并没有 public、protected、private 这些关键字,我们只要在声明变量与方法时,在前面加上“”即可作为 private 方法使用。如果不加“”,则默认为 public。不过,“_”的限制范围并不是类访问级别的,而是库访问级别。
class Point {
  num x, y;
  static num factor = 0;
  //语法糖,等同于在函数体内:this.x = x;this.y = y;
  Point(this.x,this.y);
  void printInfo() => print('($x, $y)');
  static void printZValue() => print('$factor');
}

var p = new Point(100,200); // new 关键字可以省略
p.printInfo();  // 输出(100, 200);
Point.factor = 10;
Point.printZValue(); // 输出10
  • 类的实例化需要根据参数提供多种初始化方式。除了可选命名参数和可选参数之外,Dart 还提供了命名构造函数的方式,

  • 与 C++ 类似,Dart 支持初始化列表。在构造函数的函数体真正执行之前,你还有机会给实例变量赋值,甚至重定向至另一个构造函数。

  • Point 类中有两个构造函数 Point.bottom 与 Point,其中:Point.bottom 将其成员变量的初始化重定向到了 Point 中,而 Point 则在初始化列表中为 z 赋上了默认值 0。

class Point {
  num x, y, z;
  Point(this.x, this.y) : z = 0; // 初始化变量z
  Point.bottom(num x) : this(x, 0); // 重定向构造函数
  void printInfo() => print('($x,$y,$z)');
}

var p = Point.bottom(100);
p.printInfo(); // 输出(100,0,0)
复用
  • 在面向对象的编程语言中,将其他类的变量与方法纳入本类中进行复用的方式一般有两种:继承父类和接口实现。
    • 继承父类意味着,子类由父类派生,会自动获取父类的成员变量和方法实现,子类可以根据需要覆写构造函数及父类方法;
    • 接口实现则意味着,子类获取到的仅仅是接口的成员变量符号和方法符号,需要重新实现成员变量,以及方法的声明和初始化,否则编译器会报错。
class Point {
  num x = 0, y = 0;
  void printInfo() => print('($x,$y)');
}

//Vector继承自Point
class Vector extends Point{
  num z = 0;
  @override
  void printInfo() => print('($x,$y,$z)'); //覆写了printInfo实现
}

//Coordinate是对Point的接口实现
class Coordinate implements Point {
  num x = 0, y = 0; //成员变量需要重新声明
  void printInfo() => print('($x,$y)'); //成员函数需要重新声明实现
}

var xxx = Vector(); 
xxx
  ..x = 1
  ..y = 2
  ..z = 3; //级联运算符,等同于xxx.x=1; xxx.y=2;xxx.z=3;
xxx.printInfo(); //输出(1,2,3)

var yyy = Coordinate();
yyy
  ..x = 1
  ..y = 2; //级联运算符,等同于yyy.x=1; yyy.y=2;
yyy.printInfo(); //输出(1,2)
print (yyy is Point); //true
print(yyy is Coordinate); //true
  • 除了继承和接口实现之外,Dart 还提供了另一种机制来实现类的复用,即“混入”(Mixin)。

  • 混入鼓励代码重用,可以被视为具有实现方法的接口。这样一来,不仅可以解决 Dart 缺少对多重继承的支持问题,还能够避免由于多重继承可能导致的歧义(菱形问题)。

    备注:继承歧义,也叫菱形问题,是支持多继承的编程语言中一个相当棘手的问题。当 B 类和 C 类继承自 A 类,而 D 类继承自 B 类和 C 类时会产生歧义。如果 A 中有一个方法在 B 和 C 中已经覆写,而 D 没有覆写它,那么 D 继承的方法的版本是 B 类,还是 C 类的呢?

  • 要使用混入,只需要 with 关键字即可。

class Coordinate with Point {
}

var yyy = Coordinate();
print (yyy is Point); //true
print(yyy is Coordinate); //true
  • 通过混入,一个类里可以以非继承的方式使用其他类中的变量与方法。
运算符
  • Dart 和绝大部分编程语言的运算符一样,所以你可以用熟悉的方式去执行程序代码运算。不过,Dart 多了几个额外的运算符,用于简化处理变量实例缺失(即 null)的情况。
    • ?. 运算符:假设 Point 类有 printInfo() 方法,p 是 Point 的一个可能为 null 的实例。那么,p 调用成员方法的安全代码,可以简化为 p?.printInfo() ,表示 p 为 null 的时候跳过,避免抛出异常。
    • ??= 运算符:如果 a 为 null,则给 a 赋值 value,否则跳过。这种用默认值兜底的赋值语句在 Dart 中我们可以用 a ??= value 表示。
    • ?? 运算符:如果 a 不为 null,返回 a 的值,否则返回 b。在 Java 或者 C++ 中,我们需要通过三元表达式 (a != null)? a : b 来实现这种情况。而在 Dart 中,这类代码可以简化为 a ?? b。
  • 在 Dart 中,一切都是对象,就连运算符也是对象成员函数的一部分。
    • 对于系统的运算符,一般情况下只支持基本数据类型和标准库中提供的类型。而对于用户自定义的类,如果想支持基本操作,比如比较大小、相加相减等,则需要用户自己来定义关于这个运算符的具体实现。
  • Dart 提供了类似 C++ 的运算符覆写机制,使得我们不仅可以覆写方法,还可以覆写或者自定义运算符。
class Vector {
  num x, y;
  Vector(this.x, this.y);
  // 自定义相加运算符,实现向量相加
  Vector operator +(Vector v) =>  Vector(x + v.x, y + v.y);
  // 覆写相等运算符,判断向量相等
  bool operator == (dynamic v) => x == v.x && y == v.y;
}

final x = Vector(3, 3);
final y = Vector(2, 2);
final z = Vector(1, 1);
print(x == (y + z)); //  输出true

  • operator 是 Dart 的关键字,与运算符一起使用,表示一个类成员运算符函数。在理解时,我们应该把 operator 和运算符作为整体,看作是一个成员函数名。

综合案例

  • 源码地址:https://github.com/cyndibaby905/flutter_core_demo
案例介绍
  • 用 Dart 写一段购物车程序,但先不使用 Dart 独有的特性。然后,我们再以这段程序为起点,逐步加入 Dart 语言特性,将其改造为一个符合 Dart 设计思想的程序。
//定义商品Item类
class Item {
  double price;
  String name;
  Item(name, price) {
    this.name = name;
    this.price = price;
  }
}

//定义购物车类
class ShoppingCart {
  String name;
  DateTime date;
  String code;
  List<Item> bookings;

  price() {
    double sum = 0.0;
    for(var i in bookings) {
      sum += i.price;
    }
    return sum;
  }

  ShoppingCart(name, code) {
    this.name = name;
    this.code = code;
    this.date = DateTime.now();
  }

  getInfo() {
    return '购物车信息:' +
          '\n-----------------------------' +
          '\n用户名: ' + name+ 
          '\n优惠码: ' + code + 
          '\n总价: ' + price().toString() +
          '\n日期: ' + date.toString() +
          '\n-----------------------------';
  }
}

void main() {
  ShoppingCart sc = ShoppingCart('张三', '123456');
  sc.bookings = [Item('苹果',10.0), Item('鸭梨',20.0)];
  print(sc.getInfo());
}
————————————————————————————————————————————————————————————
购物车信息:
-----------------------------
用户名: 张三
优惠码: 123456
总价: 30.0
日期: 2019-06-01 17:17:57.004645
-----------------------------
类抽象改造
  • 在其他编程语言中,在构造函数的函数体内,将初始化参数赋值给实例变量的方式非常常见。而在 Dart 里,我们可以利用语法糖以及初始化列表,来简化这样的赋值过程,从而直接省去构造函数的函数体。
class Item {
  double price;
  String name;
  Item(this.name, this.price);
}

class ShoppingCart {
  String name;
  DateTime date;
  String code;
  List<Item> bookings;
  price() {...}
  //删掉了构造函数函数体
  ShoppingCart(this.name, this.code) : date = DateTime.now();
...
}
  • 考虑到 两个类name 属性与 price 属性(方法)的名称与类型完全一致,在信息表达上的作用也几乎一致,因此我可以在这两个类的基础上,再抽象出一个新的基类 Meta,用于存放 price 属性与 name 属性。
class Meta {
  double price;
  String name;
  Meta(this.name, this.price);
}
class Item extends Meta{
  Item(name, price) : super(name, price);
}

class ShoppingCart extends Meta{
  DateTime date;
  String code;
  List<Item> bookings;
  
  double get price {...}
  ShoppingCart(name, this.code) : date = DateTime.now(),super(name,0);
  getInfo() {...}
}
方法改造
  • price属性的get方法
double get price {
  double sum = 0.0;
  for(var i in bookings) {
    sum += i.price;
  }
  return sum;
} 
  • 在 Dart 中,这样的求和运算我们只需重载 Item 类的“+”运算符,并通过对列表对象进行归纳合并操作即可实现。
class Item extends Meta{
  ...
  //重载了+运算符,合并商品为套餐商品
  Item operator+(Item item) => Item(name + item.name, price + item.price); 
}

class ShoppingCart extends Meta{
  ...
  //把迭代求和改写为归纳合并
  double get price => bookings.reduce((value, element) => value + element).price;
  ...
  getInfo() {...}
}
  • 在 getInfo 方法中,我们将 ShoppingCart 类的基本信息通过字符串拼接的方式,进行格式化组合,这在其他编程语言中非常常见。而在 Dart 中,我们可以通过对字符串插入变量或表达式,并使用多行字符串声明的方式,来完全抛弃不优雅的字符串拼接,实现字符串格式化组合。
getInfo () => '''
购物车信息:
-----------------------------
  用户名: $name
  优惠码: $code
  总价: $price
  Date: $date
-----------------------------
''';
对象初始化方式的优化
  • 在main函数中初始化。
ShoppingCart sc = ShoppingCart('张三', '123456') ;
  • 首先,在对 ShoppingCart 的构造函数进行了大量简写后,我们希望能够提供给调用者更明确的初始化方法调用方式,让调用者以“参数名: 参数键值对”的方式指定调用参数,让调用者明确传递的初始化参数的意义。在 Dart 中,这样的需求,我们在声明函数时,可以通过给参数增加{}实现。
  • 其次,对一个购物车对象来说,一定会有一个有用户名,但不一定有优惠码的用户。因此,对于购物车对象的初始化,我们还需要提供一个不含优惠码的初始化方法,并且需要确定多个初始化方法与父类的初始化方法之间的正确调用顺序。
  • 由于优惠码可以为空,我们还需要对 getInfo 方法进行兼容处理。在这里,我用到了 a??b 运算符,这个运算符能够大量简化在其他语言中三元表达式 (a != null)? a : b 的写法。
class ShoppingCart extends Meta{
  ...
  //默认初始化方法,转发到withCode里
  ShoppingCart({name}) : this.withCode(name:name, code:null);
  //withCode初始化方法,使用语法糖和初始化列表进行赋值,并调用父类初始化方法
  ShoppingCart.withCode({name, this.code}) : date = DateTime.now(), super(name,0);

  //??运算符表示为code不为null,则用原值,否则使用默认值"没有"
  getInfo () => '''
购物车信息:
-----------------------------
  用户名: $name
  优惠码: ${code??"没有"}
  总价: $price
  Date: $date
-----------------------------
''';
}

void main() {
  ShoppingCart sc = ShoppingCart.withCode(name:'张三', code:'123456');
  sc.bookings = [Item('苹果',10.0), Item('鸭梨',20.0)];
  print(sc.getInfo());

  ShoppingCart sc2 = ShoppingCart(name:'李四');
  sc2.bookings = [Item('香蕉',15.0), Item('西瓜',40.0)];
  print(sc2.getInfo());
}
-----------------------------------------------------------------------
购物车信息:
-----------------------------
  用户名: 张三
  优惠码: 123456
  总价: 30.0
  Date: 2019-06-01 19:59:30.443817
-----------------------------

购物车信息:
-----------------------------
  用户名: 李四
  优惠码: 没有
  总价: 55.0
  Date: 2019-06-01 19:59:30.451747
-----------------------------
  • 关于购物车信息的打印,我们是通过在 main 函数中获取到购物车对象的信息后,使用全局的 print 函数打印的,我们希望把打印信息的行为封装到 ShoppingCart 类中。而对于打印信息的行为而言,这是一个非常通用的功能,不止 ShoppingCart 类需要,Item 对象也可能需要。
  • 因此,我们需要把打印信息的能力单独封装成一个单独的类 PrintHelper。但,ShoppingCart 类本身已经继承自 Meta 类,考虑到 Dart 并不支持多继承,我们怎样才能实现 PrintHelper 类的复用呢?只要在使用时加上 with 关键字即可。
abstract class PrintHelper {
  printInfo() => print(getInfo());
  getInfo();
}

class ShoppingCart extends Meta with PrintHelper{
...
}
  • 经过 Mixin 的改造,我们终于把所有购物车的行为都封装到 ShoppingCart 内部了。而对于调用方而言,还可以使用级联运算符“…”,在同一个对象上连续调用多个函数以及访问成员变量。使用级联操作符可以避免创建临时变量,让代码看起来更流畅。
void main() {
  ShoppingCart.withCode(name:'张三', code:'123456')
  ..bookings = [Item('苹果',10.0), Item('鸭梨',20.0)]
  ..printInfo();

  ShoppingCart(name:'李四')
  ..bookings = [Item('香蕉',15.0), Item('西瓜',40.0)]
  ..printInfo();
}
完整代码
class Meta {
  double price;
  String name;
  //成员变量初始化语法糖
  Meta(this.name, this.price);
}

class Item extends Meta{
  Item(name, price) : super(name, price);
  //重载+运算符,将商品对象合并为套餐商品
  Item operator+(Item item) => Item(name + item.name, price + item.price); 
}

abstract class PrintHelper {
  printInfo() => print(getInfo());
  getInfo();
}

//with表示以非继承的方式复用了另一个类的成员变量及函数
class ShoppingCart extends Meta with PrintHelper{
  DateTime date;
  String code;
  List<Item> bookings;
  //以归纳合并方式求和
  double get price => bookings.reduce((value, element) => value + element).price;
  //默认初始化函数,转发至withCode函数
  ShoppingCart({name}) : this.withCode(name:name, code:null);
  //withCode初始化方法,使用语法糖和初始化列表进行赋值,并调用父类初始化方法
  ShoppingCart.withCode({name, this.code}) : date = DateTime.now(), super(name,0);

  //??运算符表示为code不为null,则用原值,否则使用默认值"没有"
  @override
  getInfo() => '''
购物车信息:
-----------------------------
  用户名: $name
  优惠码: ${code??"没有"}
  总价: $price
  Date: $date
-----------------------------
''';
}

void main() {
  ShoppingCart.withCode(name:'张三', code:'123456')
  ..bookings = [Item('苹果',10.0), Item('鸭梨',20.0)]
  ..printInfo();

  ShoppingCart(name:'李四')
  ..bookings = [Item('香蕉',15.0), Item('西瓜',40.0)]
  ..printInfo();
}
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页