一、前言
Flutter 是 Google 开源的 UI 工具包,帮助开发者通过一套代码库高效构建多平台精美应用,Flutter 开源、免费,拥有宽松的开源协议,支持移动、Web、桌面和嵌入式平台。
Flutter是使用Dart语言开发的跨平台移动UI框架,通过自建绘制引擎,能高性能、高保真地进行Android和IOS开发。Flutter采用Dart语言进行开发,而并非Java,Javascript这类热门语言,这是Flutter团队对当前热门的10多种语言慎重评估后的选择。因为Dart囊括了多数编程语言的优点,它更符合Flutter构建界面的方式。
本文主要就是简单梳理一下Dart语言的一些基础知识和语法。关于编程语言的基本语法无外乎那么些内容,注释、变量、数据类型、运算符、流程控制、函数、类、异常、文件、异步、常用库等内容,相信大部分读者都是有一定编程基础的,所以本文就简单地进行一个梳理,不做详细的讲解。大家也可以参考 Dart编程语言中文网。
上一篇文章主要是写了Dart语言的流程控制、函数和异常处理,本文将接着上一篇文章继续往后写,本文将主要介绍Dart语言的类和对象、泛型以及库的使用。
二、类和对象
Dart 是一种基于类和 mixin 继承机制的面向对象的语言。 每个对象都是一个类的实例,所有的类都继承于 Object。面向对象中非常重要的概念就是类,类产生了对象。接下来我们就具体来学习类和对象,但是Dart对类进行了很多其他语言没有的特性,所以,这里我会花比较长的篇幅来讲解。
2.1 类的定义
在Dart中,定义类用class关键字
。类通常有两部分组成:成员(member)和方法(method)。定义类的伪代码如下:
class 类名 {
类型 成员名;
返回值类型 方法名(参数列表) {
方法体
}
}
编写一个简单的Person类:
- 这里有一个注意点: 我们在方法中使用属性(成员/实例变量)时,
并没有加this
; - Dart的开发风格中,在方法中通常使用属性时,会
省略this
,但是有命名冲突
时,this不能省略
;
class Person { String name; eat() { print('$name在吃东西'); } }
我们来使用这个类,创建对应的对象:
- 注意:从Dart2开始,new关键字可以省略。
main(List<String> args) { // 1.创建类的对象 var p = new Person(); // 直接使用Person()也可以创建 // 2.给对象的属性赋值 p.name = 'why'; // 3.调用对象的方法 p.eat(); }
2.2 构造方法
Dart语言中构造方法分为普通构造方法、命名构造方法、重定向构造方法、常量构造方法、工厂构造方法以及初始化列表等多种。下面我们就一一给大家简单解释一下其中的区别。
2.2.1 普通构造方法
我们知道, 当通过类创建一个对象时,会调用这个类的构造方法。
- 当类中
没有明确指定构造方法
时,将默认拥有一个无参的构造方法
。 - 前面的Person中我们就是在调用这个构造方法。
我们也可以根据自己的需求,定义自己的构造方法:
- 注意一:当有了自己的构造方法时,
默认的构造方法将会失效
,不能使用- 当然,你可能希望明确的写一个默认的构造方法,但是会和我们自定义的构造方法冲突;
- 这是因为Dart本身
不支持函数的重载
(名称相同, 参数不同的方式)。
- 注意二:这里我还实现了toString方法
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提供了一种更加简洁的语法糖形式。
上面的构造方法可以优化成下面的写法:
Person(String name, int age) { this.name = name; this.age = age; } // 等同于 Person(this.name, this.age);
2.2.2 命名构造方法
但是在开发中, 我们确实希望实现更多的构造方法,怎么办呢?因为不支持方法(函数)的重载,所以我们没办法创建相同名称的构造方法。因此,我们需要使用命名构造方法:
class Person { String name; int age; Person() { name = ''; age = 0; } // 命名构造方法 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);
2.2.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)
2.2.4 重定向构造方法
在某些情况下, 我们希望在一个构造方法中去调用另外一个构造方法, 这个时候可以使用重定向构造方法
:
- 在一个构造函数中,去调用另外一个构造函数(注意:是在冒号后面使用this调用)
class Person { String name; int age; Person(this.name, this.age); Person.fromName(String name) : this(name, 0); }
2.2.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('zhangsan'); var p2 = const Person('zhangsan'); const p3 = Person('zhangsan'); var p4 = Person('zhangsan'); var p5 = Person('lisi'); print(identical(p1,p2)); //true print(identical(p1,p3)); //true print(identical(p1,p4)); //false print(identical(p1,p5)); //false } class Person { final String name; const Person(this.name); }
常量构造方法有一些注意点:
- 注意一:拥有常量构造方法的类中,所有的成员变量必须是final修饰的.
- 注意二: 为了可以通过常量构造方法,创建出相同的对象,不再使用 new关键字,而是使用const关键字
- 如果是将结果赋值给const修饰的标识符时,const可以省略.
2.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._internal(name); _cache[name] = p; return p; } } Person._internal(this.name); }
2.3 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); }
2.4 类的继承
面向对象的其中一大特性就是继承,继承不仅仅可以减少我们的代码量
,也是多态的使用前提
。Dart中的继承使用extends关键字
,子类中使用super来访问父类。父类中的所有成员变量和方法都会被继承,但是构造方法除外。
main(List<String> args) { var p = new Person(); p.age = 18; p.run(); print(p.age); } class Animal { int age; run() { print('在奔跑ing'); } } class Person extends Animal { }
子类可以拥有自己的成员变量,
并且可以对父类的方法进行重写
:
class Person extends Animal { String name; @override run() { print('$name在奔跑ing'); } }
子类中可以调用父类的构造方法,对某些属性进行初始化:
- 子类的构造方法在执行前,将隐含调用父类的
无参默认构造方法
(没有参数且与类同名的构造方法)。 - 如果父类没有
无参默认构造方法
,则子类的构造方法必须在初始化列表中通过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'; } }
2.5 抽象类
我们知道,继承是多态使用的前提。所以在定义很多通用的 调用接口
时, 我们通常会让调用者传入父类
,通过多态来实现更加灵活的调用方式。但是,父类本身可能并不需要对某些方法进行具体的实现,所以父类中定义的方法,我们可以定义为抽象方法。
什么是 抽象方法? 在Dart中没有具体实现的方法(没有方法体),就是抽象方法。
- 抽象方法,必须存在于抽象类中。
- 抽象类是使用
abstract
声明的类。
下面的代码中, Shape类就是一个抽象类, 其中包含一个抽象方法.
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; } }
注意事项:
- 注意一:抽象类不能实例化.
- 注意二:抽象类中的抽象方法必须被子类实现, 抽象类中的已经被实现方法, 可以不被子类重写.
2.6 隐式接口
Dart中的接口比较特殊, 没有一个专门的关键字来声明接口。默认情况下,定义的每个类都相当于默认也声明了一个接口,可以由其他的类来实现(因为Dart不支持多继承)。在开发中,我们通常将用于给别人实现的类声明为抽象类:
abstract class Runner { run(); } abstract class Flyer { fly(); } class SuperMan implements Runner, Flyer { @override run() { print('超人在奔跑'); } @override fly() { print('超人在飞'); } }
2.7 Mixin混入
在通过implements实现某个类时,类中所有的方法都必须
被重新实现
(无论这个类原来是否已经实现过该方法)。
但是某些情况下,一个类可能希望直接复用之前类的原有实现方案,怎么做呢?
- 使用继承吗?但是Dart只支持单继承,那么意味着你只能复用一个类的实现。
Dart提供了另外一种方案: Mixin混入的方式
- 除了可以通过class定义类之外,也可以通过mixin关键字来定义一个类。
- 只是通过mixin定义的类用于被其他类混入使用,通过with关键字来进行混入。
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 { }
2.8 类成员和方法
前面我们在类中定义的成员和方法都属于对象级别的, 在开发中, 我们有时候也需要定义类级别的成员和方法。在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('去上课'); } }
三、 枚举类型
枚举在开发中也非常常见, 枚举也是一种特殊的类, 通常用于表示固定数量的常量值。
3.1 枚举的定义
枚举使用enum关键字来进行定义:
main(List<String> args) {
print(Colors.red);
}
enum Colors {
red,
green,
blue
}
3.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
}
枚举类型的注意事项:
- 注意一: 您不能子类化、混合或实现枚举。
- 注意二: 不能显式实例化一个枚举
四、 泛型
泛型的定义主要有以下两种:
- 在程序编码中一些包含类型参数的类型,也就是说泛型的参数只可以代表类,不能代表个别对象。(这是当今较常见的定义)
- 在程序编码中一些包含参数的类。其参数可以代表类或对象等等。(人们大多把这称作模板)不论使用哪个定义,泛型的参数在真正使用泛型时都必须作出指明。
一些强类型编程语言支持泛型,其主要目的是加强类型安全及减少类转换的次数,但一些支持泛型的编程语言只能达到部分目的。
在Dart的 API 文档中你会发现基础数组类型 List 的实际类型是 List<E>
。 <…> 符号将 List 标记为 泛型 (或 参数化) 类型。 这种类型具有形式化的参数。 通常情况下,使用一个字母来代表类型参数, 例如 E, T, S, K, 和 V 等。
4.1 为什么使用泛型?
在类型安全上通常需要泛型支持, 它的好处不仅仅是保证代码的正常运行:
- 正确指定泛型类型可以提高代码质量。
- 使用泛型可以减少重复的代码。
如果想让 List 仅仅支持字符串类型, 可以将其声明为 List<String>
(读作“字符串类型的 list ”)。 那么,当一个非字符串被赋值给了这个 list 时,开发工具就能够检测到这样的做法可能存在错误。 例如:
var names = List<String>(); names.addAll(['Seth', 'Kathy', 'Lars']); names.add(42); // 错误
另外一个使用泛型的原因是减少重复的代码。 泛型可以在多种类型之间定义同一个实现, 同时还可以继续使用检查模式和静态分析工具提供的代码分析功能。
// 假设你创建了一个用于缓存对象的接口: abstract class ObjectCache { Object getByKey(String key); void setByKey(String key, Object value); } // 后来发现需要一个相同功能的字符串类型接口,因此又创建了另一个接口: abstract class StringCache { String getByKey(String key); void setByKey(String key, String value); } // 后来,又发现需要一个相同功能的数字类型接口 … 这里你应该明白了。 // 泛型可以省去创建所有这些接口的麻烦。 通过创建一个带有泛型参数的接口,来代替上述接口: abstract class Cache<T> { T getByKey(String key); void setByKey(String key, T value); }
在上面的代码中,T 是一个备用类型。 这是一个类型占位符,在开发者调用该接口的时候会指定具体类型。
4.2 List、Set、Map中泛型的使用
4.2.1 字面量中的泛型
List , Set 和 Map 字面量也是可以参数化的。 参数化字面量和之前的字面量定义类似, 对于 List 或 Set 只需要在声明语句前加 <type>
前缀, 对于 Map 只需要在声明语句前加 <keyType, valueType>
前缀, 下面是参数化字面量的示例:
var names = <String>['Seth', 'Kathy', 'Lars']; var uniqueNames = <String>{'Seth', 'Kathy', 'Lars'}; var pages = <String, String>{ 'index.html': 'Homepage', 'robots.txt': 'Hints for web robots', 'humans.txt': 'We are people, not machines' };
4.2.2 使用泛型类型的构造函数
在调用构造函数的时,在类名字后面使用尖括号(<...>
)来指定泛型类型。 例如:
// 创建一个元素为字符串的Set集合 var nameSet = Set<String>.from(names); // 下面代码创建了一个 key 为 integer, value 为 View 的 map 对象: var views = Map<int, View>();
4.2.3 运行时中的泛型集合
Dart 中泛型类型是 固化的,也就是说它们在运行时是携带着类型信息的。 例如, 在运行时检测集合的类型:
var names = List<String>(); names.addAll(['Seth', 'Kathy', 'Lars']); print(names is List<String>); // true
提示: 相反,Java中的泛型会被 擦除 ,也就是说在运行时泛型类型参数的信息是不存在的。 在Java中,可以测试对象是否为 List 类型, 但无法测试它是否为
List<String>
。
4.3 创建类时限制泛型类型
使用泛型类型的时候, 可以使用 extends
实现参数类型的限制。
class Foo<T extends SomeBaseClass> { // Implementation goes here... String toString() => "Instance of 'Foo<$T>'"; } class Extender extends SomeBaseClass {...} // 可以使用 SomeBaseClass 或其任意子类作为通用参数: var someBaseClassFoo = Foo<SomeBaseClass>(); var extenderFoo = Foo<Extender>(); // 也可以不指定泛型参数: var foo = Foo(); print(foo); // Instance of 'Foo<SomeBaseClass>' // 指定任何非 SomeBaseClass 类型会导致错误: var foo = Foo<Object>();
4.4 使用泛型函数
最初,Dart 的泛型只能用于类。 新语法_泛型方法_,允许在方法和函数上使用类型参数:
T first<T>(List<T> ts) { // Do some initial work or error checking, then... T tmp = ts[0]; // Do some additional checking or processing... return tmp; }
这里的 first
(<T>
) 泛型可以在如下地方使用参数 T
:
- 函数的返回值类型 (
T
). - 参数的类型 (
List<T>
). - 局部变量的类型 (
T tmp
).
五 库的使用
在Dart中,你可以导入一个库来使用它所提供的功能。库的使用可以使代码的重用性得到提高,并且可以更好的组合代码。Dart中任何一个dart文件都是一个库,即使你没有用关键字library
声明。
5.1 库的导入
import语句用来导入一个库,后面跟一个字符串形式的Uri来指定表示要引用的库,语法如下:
import '库所在的uri';
5.1.1 常见的库URI有三种不同的形式
- 来自dart标准版,比如dart:io、dart:html、dart:math、dart:core(但是这个可以省略)
//dart:前缀表示Dart的标准库,如dart:io、dart:html、dart:math import 'dart:io';
- 使用相对路径导入的库,通常指自己项目中定义的其他dart文件
//当然,你也可以用相对路径或绝对路径的dart文件来引用 import 'lib/student/student.dart';
- Pub包管理工具管理的一些库,包括自己的配置以及一些第三方的库,通常使用前缀package
//Pub包管理系统中有很多功能强大、实用的库,可以使用前缀 package: import 'package:flutter/material.dart';
5.1.2 库文件中内容的显示和隐藏
如果希望只导入库中某些内容
,或者刻意隐藏库里面某些内容
,可以使用show
和hide
关键字
- show关键字:可以显示某个成员(屏蔽其他)
- hide关键字:可以隐藏某个成员(显示其他)
// 只显示Student, Person,其他的都屏蔽 import 'lib/student/student.dart' show Student, Person; // 只屏蔽Person,其他的都显示 import 'lib/student/student.dart' hide Person;
5.1.3 库中内容和当前文件中的名字冲突
当各个库有命名冲突的时候,可以使用as关键字
来使用命名空间
import 'lib/student/student.dart' as Stu; Stu.Student s = new Stu.Student();
5.2 库的定义
5.2.1 library关键字
通常在定义库时,我们可以使用 library 关键字给库起一个名字。但目前我发现,库的名字并不影响导入,因为import语句用的是字符串URI
library math;
5.2.2 part关键字
在开发中,如果一个库文件太大,将所有内容保存到一个文件夹是不太合理的,我们有可能希望将这个库进行拆分,这个时候就可以使用part
关键字了。不过官方已经不建议使用这种方式了:
// mathUtils.dart文件 part of "utils.dart"; int sum(int num1, int num2) { return num1 + num2; } // dateUtils.dart文件 part of "utils.dart"; String dateFormat(DateTime date) { return "2020-12-12"; } // utils.dart文件 part "mathUtils.dart"; part "dateUtils.dart"; // test_libary.dart文件 import "lib/utils.dart"; main(List<String> args) { print(sum(10, 20)); print(dateFormat(DateTime.now())); }
5.2.3 export关键字
官方不推荐使用part关键字
,那如果库非常大,如何进行管理呢?
- 将每一个dart文件作为库文件,使用export关键字在某个库文件中单独导入
// mathUtils.dart文件 int sum(int num1, int num2) { return num1 + num2; } // dateUtils.dart文件 String dateFormat(DateTime date) { return "2020-12-12"; } // utils.dart文件 library utils; export "mathUtils.dart"; export "dateUtils.dart"; // test_libary.dart文件 import "lib/utils.dart"; main(List<String> args) { print(sum(10, 20)); print(dateFormat(DateTime.now())); }
最后,也可以通过Pub管理自己的库自己的库,在项目开发中个人觉得不是非常有必要,所以暂时不讲解这种方式。