Day03-Dart-基础语法二-阿里云开发者社区

总体概述

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

一、运算符

1.1、Dart 所有的运算符

描述	运算符
一元后缀	`expr++expr--·()[].?.`
一元前缀	`-expr!expr~expr--expr`
乘法类型	`*/%~/`
加法类型	`+-`
移动位运算	`<<>>`
与位运算	`&`
异或位运算	`^`
或位运算	`\|`
关系和类型测试	`>=<=><asisis!`
等式	`==!=`
逻辑与	`&&`
逻辑或	`\|\|`
条件	`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);
}

也可以如下：使用箭头

class Dog {
   String color;
   Dog(this.color);
   String get getColor => color;
   set setColor(String color) => this.color = 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中使用的方式来定义泛型。例如，如果想要 List 只包含字符串，我们可以将其声明为 list。如下所示

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';

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

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

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

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

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

import 'lib/student/student.dart' show Student, Person;
import 'lib/student/student.dart' hide Person;

<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 为例

我们需要在我们的项目里面建立一个文件 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}');
}

Day03-Dart-基础语法二

一、运算符

二、流程控制

三、类和对象

四、泛型

五、库的使用

热门文章

最新文章

相关课程

相关电子书

相关实验场景