二、Dart基础语法 (二)运算符类

作者: 爱玩游戏的iOS菜鸟 | 来源:发表于2020-10-28 11:26 被阅读0次

一、运算符

这里只列举比较简单的特殊的运算符，其余的运算符不浪费时间。

1、除法/整除、取模

  var num = 7;
  print(num / 3); //2.33333 除法操作
  print(num ~/ 3); //2 整除操作
  print(num % 3); //1 取模操作

2、??= 赋值操作

dart有一个很多语言都不具备的赋值运算符：

当变量为null时，使用后面的内容进行赋值。
当变量有值时，使用自己原来的值。

  var name1 = 'zzq';
  print(name1);
  // var name2 = 'kobe';
  var name2 = null;
  name2 ??= 'james';
  print(name2);

3、条件运算符

Dart中包含一直比较特殊的条件运算符：expr1 ?? expr2

如果expr1是null，则返回expr2的结果;
如果expr1不是null，直接使用expr1的结果。

  var temp = 'why';
  var temp = null;
  var name = temp ?? 'kobe';
  print(name);

4、级联语法: `..`

某些时候，我们希望对一个对象进行连续的操作，这个时候可以使用级联语法

main(List<String> args) {
  final obj = Person();
  obj.run();
  obj.jump();
  obj.speak();

  final zzq = Person()
    ..run()
    ..jump()
    ..speak();
}

class Person {
  run() {
    print("run");
  }

  speak() {
    print("speak");
  }

  jump() {
    print("jump");
  }
}

二、流程控制

和大部分语言的特性比较相似，这里就不再详细赘述，看一下即可。

1、if和else

不支持非空即真或者非0即真，必须有明确的bool类型

  var name = "zzq";
  if (name) {//报错：Conditions must have a static type of 'bool'.
    print(name);
  }

2、循环操作

while和do-while和其他语言一致
break和continue用法也是一致
for的用法也是一致
switch-case的用法也是一致

三、类与对象

1、类的定义

在Dart中，定义类用class关键字

类通常有两部分组成：成员（member）和方法（method）

class 类名{
    类型 成员名;
    返回值类型 方法名(参数列表) {
    方法体
  }
}

下面是示例代码：

class Person {
  String name;
  int age;
  int sex;
  run() {
    print("run");
  }
}

2、构造方法

2.1 普通构造方法

当通过类创建一个对象时，会调用这个类的构造方法。

当类中没有明确指定构造方法时，将默认拥有一个无参的构造方法。
前面的Person中我们就是在调用这个构造方法.

也可以根据自己的需求，定义自己的构造方法，但是需要注意的是:

当有了自己的构造方法时，默认的构造方法将会失效，不能使用

main(List<String> args) {
  final person = Person("name", 10);
  print(person);
}

class Person {
  String name;
  int age;

  Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  //Person(this.name, this.age); //Dart提供一种更简单的语法糖形式

  @override
  String toString() {
    //重写了toString方法
    return "name is $name, age is $age";
  }
}

2.2 命名构造方法

因为不支持方法（函数）的重载，所以我们没办法创建相同名称的构造方法。

main(List<String> args) {
  final person = Person("name", 10);
  print(person);

  final person2 = Person.withArgments("zzq", 20);
  print(person2);

  final person3 = Person.withMap({'name': "wll", 'age': 30});
  print(person3);
}

class Person {
  String name;
  int age;

  Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  //Person(this.name, this.age); //Dart提供一种更简单的语法糖形式

  Person.withArgments(String name, int age) {
    this.name = name;
    this.age = age;
  }

  Person.withMap(Map<String, Object> map) {
    this.name = map['name'];
    this.age = map['age'];
  }

  @override
  String toString() {
    //重写了toString方法
    return "name is $name, age is $age";
  }
}

2.3 初始化列表

下面初始化变量的方法，我们称之为：初始化列表(Initializer list)

main(List<String> args) {
  final circle = Circle(10, 2);
  print(circle);
}

class Circle {
  int length;
  int num;
  int distance;

  Circle(this.length, this.num) : distance = length * num;

  @override
  String toString() {
    return '$length, $num, $distance';
  }
}

2.4 重定向构造方法

在我们需要在一个构造方法中去调用另一个构造方法时，需要使用重定向方法

class Circle {
  int length;
  int num;
  int distance;

  Circle(this.length, this.num);
  Circle.fromLength(int name) : this(name, 10);
}

2.5 常量构造方法

在某些情况下，传入相同值时，我们希望返回同一个对象，这个时候，可以使用常量构造方法.

默认情况下，创建对象时，即使传入相同的参数，创建出来的也不是同一个对象。

main(List<String> args) {
  var p1 = Person('why');
  var p2 = Person('why');
  print(identical(p1, p2)); // false  通过identical函数比较
}

class Person {
  String name;

  Person(this.name);
}

如果将构造方法前加const进行修饰，那么可以保证同一个参数，创建出来的对象是相同的，这样的构造方法就称之为常量构造方法。

main(List<String> args) {
  var p1 = const Person('why');
  var p2 = const Person('why');
  print(identical(p1, p2)); // true
}

class Person {
  final String name;

  const Person(this.name);
}

常量构造方法有一些注意点:

注意一：拥有常量构造方法的类中，所有的成员变量必须是final修饰的.
注意二: 为了可以通过常量构造方法，创建出相同的对象，不再使用 new关键字，而是使用const关键字
如果是将结果赋值给const修饰的标识符时，const可以省略.

2.6 工厂构造方法

Dart提供了factory关键字, 用于通过工厂去获取对象

main(List<String> args) {
  var p1 = Person('why');
  var p2 = Person('why');
  print(identical(p1, p2)); // true
}

class Person {
  String name;

  static final Map<String, Person> _cache = <String, Person>{};
  factory Person(String name) {
    if (_cache.containsKey(name)) {
      return _cache[name];
    } else {
      final p = Person._zzInternal(name);
    }
  }
  Person._zzInternal(this.name);
}

3、setter 和 getter方法

默认情况下，Dart中类定义的属性可以直接被外界访问

但是有时候，监控这个类的属性被访问的过程时，可以使用setter和getter

main(List<String> args) {
  var dog = Dog('blue');
  dog.setColor = 'MC hot';
  dog.getColor;
}

class Dog {
  String color;
  set setColor(String color) {
    print("set dog color : $color dog");
    this.color = color;
  }

  get getColor {
    print("get dog color : $color dog");
    return color;
  }

  Dog(this.color);
}

4、类的继承

Dart中继承使用extends关键字，子类中使用super来访问父类。

父类的所有成员变量和方法都会被子类继承，除了构造方法。

子类可以添加自己的成员变量, 并对父类的方法进行重写：

main(List<String> args) {
  final person = Person('zzq');
  person.run();
}

class Animal {
  String age;
  run() {
    print('Animal run');
  }
}

class Person extends Animal {
  String name;

  Person(this.name);

  @override
  run() {
    print("$name is running");
  }
}

子类中可以调用父类的构造方法，对某些属性进行初始化：

子类的构造方法在执行前，将隐含调用父类的无参默认构造方法（没有参数且与类同名的构造方法）。
如果父类没有无参默认构造方法，则子类的构造方法必须在初始化列表中通过super显式调用父类的某个构造方法。

main(List<String> args) {
  final person = Person('zzq', 25);
  person.run();
}

class Animal {
  int age;
  run() {
    print('Animal run');
  }

  Animal(this.age);
}

class Person extends Animal {
  String name;

  Person(String name, int age)//显示调用父类的构造方法
      : this.name = name,
        super(age);

  @override
  run() {
    print("$name is running");
  }
}

5、抽象类

抽象类是通过abstract声明，在抽象类中，没有具体实现的方法，叫做抽象方法(必须存在于抽象类中)

抽象类不可以被实例化
抽象类中可以实现方法，没有实现的方法，必须在子类中实现

main(List<String> args) {
  final Shape cir = Sphere(20);//父类指针指向子类对象
  final Shape cir2 = Cube(20);

  print(cir.getVolume());//调用相同的方法 结果不同
  print(cir2.getVolume());//调用相同的方法 结果不同
}

abstract class Shape {
  double getVolume();
}

class Sphere extends Shape {
  int radius;

  Sphere(this.radius);

  @override
  double getVolume() {
    return radius * radius * radius * 3.14 * 4 / 3;
  }
}

class Cube extends Shape {
  int radius;

  Cube(this.radius);

  @override
  double getVolume() {
    return radius * radius * radius * 1.0;
  }
}

6、隐式接口

默认情况下，定义的每个类都相当于默认也声明了一个接口，可以由其他的类来实现

通过implements实现某个类时，类中所有的方法都必须被重新实现(无论这个类原来是否已经实现过该方法)

通常将用于给别人实现的类声明为抽象类

main(List<String> args) {
  final person = Person();
  person.fly();
  person.run();
}

abstract class Runner {
  run() {}
}

abstract class Flyer {
  fly() {}
}

class Person implements Runner, Flyer {
  @override
  run() {
    print("run");
  }

  @override
  fly() {
    print('fly');
  }
}

7、Mixin混入

但一个类需要直接复用之前类的原有实现方案时，使用Mixin混入的方式

除了可以通过class定义类之外，也可以通过mixin关键字来定义一个类。
只是通过mixin定义的类用于被其他类混入使用，通过with关键字来进行混入。

main(List<String> args) {
  final person = Person();
  person.fly();
  person.run();
}

mixin Runner {
  run() {
    print("run");
  }
}

mixin Flyer {
  fly() {
    print("fly");
  }
}

class Person with Runner, Flyer {}

8、类成员和方法

使用static关键字来定义属性和方法

main(List<String> args) {
  var stu = Student();
  stu.name = 'zzq';
  stu.sno = 110;
  stu.study();

  Student.time = '晚上6点';
  // stu.time = '晚上6点'; 错误做法, 实例对象不能访问类成员
  Student.attendClass();
  // stu.attendClass(); 错误做法, 实现对象不能访问类方法
}

class Student {
  String name;
  int sno;

  static String time;

  study() {
    print('$name在学习');
  }

  static attendClass() {
    print('去上课');
  }
}

四、枚举类型

Dart的枚举类型没有Swift那么强大，仅仅是定义一个固定的值而已，提高易读性

枚举类型中有两个比较常见的属性:

index: 用于表示每个枚举常量的索引, 从0开始.(不能自定义索引值)
values: 包含每个枚举值的List.

main(List<String> args) {
  print(Colors.red.index);
  print(Colors.green.index);
  print(Colors.blue.index);

  print(Colors.values);
  print(Colors.values.runtimeType); //List<Colors>
}

enum Colors { red, green, blue }

五、泛型

1、List和Map的泛型

//List的定义
abstract class List<E> implements EfficientLengthIterable<E>
//Map
abstract class Map<K, V>

示例：

    // 创建List的方式
  var names1 = ['why', 'kobe', 'james', 111];
  print(names1.runtimeType); // List<Object>

  // 限制类型
  var names2 = <String>['why', 'kobe', 'james', 111]; // 最后一个报错
  List<String> names3 = ['why', 'kobe', 'james', 111]; // 最后一个报错

  // 创建Map的方式
  var infos1 = {1: 'one', 'name': 'why', 'age': 18};
  print(infos1.runtimeType); // _InternalLinkedHashMap<Object, Object>

  // 对类型进行显示
  Map<String, String> infos2 = {'name': 'why', 'age': 18}; // 报错 18不能放在value中
  varinfos3 = <String, String>{'name': 'why', 'age': 18}; // 报错 18不能放在value中

2、类定义的泛型

如果我们需要定义一个类, 用于存储位置信息Location, 但是并不确定使用者希望使用的是int类型,还是double类型, 甚至是一个字符串, 这个时候如何定义呢?

一种方案是使用Object类型, 但是在之后使用时, 非常不方便
另一种方案就是使用泛型.（推荐使用）

main(List<String> args) {
  Location l2 = Location<int>(10, 20);
  print(l2.x.runtimeType); // int

  Location l3 = Location<String>('aaa', 'bbb');
  print(l3.x.runtimeType); // String
}

class Location<T> {
  T x;
  T y;
  Location(this.x, this.y);
}

main(List<String> args) {
  Location l1 = Location<int>(10, 20);
  print(l1.x.runtimeType); // int

  Location l2 = Location<String>("12.3456", '12.3456'); //报错
  print(l2.x.runtimeType); // String
}

如果我们希望类型只能是num类型, 怎么做呢?

class Location<T extends int> {
  T x;
  T y;
  Location(this.x, this.y);
}

3、泛型方法的定义

泛型方法的新语法允许在方法和函数中使用类型参数。

main(List<String> args) {
  var names = ['why', 'kobe'];
  var first = getFirst(names);
  print('$first ${first.runtimeType}'); // why String

  var scores = [12, 23, 45];
  var firstScore = getFirst(scores);
  print('$firstScore ${firstScore.runtimeType}'); // 12 int
}

T getFirst<T>(List<T> ts) {
  return ts[0];
}

六、库的使用

import语句用来导入一个库，后面跟一个字符串形式的Url来指定表示要引用的库，语法如下：

import '库所在的uri';

常见的库URI有三种不同的形式:

来自dart标准版，比如dart:io、dart:html、dart:math、dart:core(默认已导入)

//dart:前缀表示Dart的标准库，如dart:io、dart:html、dart:math
import 'dart:io';

使用相对路径导入的库，通常指自己项目中定义的其他dart文件

//当然，你也可以用相对路径或绝对路径的dart文件来引用
import 'utils/dart02.dart';//同级目录
import './dart02.dart';//从上级目录
import '../hellodart/utils/dart02.dart';//从根目录开始

Pub包管理工具管理的一些库，包括自己的配置以及一些第三方的库，通常使用前缀package

//Pub包管理系统中有很多功能强大、实用的库，可以使用前缀 package:
import 'package:flutter/material.dart';

1、库文件中内容的显示和隐藏

如果希望只导入库中某些内容，或者刻意隐藏库里面某些内容，可以使用show和hide关键字

show关键字：可以显示某个成员（屏蔽其他）
hide关键字：可以隐藏某个成员（显示其他）

import '../hellodart/utils/dart02.dart' hide getFirst;
import 'lib/student/student.dart' show Student, Person;

库中内容和当前文件中的名字冲突，可以使用as关键字来使用命名空间
import 'lib/student/student.dart' as Stu;

Stu.Student s = new Stu.Student();

2、库的定义— library关键字

通常在定义库时，我们可以使用library给库起一个名字。

但是目前库的名字并不影响导入，因为import语句用的是字符串URI。

library dart.math;//math库的头部

3、库的管理

官方不推荐使用part关键字，库非常大，用到export关键字

将每一个dart文件作为库文件，使用export关键字在某个库文件中单独导入, 然后再将汇总的库声明给其他文件使用

dart02.dart文件：

T getFirst<T>(List<T> ts) {
  return ts[0];
}

helloDart.dart文件：

getName(String name) {
  print('$name');
}

total.dart文件：

export './helloDart.dart';
export './utils/dart02.dart';

student.dart文件：

//其他文件
import '../hellodart/total.dart';//导入`total.dart` 可使用上面2个库的方法

main(List<String> args) {
  print(getName("name"));
  print(getFirst(['1', '2', '3']));
}

案例学习：购物车

在不使用任何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());
}

通过这两天的学习，我们运用Dart语法的特性，进行Dart式的改造：（中间的优化过程自己对比理解）

main(List<String> args) {
  ShopingCart car = ShopingCart.withCode("张三", code: "123456")
    ..bookings = [Item('苹果', 12.98)]//级联语法
    ..printInfo();

  ShopingCart car2 = ShopingCart("李四")
    ..bookings = [Item('梨子', 12.98)]
    ..printInfo();
}

class Meta {//抽取公共方法、属性到父类
  double price;
  String name;
  Meta(this.name, this.price);
}

class Item extends Meta with PrintHelper {
  Item(name, price) : super(name, price);//构造方法

  Item operator +(Item item) => Item(name + item.name, price + this.price);//重载 + 运算符

  @override
  getInfo() {}
}

abstract class PrintHelper {//抽象类：用途 公共打印
  printInfo() => print(getInfo());
  getInfo();
}

class ShopingCart extends Meta with PrintHelper {
  DateTime date;
  String code;
  List<Item> bookings;

  double get price =>
      bookings.reduce((value, element) => value + element).price;

  ShopingCart(name) : this.withCode(name, code: null);//重定向构造方法

  ShopingCart.withCode(name, {this.code})//命名可选参数
      : date = DateTime.now(),
        super(name, 0);//赋值默认值

  @override
  printInfo() {
    // TODO: implement printInfo
    return super.printInfo();
  }

  @override
  getInfo() => '''
  购物车信息:
  -------------------
    用户名：$name
    优惠码：${code ?? "没有"}
    总价：$price
    Date:$date
  -------------------
  ''';
}

这里面用到了：
1、Dart类的命名可选构造方法
2、类的继承，抽象类的使用，混入
3、运算符的重载
4、字符串的插入
5、级联语法

二、Dart基础语法 (二)运算符 类