Day03-Dart-基础语法二

总体概述

• 运算符
• 流程控制
• 类和对象
• 泛型
• 库的使用

一、运算符

• 1.1、Dart 所有的运算符

  描述	运算符
  一元后缀	expr++ expr--· () [] . ?.
  一元前缀	-expr !expr ~expr --expr
  乘法类型	* / % ~/
  加法类型	+ -
  移动位运算	<< >>
  与位运算	&
  异或位运算	^
  或位运算	|
  关系和类型测试	>= <= > < as is is!
  等式	== !=
  逻辑与	&&
  逻辑或	||
  条件	expr1 ? expr2 : expr3
  级联	..
  赋值	= *= /= ~/= %= += -= <<= >>= &= ^= \= ??=

  提示：上表操作符的优先级由上到下逐个减小，上面行内的操作符优先级大于下面行内
  使用操作运算符时的顺序，如下

  // 使用括号来提高可读性
  if ((n % I == 0) && (d % i == 0))
  // 可读性较差
  if (n % I == 0 && d % i == 0)
  

• 1.2、除法、整除、取余运算

  var num = 7;
  print(num / 3); // 除法操作, 结果2.3333..
  print(num ~/ 3); // 整除操作取商, 结果2;
  print(num % 3); // 取余操作, 结果1;
  

• 1.3、??= 赋值操作
  当变量为 null 时，使用后面的内容进行赋值。
  当变量有值时，使用自己原来的值。

  main(List<String> args) {
       var name1 = 'Lily';
       print(name1);
       // var name2 = 'kobe';
       var name2 = null;
       name2 ??= 'James'; 
       // 当name2初始化为kobe时，结果为kobe，当初始化为null时，赋值了James
       print(name2); 
  }
  

• 1.4、条件运算符：

  • 第一种：Dart中包含一直比较特殊的条件运算符：expr1 ?? expr2
    如果expr1是null，则返回expr2的结果;
    如果expr1不是null，直接使用expr1的结果。

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

  • 第二种：三元表达式，如果条件为真；则但会 expr1，否则返回 expr2的值

    condition  ? expr1 : expr2
    

• 1.5、级联语法：..
  某些时候，我们希望对一个对象进行连续的操作，这个时候可以使用级联语法，类似于链式语法

  class Person {
     String name;
  
     void run() {
         print("${name} is running");
     }
  
     void eat() {
         print("${name} is eating");
     }
  
     void swim() {
         print("${name} is swimming");
     }
  }
  
  main(List<String> args) {
      final p1 = Person();
      p1.name = 'why';
      p1.run();
      p1.eat();
      p1.swim();
  
      final p2 = Person()
            ..name = "why"
            ..run()
            ..eat()
            ..swim();
  }
  

  提示：级联的 双点 符号不是运算符，这只是 Dart 语法的一部分。

二、流程控制

• 2.1. if 和 else
  和其他语言用法一样

  String today = 'Monday'
  if (today == 'Monday') {
        print('今天是星期一');
  } else {
        print('不知道今天是星期几')
  }
  

  提示：这里有一个注意点：不支持非空即真或者非0即真，必须有明确的bool类型

  String name = '小王'
  if (name) {
     // 这是错误的写法
  }
  

• 2.2. 循环操作
  基本的for循环

  for (var i = 0; i < 5; i++) {
      print(i);
  } 
  

  for in遍历List和Set类型

  var names = ['why', 'kobe', 'curry'];
  for (var name in names) {
      print(name);
  }
  

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

• 2.3. switch-case
  普通的switch使用，注意：每一个case语句，默认情况下必须以一个break结尾

  main(List<String> args) {
      var direction = 'east';
      switch (direction) {
      case 'east':
          print('东面');
      break;
      case 'south':
          print('南面');
      break;
      case 'west':
          print('西面');
      break;
      case 'north':
          print('北面');
      break;
      default:
          print('其他方向');
      }
  }
  

三、类和对象
Dart 作为高级语言支持买你洗那个对象的很多特性，并且支持基于 mixin 的继承方式。基于 mixin 的方式是指：一个类可以继承多个父类，相当于其他语言里的多继承。所有的类都有同一个基类 Object，这个特性类似于 Java 语言，Java所有类也都是继承自 Object，也就是说一切皆为对象。

• 3.1. 类的定义
  在Dart中，定义类用class关键字。
  类通常有两部分组成：成员（member）和方法（method）。
  定义类的伪代码如下：

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

  编写一个简单的Person类：

   class Person {
      String name;
      eat() {
          print('$name在吃东西');
      }
  }
  

  提示：

  • 这里有一个注意点: 我们在方法中使用属性(成员/实例变量)时，并没有加this；
  • Dart的开发风格中，在方法中通常使用属性时，会省略this，但是有命名冲突时，this不能省略；

  我们来使用这个类，创建对应的对象，从Dart2开始，new关键字可以省略

  main(List<String> args) {
      // 1.创建类的对象
      var p = new Person(); // 直接使用Person()也可以创建
  
      // 2.给对象的属性赋值
      p.name = '小王';  // 相当于使用了 name 的 setter 方法
  
      // 3.调用对象的方法
      p.eat();
  }
  

  提示：类定义中所有的变量都会隐式的定义 setter 方法，针对非空的变量会额外增加 getter 方法。

• 3.2、构造函数

  • <1>、普通构造函数
    构造函数是用来构造当前类的函数，是一种特殊的函数，函数名称必须要和类名相同才行。如下代码为 User类添加了一个构造函数，函数里给User类的两个成员变量初始化了值：

    class  User {
        String name;
        int age;
    
        User(String name, int age) {
              this.name = name;
              this.age = age;
        }
    }
    

    this 关键字指向了当前类的实例，上面的代码可以简化为

    class  User {
        String name;
        int age;
    
        User( this.name, this.age);
    
        @override
        String toString() {
           // TODO: implement toString
           return 'name=$name age=$age';
        }
    }
    

    • 注意一：当有了自己的构造方法时，默认的构造方法将会失效，不能使用
      当然，你可能希望明确的写一个默认的构造方法，但是会和我们自定义的构造方法冲突；这是因为Dart本身不支持函数的重载（名称相同, 参数不同的方式）。
    • 注意二：这里我还实现了toString方法

  • <2>、 命名构造函数
    使用命名构造函数从一个类或现有的数据中快速实现构造函数，代码如下所示

    class Person {
       String name;
       int age;
    
       Person( this.name, this.age);
    
       // 命名构造方法
       Person.withArgments(String name, int age) {
             this.name = name;
             this.age = age;
       }
    
       @override
       String toString() {
            return 'name=$name age=$age';
       }
    }
    
    // 创建对象
    var p1 = new Person();
    print(p1);
    var p2 = new Person.withArgments('why', 18);
    print(p2);
    

    在之后的开发中, 我们也可以利用命名构造方法，提供更加便捷的创建对象方式,比如开发中，我们需要经常将一个Map转成对象，可以提供如下的构造方法

    // 新的构造方法
    Person.fromMap(Map<String, Object> map) {
         this.name = map['name'];
         this.age = map['age'];
    }
    
    // 通过上面的构造方法创建对象
    var p3 = new Person.fromMap({'name': 'kobe', 'age': 30});
    print(p3);
    

  • <3>、构造函数初始化列表
    我们来重新定义一个类Point, 传入x/y，可以得到它们的距离distance:

    class Point {
        final num x;
        final num y;
        final num distance;
    
        // 错误写法
        // Point(this.x, this.y) {
        //   distance = sqrt(x * x + y * y);
        // }
    
        // 正确的写法
        Point(this.x, this.y) : distance = sqrt(x * x + y * y);
    }
    

    上面这种初始化变量的方法, 我们称之为初始化列表(Initializer list)

  • <4>、重定向构造函数
    在某些情况下, 我们希望在一个构造方法中去调用另外一个构造方法, 这个时候可以使用重定向构造方法，在一个构造函数中，去调用另外一个构造函数（注意：是在冒号后面使用this调用）

    class Person {
       String name;
       int age;
    
       Person(this.name, this.age);
       Person.fromName(String name) : this(name, 0);
    }
    

  • <5>、常量构造方法
    在某些情况下，传入相同值时，我们希望返回同一个对象，这个时候，可以使用常量构造方法.
    默认情况下，创建对象时，即使传入相同的参数，创建出来的也不是同一个对象，看下面代码:
    这里我们使用 identical(对象1, 对象2) 函数来判断两个对象是否是同一个对象:

    main(List<String> args) {
        var p1 = Person('why');
        var p2 = Person('why');
        print(identical(p1, p2)); // false
    }
    
    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 可以省略.

  • <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._internal(name);
                _cache[name] = p;
                return p;
            }
        }
        Person._internal(this.name);
    }
    

    提示

    • 普通的构造函数：会自动返回创阿金出来的对象，不能手动返回
    • 工厂构造函数的最大特点：可以手动返回一个对象

  • <7>、setter和getter
    默认情况下，Dart中类定义的属性是可以直接被外界访问的。
    但是某些情况下，我们希望监控这个类的属性被访问的过程，这个时候就可以使用 setter 和 getter 了

    main(List<String> args) {
        final d = Dog("黄色");
        d.setColor = "黑色";
        print(d.getColor);
    }
    
    class Dog {
        String color;
    
        String get getColor {
            return color;
        }
        set setColor(String color) {
            this.color = color;
        }
        Dog(this.color);
    }
    

• 3.3、 类的继承
  继承是面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为。使得子类对象(实例)具有父类的实例域和方法；或子类从父类继承方法，使得子类具有父类相同的行为。
  面向对象的其中一大特性就是继承，继承不仅仅可以减少我们的代码量，也是多态的使用前提。
  Dart中的继承使用extends关键字，子类中使用super来访问父类。
  父类中的所有成员变量和方法都会被继承,，但是构造方法除外。

  class Animal {
      int age;
  
      Animal(this.age);
  
      run() {
         print('在奔跑ing');
      }
  }
  
  class Person extends Animal {
      String name;
  
      Person(String name, int age) : name=name, super(age);
      // 重写父类的方法
      @override
      run() {
         print('$name在奔跑ing');
      }
  
      @override
      String toString() {
         return 'name=$name, age=$age';
      }
  }
  

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

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

• 3.4、抽象类
  父类本身可能并不需要对某些方法进行具体的实现，所以父类中定义的方法,，我们可以定义为抽象方法。
  什么是 抽象方法? 在Dart中没有具体实现的方法(没有方法体)，就是抽象方法。也就是定义了方法，可以不用实现。
  抽象方法，必须存在于抽象类中。
  抽象类是使用abstract声明的类。
  下面的代码中, Shape类就是一个抽象类, 其中包含一个抽象方法.

  // 抽象类不能实例化
  abstract class Shape {
      getArea();
  }
  
  class Circle extends Shape {
      double r;
  
      Circle(this.r);
  
      @override
      getArea() {
          return r * r * 3.14;
      }
  }
  // 注意：继承抽象类后，必须实现抽象类的抽象方法，不比如我们必须实现 Shape 的 getArea()
  class Reactangle extends Shape {
      double w;
      double h;
  
      Reactangle(this.w, this.h);
  
      @override
      getArea() {
          return w * h;
      }
  }
  

  提示：

  • 注意一：抽象类不能实例化。如果我们想实例化，那么可以如下

  • 注意二：抽象类中的抽象方法必须被子类实现, 抽象类中的已经被实现方法, 可以不被子类重写。

• 3.5、隐式接口
  Dart中的接口比较特殊, 没有一个专门的关键字来声明接口。
  默认情况下，定义的每个类都相当于默认也声明了一个接口，可以由其他的类来实现(因为Dart不支持多继承)
  在开发中，我们通常将用于给别人实现的类声明为抽象类:

  abstract class Runner {
      run();
  }
  
  abstract class Flyer {
      fly();
  }
  
  class SuperMan implements Runner, Flyer {
       @override
       run() {
          print('超人在奔跑');
       }
  
       @override
       fly() {
          print('超人在飞');
       }
  }
  

  提示： implements 后面跟 当做接口使用的类，那么该类必须实现 implements 后面所有类的方法

• 3.6、Mixin混入

  • Mixin(混入功能) 相当于多继承，也就是说可以继承多个类。

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

  • 但是某些情况下，一个类可能希望直接复用之前类的原有实现方案，怎么做呢?

  • 使用继承吗？但是Dart只支持单继承，那么意味着你只能复用一个类的实现。

  • Dart提供了另外一种方案: Mixin混入的方式

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

  • 使用 with 关键字来实现 Mixin功能，实例代码如下所示：

    main(List<String> args) {
        var superMan = SuperMain();
        superMan.run();
        superMan.fly();
    }
    
    mixin Runner {
        run() {
          print('在奔跑');
        }
    }
    
    mixin Flyer {
        fly() {
           print('在飞翔');
        }
    }
    
    // implements的方式要求必须对其中的方法进行重新实现
    // class SuperMan implements Runner, Flyer {}
    
    class SuperMain with Runner, Flyer {
    
    }
    

    提示：上面定义一个类并不是一定要用 mixin, 我们可以使用 calss

• 3.7、类成员和方法
  前面我们在类中定义的成员和方法都属于对象级别的, 在开发中, 我们有时候也需要定义类级别的成员和方法
  在Dart中我们使用static关键字来定义:

  main(List<String> args) {
       var stu = Student();
       stu.name = 'why';
       stu.sno = 110;
       stu.study();
  
       Student.time = '早上8点';
       // stu.time = '早上9点'; 错误做法, 实例对象不能访问类成员  
       ‍‍‍Student.attendClass();  // stu.attendClass(); 错误做法, 实现对象不能‍访问类方法
  }
  
  class Student {
      String name;
      int sno;
  
      static String time;
  
      study() {
         print('$name在学习');
      }
  
      static attendClass() {
         print('去上课');
      }
  }
  

  提示：static 是静态方法，也是类方法，如果学过Swift的话就会知道

• 3.8、枚举类型
  枚举在开发中也非常常见, 枚举也是一种特殊的类, 通常用于表示固定数量的常量值。

  • <1>、枚举的定义
    枚举使用 enum 关键字来进行定义:

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

  • <2>、枚举的属性
    枚举类型中有两个比较常见的属性:
    index: 用于表示每个枚举常量的索引, 从0开始.
    values: 包含每个枚举值的List.

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

    提示：枚举类型的注意事项:

    • 注意一: 不能子类化、混合或实现枚举。

    • 注意二: 不能显式实例化一个枚举，如下代码是错误的

      final color = Colors();
      

四、泛型

• 4.1、泛型的含义
  泛型通常是为了类型的安全而设计的，适当地指定泛型的类型会生成更好的代码，可以使用泛型来减少代码重复。Dart中使用 <T> 的方式来定义泛型。例如，如果想要 List 只包含字符串，我们可以将其声明为 list<String>。如下所示

  var names = new List<String>();
  name.addAll(['张三', '李四', '王五'])
  

• 4.2. List和Map的泛型
  List使用时的泛型写法:

  // 创建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使用时的泛型写法:

  // 创建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中
  var infos3 = <String, String>{'name': 'why', 'age': 18}; // 18不能放在value中
  

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

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

  Location类的定义: Object方式

  main(List<String> args) {
      Location l1 = Location(10, 20);
      print(l1.x.runtimeType); // Object
  }
  
  class Location {
      Object x;
      Object y;
  
      Location(this.x, this.y);
  }
  

  Location类的定义: 泛型方式

  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);
  }
  

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

  main(List<String> args) {
      Location l2 = Location<int>(10, 20);
      print(l2.x.runtimeType);
  
       // 错误的写法, 类型必须继承自num
      Location l3 = Location<String>('aaa', 'bbb');
      print(l3.x.runtimeType);
  }
  
  class Location<T extends num> {
      T x;
      T y;
  
      Location(this.x, this.y);
  }
  

  提示：T extends num 也就是只能传入 num 类型

• 4.4、泛型方法的定义
  最初，Dart仅仅在类中支持泛型。后来一种称为泛型方法的新语法允许在方法和函数中使用类型参数。

  main(List<String> args) {
      var names = ['why', 'kobe'];
      var first = getFirst(names);
      print('$first ${first.runtimeType}'); // why String
  }
  // 返回 list 的第一个元素
  T getFirst<T>(List<T> ts) {
      return ts[0];
  }
  

五、库的使用
在Dart中，你可以导入一个库来使用它所提供的功能。
库的使用可以使代码的重用性得到提高，并且可以更好的组合代码。
Dart中任何一个dart文件都是一个库，即使你没有用关键字library声明

• 5.1、引用库

  • <1>、引用自己写的库
    下图是在项目文件下建立了一个 Utils 文件夹，里面一个一些 dart 文件, Utils.dart 是专门用来放头文件的, 其他我自己写的工具文件，在其他文件使用的时候我们只需要导入 Utils.dart 文件，如： import 'Utils/utils.dart';
    

    61588387053_.pic_hd.jpg

    提示，当自己写的工具文件和其他库有冲突的时候，我们那可以给文件起别名，如上面的日期文件 date.utils.dart，我们可以如下，在调用 日期里面的方法的时候我们就可以 newDate. 了

    import 'utils/date.utils.dart ' as newDate
    

  • <2>、引用系统的库
    来自dart标准版，比如dart:io、dart:html、dart:math、dart:core(但是这个可以省略)

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

  • <3>、引用第三方的库，在 pub.dev 搜索第三方库，下面我们以 使用 http 为例
    

    WechatIMG7.jpeg

    • 我们需要在我们的项目里面建立一个文件 pubspec.yaml,里里有一些固定的格式

      name: wc
      description: a dart
      dependencies: 
            http: ^0.12.1
      

      提示：

      • name: 名字
      • description：描述
      • dependencies: 第三方库

    • 上面写好后我们需要在终端进入项目，执行下面的指令

      pub get
      

      提示，在执行完 pub get 后会生成其他几个文件，如：.packages、.dart_tool、pubspec.lock

    • http 的使用，导入头文件

      import 'package:http/http.dart' as http;
      
      main(List<String> args) async {
          var url = 'http://rest.apizza.net/mock/3bb78bf66bbd102a95221370ba9ddc2f/test';
          var response = await http.get(url);
          print('Response status: ${response.statusCode}');
          print('Response body: ${response.body}');
      }