Dart 学习记录(二)

发表于 | 分类于
字数统计: 4k word | 阅读时长 ≈ 17 min

运算符

除法、整除、取模运算
1
2
3
4
var num = 7;
print(num / 3); // 除法操作, 结果2.3333..
print(num ~/ 3); // 整除操作, 结果2;
print(num % 3); // 取模操作, 结果1;
??= 赋值操作

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

  • 当变量为null时，使用后面的内容进行赋值。
  • 当变量有值时，使用自己原来的值。
1
2
3
4
5
6
7
8
main(List<String> args) {
  var name1 = 'coderwhy';
  print(name1);
  // var name2 = 'kobe';
  var name2 = null;
  name2 ??= 'james'; 
  print(name2); // 当name2初始化为kobe时，结果为kobe，当初始化为null时，赋值了james
}
?? 条件运算符

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

  • 如果expr1是null，则返回expr2的结果;
  • 如果expr1不是null，直接使用expr1的结果。
1
2
3
4
var temp = 'why';
temp = null;
var name = temp ?? 'kobe';
print(name);  //输出： Kobe
.. 级联语法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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 = 'sss';
  p1.run();
  p1.eat();
  p1.swim();
	//使用级联语法 ..
  final p2 = Person()
              ..name = "ccc"
              ..run()
              ..eat()
              ..swim();
}

流程控制

if和else
  • 参考其他语言的用法但要注意： 不支持非空即真或者非0即真，必须有明确的bool类型
循环操作

  • 基本for循环

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

  • for in 遍历List和Set类型

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

  • while和do-while 和其他语言一致

  • break和continue用法也和其他语言一致
switch-case

普通的switch使用

  • 注意：每一个case语句，默认情况下必须以一个break结尾

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    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中，定义类用class关键字。

和Java一样， 类通常有两部分组成：成员（member）和方法（method） 。

1
2
3
4
5
6
class 类名 {
  类型 成员名;
  返回值类型 方法名(参数列表) {
    方法体
  }
}

编写一个简单的Person类

  • 这里有一个注意点: 我们在方法中使用属性(成员/实例变量)时，并没有加this；

  • Dart的开发风格中，在方法中通常使用属性时，会省略this，但是有命名冲突时，this不能省略；

    1
    2
    3
    4
    5
    6
    7
    class Person {
      String name;

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

我们来使用这个类，创建对应的对象：

  • 注意：从Dart2开始，new关键字可以省略。 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    main(List<String> args) {
      // 1.创建类的对象
      var p = new Person(); // 直接使用Person()也可以创建

      // 2.给对象的属性赋值
      p.name = 'why';

      // 3.调用对象的方法
      p.eat();
    }
构造方法
普通构造方法

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

  • 当类中没有明确指定构造方法时，将默认拥有一个无参的构造方法
  • 当有了自己的构造方法时，默认打的构造方法将会失效，不能使用
    • 当然， 你可能希望明确的写一个默认的构造方法，但是会和我们自定义的构造方法冲突；
    • 这是因为Dart本身不支持函数的重载（名称相同, 参数不同的方式）。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Person {
  String name;
  int age;

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

  @override
  String toString() {
    return 'name=$name age=$age';
  }
}

另外，在实现构造方法时，通常做的事情就是通过参数给属性赋值

为了简化这一过程, Dart提供了一种更加简洁的语法糖形式.

上面的构造方法可以优化成下面的写法：

1
2
3
4
5
6
Person(String name, int age) {
  this.name = name;
  this.age = age;
}
// 等同于
Person(this.name, this.age);
命名构造方法

在开发中，我们确实 希望实现更多的构造方法，怎么办呢？

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

我们需要使用命名构造方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Person {
  String name;
  int age;

  Person() {
    name = '';
    age = 0;
  }
	// 命名构造方法 自己起一个名 这里名字叫做withArgments
  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转成对象，可以提供如下的构造方法 

    1
    2
    3
    4
    5
    6
    7
    8
    9
     // 新的构造方法
    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);
初始化列表

  • 初始化实例参数，用逗号分隔

    我们来重新定义一个类Point, 传入x/y，可以得到它们的距离distance: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Point {
  num x;
  num y;

  Point(this.x, this.y);

  // Initializer list sets instance variables before
  // the constructor body runs.
  Point.fromJson(Map jsonMap)
      : x = jsonMap['x'],
        y = jsonMap['y'] {
    print('In Point.fromJson(): ($x, $y)');
  }
}
  • 初始化列表非常适合用来设置 final 变量的值
1
2
3
4
5
6
7
8
import 'dart:math';
class Point {
  final num x;
  final num y;
  final num distance;
  
  Point(this.x, this.y) : distance = sqrt(x * x + y * y);
}
重定向构造方法
  • 在某些情况下, 我们希望在一个构造方法中去调用另外一个构造方法, 这个时候可以使用重定向构造方法： 
1
2
3
4
5
6
7
class Person {
  String name;
  int age;

  Person(this.name, this.age);
  Person.fromName(String name) : this(name, 0);
}
常量构造方法

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

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

  • 这里我们使用identical(对象1, 对象2)函数来判断两个对象是否是同一个对象: 
1
2
3
4
5
6
7
8
9
10
11
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进行修饰，那么可以保证同一个参数，创建出来的对象是相同的

  • 这样的构造方法就称之为常量构造方法 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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关键字
工厂构造方法

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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);
}
setter和getter
  • 参考java

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

但是某些情况下，我们希望监控这个类的属性被访问的过程，这个时候就可以使用setter和getter了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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);
}
类的继承

  • 关键字： extends

  • 子类中用 super 来访问父类

  • 父类中的所有成员变量和方法都会被继承，但是构造方法除外

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    main(List<String> args) {
      var p = new Person();
      p.age = 18;
      p.run();
      print(p.age);
    }

    class Animal {
      int age;

      run() {
        print('在奔跑ing');
      }
    }

    //Person类继承了Animal 类
    class Person extends Animal {

    }

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

    1
    2
    3
    4
    5
    6
    7
    8
    class Person extends Animal {
      String name;

      @override
      run() {
        print('$name在奔跑ing');
      }
    }

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

    • 子类的构造方法在执行前，将隐含调用父类的无参默认构造方法（没有参数且与类同名的构造方法）。

    • 注意：！！！如果父类没有无参默认构造方法，则子类的构造方法必须在初始化列表中通过super显式调用父类的某个构造方法。 

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      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';
        }
      }
抽象类

  • 参考java

  • 抽象类使用 abstract 声明的类

  • 抽象类中的抽象方法，不需要在抽象类中实现，只需声明即可

  • 抽象类不能被实例化 即不能new一个抽象类

  • 抽象类中的抽象方法必须被子类实现, 抽象类中的已经被实现方法, 可以不被子类重写. 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    abstract class Shape {
      getArea();
    }

    class Circle extends Shape {
      double r;

      Circle(this.r);

      @override
      getArea() {
        return r * r * 3.14;
      }
    }

    class Reactangle extends Shape {
      double w;
      double h;

      Reactangle(this.w, this.h);

      @override
      getArea() {
        return w * h;
      }
    }
隐式接口

Dart中的接口比较特殊, 没有一个专门的关键字来声明接口.

默认情况下，定义的每个类都相当于默认也声明了一个接口，可以由其他的类来实现(因为Dart不支持多继承)

在开发中，我们通常将用于给别人实现的类声明为抽象类:

  • 实现接口用 implements
  • 通过implements实现某个类时，类中所有的方法都必须被重新实现(无论这个类原来是否已经实现过该方法)。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
abstract class Runner {
  run();
}

abstract class Flyer {
  fly();
}

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

  @override
  fly() {
    print('超人在飞');
  }
}
Mixin 混入

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

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

  • 除了可以通过class定义类之外，也可以通过mixin关键字来定义一个类。

  • 只是通过mixin定义的类用于被其他类混入使用，通过with关键字来进行混入。 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    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 {

    }
类成员和方法

前面我们在类中定义的成员和方法都属于对象级别的, 在开发中, 我们有时候也需要定义类级别的成员和方法

  • 在Dart中我们使用 static 关键字来定义: 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    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('去上课');
      }
    }
枚举类型
枚举的定义

  • 参考java

  • 用关键字 enum 定义

  • 不能子类化、混合或实现枚举

  • 不能显式实例化一个枚举

    1
    2
    3
    4
    5
    6
    7
    8
    9
    main(List<String> args) {
      print(Colors.red);
    }

    enum Colors {
      red,
      green,
      blue
    }
枚举的属性

枚举类型中有两个常见的属性：

  • index: 用于表示每个枚举常量的索引，从0开始。

  • values: 包含每个枚举值的List。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    main(List<String> args) {
      print(Colors.red.index);
      print(Colors.green.index);
      print(Colors.blue.index);

      print(Colors.values);
    }

    enum Colors {
      red,
      green,
      blue
    }

泛型

  • 参考Java
List和Map的泛型

List使用时的泛型写法：

1
2
3
4
5
6
7
// 创建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使用时的泛型写法：

1
2
3
4
5
6
7
// 创建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中
类定义的泛型

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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);
}
泛型方法的定义
1
2
3
4
5
6
7
8
9
main(List<String> args) {
  var names = ['why', 'kobe'];
  var first = getFirst(names);
  print('$first ${first.runtimeType}'); // why String
}
//一定要注意写法
T getFirst<T>(List<T> ts) {
  return ts[0];
}

库的使用

在Dart中，你可以导入一个库来使用它所提供的功能。

库的使用可以使代码的重用性得到提高，并且可以更好的组合代码。

Dart中任何一个dart文件都是一个库，即使你没有用关键字library声明

导入库
1
import '库所在的uri';

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

  • 来自dart标准版，比如dart:io、dart:html、dart:math、dart:core(但是这个可以省略) 

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

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

    1
    2
    //当然，你也可以用相对路径或绝对路径的dart文件来引用
    import 'lib/student/student.dart';

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

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

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

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

    • show 关键字，可以显示某个成员（屏蔽其他）

    • hide 关键字，可以隐藏某个成员（显示其他）

      1
      2
      3
      import 'lib/student/student.dart' show Student, Person;

      import 'lib/student/student.dart' hide Person;

  • 库中内容和当前文件中的名字冲突

    当各个库有命名冲突的时候，可以使用as关键字来使用命名空间 

    1
    2
    3
    import 'lib/student/student.dart' as Stu;

    Stu.Student s = new Stu.Student();
库的定义

  • library 关键字

  • 通常在定义库时，我们可以使用library关键字给库起一个名字。 但库的名字并不影响导入，因为import语句用的是字符串Uri 

    1
    library math;
库的管理和组织

如果库非常大，如何进行管理呢？

  • 将每一个dart文件作为库文件，使用export关键字在某个库文件中单独导入

    • mathUtils.dart文件 （分）

      1
      2
      3
      int sum(int num1, int num2) {
        return num1 + num2;
      }

    • dateUtils.dart文件 ？（分）

      1
      2
      3
      String dateFormat(DateTime date) {
        return "2020-12-12";
      }

    • utils.dart文件 (合)

      1
      2
      3
      4
      library utils;

      export "mathUtils.dart";
      export "dateUtils.dart";

    • test_libary.dart文件 (用)

      1
      2
      3
      4
      5
      6
      import "lib/utils.dart";

      main(List<String> args) {
        print(sum(10, 20));
        print(dateFormat(DateTime.now()));
      }
0%