通过一个综合案例，掌握Dart的核心特性
今天我先用Dart写一段购物车程序，但是先不使用Dart独有的特性，然后我们再以这段程序为起点。逐步加入Dart语言特性，将其改造成一个符合Dart设计思想的程序。
首先，我们来看看在不使用任何Dart语法特性的情况下，一个有着基本功能的购物车长什么样子。
void main (){
ShoppingCart shoppingcart = ShoppingCart('拉维', '888666');
shoppingcart.bookings = [Product('肥皂', 12), Product('牙刷', 6)];
print(shoppingcart.getInfo());
}
//定义商品Product类
class Product {
String name;
double price;
Product (String name, double price) {
this.name = name;
this.price = price;
}
}
//定义购物车Shoppingcart类
class ShoppingCart {
String name;
String code;
DateTime date;
List<Product> bookings;
price(){
double sum = 0.0;
for (var product in bookings) {
sum += product.price;
}
return sum;
}
ShoppingCart(String name, String 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-----------------------------';
}
}在这段程序中，我定义了商品Product类，以及购物车ShoppingCart类。它们分别包含了一个初始化构造方法，将main函数内部传入的参数信息赋值给对象内部属性。而购物车的基本信息，则通过ShoppingCart类中的getInfo方法输出。在这个方法中，我采用了字符串拼接的方式，将各类信息进行格式化组合后，返回给调用者。
运行这段程序，不出意外，购物车对象shoppingcart的基本信息就会被打印到命令行中。
购物车信息:
-----------------------------
用户名: 拉维
优惠码: 888666
总价: 18.0
日期: 2019-07-18 18:28:50.991920
-----------------------------这段程序功能非常简单：我们初始化了一个购物车对象，然后给购物车对象进行加购操作，最后打印出基本信息。可以看到，在不使用Dart语法任何特性的情况下，这段代码与Java、C++甚至JavaScript没有明显的语法差异。
在关于如何表达以及处理信息上，Dart保持了既简单又简洁的风格。接下来我们就从表达信息入手，看看Dart是如何优化这段代码的。
类抽象改造
我们先来看看Product类与ShoppingCart类的初始化部分。它们在构造函数中的初始化工作，仅仅是将main函数中传入的参数进行属性赋值。
在其他编程语言中，在构造函数的函数体内，将初始化参数赋值给实例变量的方式非常常见。而在Dart中，我们可以利用语法糖以及初始化列表，来简化这样的赋值过程，从而直接省去构造函数的函数体：
void main (){
ShoppingCart shoppingcart = ShoppingCart('拉维', '888666');
shoppingcart.bookings = [Product('肥皂', 12), Product('牙刷', 6)];
print(shoppingcart.getInfo());
}
//定义商品Product类
class Product {
String name;
double price;
Product(this.name, this.price);
}
//定义购物车Shoppingcart类
class ShoppingCart {
String name;
String code;
DateTime date;
List<Product> bookings;
price(){
double sum = 0.0;
for (var product in bookings) {
sum += product.price;
}
return sum;
}
//删掉了构造函数函数体
ShoppingCart(this.name, this.code) : date = DateTime.now();
getInfo() {
return '购物车信息:' +
'\n-----------------------------' +
'\n 用户名: ' + name +
'\n 优惠码: ' + code +
'\n 总价: ' + price().toString() +
'\n 日期: ' + date.toString() +
'\n-----------------------------';
}
}这一下就省去了6行代码！通过这次改造，我们有两个新的发现：
- 首先，Product类与ShoppingCart类中都有一个name属性，在Product中表示商品名称，在ShoppingCart中表示用户名；
- 然后，Product类中有一个price属性，ShoppingCart中有一个price方法，他们都表示当前的价格。
考虑到name属性和price属性（方法）的名称与类型完全一致，在信息表达上的作用也几乎一致，因此我可以在这两个类的基础上，再抽象出一个新的基类Father，用于存放name属性和price属性。
同时，考虑到在ShoppingCart类中，price属性仅用作计算购物车中商品的价格（而不是像Product类那样用于数据存取），因此在继承了Father类后，我改写了ShoppingCart类中price属性的Get方法：
void main (){
ShoppingCart shoppingcart = ShoppingCart('拉维', '888666');
shoppingcart.bookings = [Product('肥皂', 12), Product('牙刷', 6)];
print(shoppingcart.getInfo());
}
//定义父类
class Father {
String name;
double price;
Father(this.name, this.price);
}
//定义商品Product类
class Product extends Father {
Product(String name, double price) : super(name, price);
}
//定义购物车Shoppingcart类
class ShoppingCart extends Father {
String code;
DateTime date;
List<Product> bookings;
get price{
double sum = 0.0;
for (var product in bookings) {
sum += product.price;
}
return sum;
}
ShoppingCart(String name, this.code) : date = DateTime.now(), super(name, 0.0);
getInfo() {
return '购物车信息:' +
'\n-----------------------------' +
'\n 用户名: ' + name +
'\n 优惠码: ' + code +
'\n 总价: ' + price().toString() +
'\n 日期: ' + date.toString() +
'\n-----------------------------';
}
}通过这次改造，程序中各个类的依赖关系变得更加清晰了。不过，目前这段程序中还有两个冗长的方法显得格格不入，即ShoppingCart类中计算商品总价格的price属性的get方法，以及提供购物车基本信息的getInfo方法。接下来我们分别来改造这两个方法。
方法改造
我们先看看price属性的get方法：
get price{
double sum = 0.0;
for (var product in bookings) {
sum += product.price;
}
return sum;
}在这个方法里，我采用了其他语言常见的求和算法，依次遍历bookings中的Product对象，累积相加求和。
而在Dart中，这样的求和运算我们只需重载Product类的“+”运算符，并通过对列表对象进行归纳合并操作即可实现。
另外，由于函数体只有一行，所以我们可以使用Dart的箭头函数来进一步简化实现函数：
void main (){
ShoppingCart shoppingcart = ShoppingCart('拉维', '888666');
shoppingcart.bookings = [Product('肥皂', 12), Product('牙刷', 6)];
print(shoppingcart.getInfo());
}
class Father {
String name;
double price;
Father(this.name, this.price);
}
class Product extends Father {
Product(String name, double price) : super(name, price);
//重载 + 运算符，合并商品为套餐商品
Product operator+ (Product p) => Product(name+p.name, price+p.price);
}
class ShoppingCart extends Father {
String code;
DateTime date;
List<Product> bookings;
//把迭代求和改为归纳合并
get price => bookings.reduce((v1, v2)=>v1+v2).price;
ShoppingCart(String name, this.code) : date = DateTime.now(), super(name, 0.0);
getInfo() {
return '购物车信息:' +
'\n-----------------------------' +
'\n 用户名: ' + name +
'\n 优惠码: ' + code +
'\n 总价: ' + price().toString() +
'\n 日期: ' + date.toString() +
'\n-----------------------------';
}
}可以看到，这段代码又简洁了很多！接下来，我们再看看 getInfo 方法如何优化。
在 getInfo 方法中，我们将ShoppingCart类的基本信息通过字符串拼接的方式，进行格式化组合，这在其他编程语言中非常常见。而在Dart中，我们可以通过对字符串插入变量或者表达式，并使用多行字符串声明的方式，来完全抛弃不优雅的字符串拼接，实现字符串格式化组合。
getInfo() => '''
购物车信息:
-----------------------------
用户名: $name
优惠码: $code
总价: ${price.toString()}
日期: ${date.toString()}
-----------------------------
''';在去掉了多余的字符串转义和拼接代码后，getInfo方法看着就清晰多了。
在优化完了Product类与ShoppingCart类的内部实现后，我们再来看看 main 函数，从调用者的角度去分析程序还能在哪些方面做优化。
对象初始化方式的优化
在 main 函数中，我们使用
ShoppingCart shoppingcart = ShoppingCart('拉维', '888666');初始化了一个使用“888666”优惠码，名为“拉维”的用户所使用的购物车对象。而这段初始化方法的调用，我们可以从两个方面优化：
- 首先，在对ShoppingCart的构造函数进行大量简写之后，我们希望能够给调用者更明确的初始化方法调用方式，让调用者以“参数名:参数值”键值对的方式指定调用参数，让调用者明确传递的初始化参数的意义。在Dart中，这样的需求，我们在声明函数时，可以通过给参数增加{}来实现。
- 对一个购物车对象来说，一定会有一个用户名但不一定有优惠码的用户。因此，对于购物车对象的初始化，我们还需要提供一个不含优惠码的初始化方法，并且需要确定多个初始化方法与父类的初始化方法之间的正确调用顺序。
按照这样的思路，我们开始对ShoppingCart进行改造。
需要注意的是，由于优惠码可以为空，我们还需要对getInfo方法进行兼容处理。在这里，我用到了a??b运算符，这个运算符能够大量简化在其他语言中的三元表达式（a!=null) ? a : b 的写法：
void main (){
ShoppingCart shoppingcart = ShoppingCart('拉维');
shoppingcart.bookings = [Product('肥皂', 12), Product('牙刷', 6)];
print(shoppingcart.getInfo());
ShoppingCart shoppingcart2 = ShoppingCart.withCode('煎饼果子', code:'888666');
shoppingcart2.bookings = [Product('脸盆', 30), Product('毛巾', 20)];
print(shoppingcart2.getInfo());
}
class Father {
String name;
double price;
Father(this.name, this.price);
}
class Product extends Father {
Product(String name, double price) : super(name, price);
Product operator+ (Product p) => Product(name+p.name, price+p.price);
}
class ShoppingCart extends Father {
String code;
DateTime date;
List<Product> bookings;
get price => bookings.reduce((v1, v2)=>v1+v2).price;
//默认初始化方法，转发到withCode里
ShoppingCart(String name) : this.withCode(name);
//withCode初始化方法，使用语法糖和初始列表进行赋值，并调用父类初始化方法
ShoppingCart.withCode(String name, {this.code}) : date = DateTime.now(), super(name, 0.0);
//??运算符表示，当code不为null时使用原值，当code为null时使用“无优惠码”。
getInfo() => '''
购物车信息:
-----------------------------
用户名: $name
优惠码: ${code??'无优惠码'}
总价: ${price.toString()}
日期: ${date.toString()}
-----------------------------
''';运行这段程序，两个购物车的信息就会被打印到命令行中：
flutter: 购物车信息:
-----------------------------
用户名: 拉维
优惠码: 无优惠码
总价: 18.0
日期: 2019-07-19 08:05:18.190934
-----------------------------
flutter: 购物车信息:
-----------------------------
用户名: 煎饼果子
优惠码: 888666
总价: 50.0
日期: 2019-07-19 08:05:18.198844
-----------------------------关于购物车信息的打印，我们是通过在 main 函数中获取到购物车对象的信息后，使用全局的 print 函数打印的，我们希望将打印信息的行为封装到ShoppingCart类中。而对于打印信息的行为而言，不止ShoppingCart类需要，Product对象也可能会需要。
因此，我们需要把打印信息的能力单独封装成一个单独的类PrintHandle。但是ShoppingCart类本身已经继承自Father类，考虑到Dart并不支持多继承，我们怎样才能实现PrintHandle类的复用呢？
这就用到了之前提到的混入（Mixin），通过with关键字来实现。
我们来试着增加PrintHandle类，并调整ShoppingCart类的声明：
class ShoppingCart extends Father with PrintHandle{
......
}
abstract class PrintHandle{
getInfo();
printInfo() => print(getInfo());
}通过Mixin的改造，我们终于把所有购物车的行为都封装到ShoppingCart内部了，而对于调用方而言，还可以使用级联运算符“..”，同一个对象上连续调用多个函数以及访问成员变量。使用级联操作符可以避免创建临时变量，让代码看起来更流畅：
void main (){
ShoppingCart('拉维')
..bookings = [Product('肥皂', 12), Product('牙刷', 6)]
..printInfo();
ShoppingCart.withCode('煎饼果子', code:'888666')
..bookings = [Product('脸盆', 30), Product('毛巾', 20)]
..printInfo();
}到此为止，通过Dart独有的语法特性，我们终于把这段购物车代码改造成了简洁、直接而又强大的Dart风格程序。
总结
下面是今天购物车综合案例的完整代码：
void main (){
ShoppingCart('拉维')
..bookings = [Product('肥皂', 12), Product('牙刷', 6)]
..printInfo();
ShoppingCart.withCode('煎饼果子', code:'888666')
..bookings = [Product('脸盆', 30), Product('毛巾', 20)]
..printInfo();
}
class Father {
String name;
double price;
//成员变量初始化语法糖
Father(this.name, this.price);
}
class Product extends Father {
Product(String name, double price) : super(name, price);
//重载 + 运算符，将商品对象合并为套餐商品
Product operator+ (Product p) => Product(name+p.name, price+p.price);
}
//with表示以非继承的方式复用另一个类的成员变量及函数
class ShoppingCart extends Father with PrintHandle{
String code;
DateTime date;
List<Product> bookings;
//以归纳合并方式求和
get price => bookings.reduce((v1, v2)=>v1+v2).price;
//默认初始化方法，转发到withCode里
ShoppingCart(String name) : this.withCode(name);
//withCode初始化方法，使用语法糖和初始列表进行赋值，并调用父类初始化方法
ShoppingCart.withCode(String name, {this.code}) : date = DateTime.now(), super(name, 0.0);
//??运算符表示，当code不为null时使用原值，当code为null时使用“无优惠码”。
getInfo() => '''
购物车信息:
-----------------------------
用户名: $name
优惠码: ${code??'无优惠码'}
总价: ${price.toString()}
日期: ${date.toString()}
-----------------------------
''';
}
abstract class PrintHandle{
getInfo();
printInfo() => print(getInfo());
}以上。