Dart 学习记录(二)

运算符

除法、整除、取模运算
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';
  • 库文件中内容的显示和隐藏

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

    • 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%