专栏首页前端修炼之路Dart 学习之开发语言概览,带思维导图(二)

Dart 学习之开发语言概览,带思维导图(二)

库和可见性

  • 使用import关键字导入
  • dart内置库,使用dart:xxxx
  • 其他库,package:xxxx
  • 以下划线(_)开头的成员仅在代码库中可见
  • 每个 Dart 程序都是一个库,即便没有使用关键字 library 指定

库前缀

如果两个库代码有冲突,可以指定库前缀

import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;

// 使用 lib1 的 Element 类。
Element element1 = Element();

// 使用 lib2 的 Element 类。
lib2.Element element2 = lib2.Element();

导入库的一部分

只想使用代码库中的一部分,你可以有选择地导入代码库

// 只导入 lib1 中的 foo。(Import only foo).
import 'package:lib1/lib1.dart' show foo;

// 导入 lib2 中除了 foo 外的所有。
import 'package:lib2/lib2.dart' hide foo;

注释

单行注释

单行注释以 // 开始。所有在 // 和该行结尾之间的内容被编译器忽略。

// 单行注释

多行注释

  • 不会忽略文档注释
  • 多行注释可以嵌套
  • 多行注释以 /` 开始,以 `/ 结尾。所有在 /` 和 `/ 之间的内容被编译器忽略
void main() {
  /*
   * This is a lot of work. Consider raising chickens.

  Llama larry = Llama();
  larry.feed();
  larry.exercise();
  larry.clean();
   */
}

文档注释

  • 在文档注释中,除非用中括号括起来,否则 Dart 编译器会忽略所有文本。
/// A domesticated South American camelid (Lama glama).
///
/// Andean cultures have used llamas as meat and pack
/// animals since pre-Hispanic times.
class Llama {
  String name;

  /// Feeds your llama [Food].
  ///
  /// The typical llama eats one bale of hay per week.
  void feed(Food food) {
    // ...
  }

  /// Exercises your llama with an [activity] for
  /// [timeLimit] minutes.
  void exercise(Activity activity, int timeLimit) {
    // ...
  }
}

在生成的文档中,[Food] 会成为一个链接,指向 Food 类的 API 文档。

也就是说,在生成的文档中[Food]这个标识符就可以显示一个链接。

类型定义

  • 使用typedef显示保留类型信息
  • 目前类型定义只能在函数上
// 自定义一个类型
typedef Compare = int Function(Object a, Object b);

/// 使用类型定义的情况
class SortedCollection {
  Compare compare;  // 自定义类型

  SortedCollection(this.compare);
}

// 简单的不完整实现。
int sort(Object a, Object b) => 0;

void main() {
  SortedCollection coll = SortedCollection(sort);
  print(coll.compare is Function); // true
  print(coll.compare is Compare); // true
}

声明类

  • 使用class声明
  • 使用new创建一个对象,new可以省略
  • 所有对象都是一个类的实例
  • 所有的类都继承自 Object 类

使用类成员

  • 类的成员包括函数和数据
  • 使用(.)来访问变量和方法
  • 使用(?.)避免表达式为null
void main(List<String> args) {
  Person p = Person();
  p.name = 'tom';
  p.age = 12;
  print(p.name); // tom

  /// ?. 
  // 因为p2是null,所以无法设置并且打印
  // 但是使用了?.以后就不会报错了。
  Person p2;
  p2?.name = 'jack';
  p2?.age = 13;
  print(p2?.name);  // null
}

class Person{
  String name;
  int age;
}

使用构造函数

  • 使用类名
  • 使用类名.标识符
  • 使用identical函数判断两个类的实例是否相等
void main(List<String> args) {
  // 通过 类 创建实例
  Person p = Person('tom', 12);
  print(p.name);  // tom
  print(p.age); // 12

  // 通过 类名.标识符 创建实例
  Person p2 = Person.fromJson({'name': 'jack', 'age': 13})  ;
  print(p2.name); // jack
  print(p2.age); // 13

  Animal a = const Animal('titi', 2);
  Animal b  = const Animal('titi', 2);
  print(a.name);
  print(a.age);

  print(b.name);

  // 两个实例相等
  print(identical(a,b));  // true


}

class Person{
  String name;
  int age;

  Person(this.name, this.age);

  Person.fromJson(Map<String, dynamic> json){
    name = json['name'];
    age = json['age'];
  }
}

// 常量构造函数
class Animal{
  final String name;
  final int age;

  const Animal(this.name, this.age);
}

实例变量

  • 所有未初始化的变量均会被设置为null
  • 所有实例变量均会隐式地声明一个 Getter 方法
  • 所有 非 final 变量均会隐式声明一个 Setter方法
void main(List<String> args) {
  Point p = Point();
  print(p.x); // 调用x的 Getter

  p.y = 1; // 调用y的 Setter
  print(p.y); // 调用y的 Getter
}
class Point{
  int x,y;
}

命名式构造函数

void main(List<String> args) {
  Point p = Point.origin();

  print(p.x); // 0
  print(p.y); // 1
}
class Point{
  int x,y;
  Point(this.x, this.y);

  // 命名式构造函数
  Point.origin(){
    x = 0;
    y = 1;
  }
}

调用父类非默认构造函数

调用顺序

  • 1.初始化列表
  • 2.父类的无参数构造函数
  • 3.当前类的构造函数

传递给父类构造函数的参数不能使用 this 关键字。

使用(:)为子类的构造函数指定一个父类的构造函数。

class Person {
  String firstName;

  Person.fromJson(Map data) {
    print('in Person');
  }
}

class Employee extends Person {.
  // Person没有默认构造函数
  // 需要通过 super.fromJson 来显示调用
  Employee.fromJson(Map data) : super.fromJson(data) {
    print('in Employee');
  }
}

main() {
  var emp = new Employee.fromJson({});

  // 打印:
  // in Person  先执行父类的构造
  // in Employee
  if (emp is Person) {  // emp类继承了Person
    emp.firstName = 'Bob';
  }
  print(emp.firstName); // Bob
  (emp as Person).firstName = 'Jack';
  print(emp.firstName);   // Jack
}

初始化列表

  • 在构造函数体执行前初始化变量
  • 初始化列表用来设置 final 字段是非常好用的
class Person {
  String firstName;

  // 初始化列表 会比 构造函数优先执行
  Person.fromJson(Map data): firstName = data['firstName'] {
    print(firstName);
  }
}

main() {
  Person p = Person.fromJson({ 'firstName': 'zhangsan'});

}

设置final 字段

import 'dart:math';

class Point {
  final num x;
  final num y;
  final num distanceFromOrigin;

  // 初始化列表设置final属性,非常好用
  Point(x, y)
      : x = x,
        y = y,
        distanceFromOrigin = sqrt(x * x + y * y);
}

main() {
  var p = new Point(2, 3);
  print(p.distanceFromOrigin);  // 3.605551275463989
}

重定向构造函数

  • 调用自己类中其它的构造函数
  • 没有函数体
void main(List<String> args) {}

class Point {
  int x, y;
  Point(this.x, this.y);

  // 重定向构造函数
  // 在函数中调用另一个构造函数的形式
  Point.origin(int num) : this(num, 0);
}

常量构造函数

  • 属性用final定义为常量属性
  • 构造函数用const定义为常量构造函数
void main(List<String> args) {
  Point p = const Point(0, 0);
  Point p2 = const Point(0, 0);

  Point p3 = Point(0, 0);

  // 这两个实例对象是相同的
  print(identical(p, p2)); // true

  // 如果不使用const声明实例,则不会相等
  print(identical(p, p3)); // false
}

class Point {
  // 变量必须用final 定义
  final num x, y;
  const Point(this.x, this.y); // 构造函数也是常量
}

工厂构造函数

void main(List<String> args) {
  Person p = Person('tom');
  p.say();    // tom

}
 class Person{
   String name;

  // 必须static 定义
  static final Map<String, dynamic> _cach = Map<String, dynamic>();

   factory Person(String name){
     return _cach.putIfAbsent(name, () => Person._init(name));
   } 

   Person._init(this.name);

   void say(){
     print(name);
   }

 }

方法

实例方法

对象的实例方法可以访问实例变量和this

void main(List<String> args) {
  Person p = Person('tom', 'hello title');
  p.say();
}

class Person{
  String name;
  String title;

  Person(this.name, this.title);

  void say(){
    // 可以访问变量
    print('name is $name');
    // 也可以访问this
    print(this.name);
  }
}

Getter和Setter

你可以使用 get 和 set 关键字为额外的属性添加 Getter 和 Setter 方法

void main(List<String> args) {
  Point p = Point(1, 2, 3);
  print(p.point); // 6

  p.point = 0;
  print(p.point);
  print(p.z);
}

class Point {
  int x, y, z;

  Point(this.x, this.y, this.z);

  get point => x + y + z;
  // TODO: 这里为啥设置point 却返回z的值?
  set point(int num) => z = num + x;
}

抽象方法

void main(List<String> args) {

}
// 定义抽象类
abstract class Person{
  // 定义抽象方法
  void doSomething();
}

class Zhangsan extends Person{
  // 实现具体的方法
  void doSomething(){

  }
}

抽象类

void main(List<String> args) {
  var me = Me();
  me.sayHello();
}

abstract class Person{
  String name;
  int age;

  void sayHello();
}

class Me extends Person{
  void sayHello(){
    print('hello');
  }
}

隐式接口

一个类可以通过关键字 implements 来实现一个或多个接口并实现每个接口定义的 API。

void main(List<String> args) {

  print(saySomething(Person('张三')));

  print(saySomething(Man()));

}

String saySomething(Person person) => person.sayName('李四');

class Person {
  String _name;

  Person(this._name);

  String sayName(String name) => '$_name,你好。我是$name';
}

class Man implements Person {
  get _name => '谁也不是';

  set _name(String name) => ''; // 因为存在隐式的setter,所以这个也要定义

  String sayName(String name) => '$_name,你好。我是$name';
}

扩展一个类

  • 使用extends来扩展一个类
  • 使用super来引用一个父类
void main(List<String> args) {
  Man man = Man();
  man.sayName();
}

class Person{

  void sayName() => print('hello person');
}

class Man extends Person{

  void sayName() => super.sayName();  // 调用父类方法
}

重写类成员

void main(List<String> args) {
  Man man = Man();
  man.sayName();
}

class Person{

  void sayName() => print('hello person');
}

class Man extends Person{

  @override
  void sayName() => print('hello man'); // 重写实例方法
}

重写运算符

class Vector {
  final int x, y;

  Vector(this.x, this.y);

  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  Vector operator -(Vector v) => Vector(x - v.x, y - v.y);

  // 运算符 == 和 hashCode 的实现未在这里展示,详情请查看下方说明。
  // ···
}

void main() {
  final v = Vector(2, 3);
  final w = Vector(2, 2);

  assert(v + w == Vector(4, 5));
  assert(v - w == Vector(0, 1));
}

noSuchMethod

这个地方没有看明白

void main(List<String> args) {
  Man man = Man();
  // man.name;
  // todo 怎么使用??
}

class Person {
  void sayName() => print('hello person');
}

class Man extends Person {
  void sayName() => super.sayName(); // 调用父类方法

  @override
  void noSuchMethod(Invocation invocation) {
    print('你尝试使用一个不存在的成员:' + '${invocation.memberName}');
  }
}

枚举

  • 使用enmu定义
  • 每个枚举值都有index
  • 使用values获取所有枚举
  • 枚举不能成为子类
  • 枚举不可以mixin
  • 不可以实现一个枚举
  • 不可以显示实例化一个枚举

使用枚举

void main(List<String> args) {

  print(Color.blue);  // 获取枚举

  print(Color.red.index);   // 获取枚举下标

  List<Color> colors = Color.values;  // 获取全部枚举

  print(colors[2]);

}

enum Color{ // 定义枚举
  red, blue, green
}

switch枚举

void main(List<String> args) {
  var aColor = Color.red;
  // 如果使用switch 则枚举中的每一个成员都得用case判断
  // 否则就会发出警告
  switch (aColor) {
    case Color.red:
      print('红色');
      break;
    case Color.blue:
      print('蓝色');
      break;
    case Color.green:
      print('绿色');
      break;
  }
}

enum Color {
  // 定义枚举
  red,
  blue,
  green
}

使用mixin为类添加功能

  • Mixin 是一种在多重继承中复用某个类中代码的方法模式
  • 使用with关键字
  • 使用mixin定义
  • 使用on规定哪个类可以使用

覆写操作符基本格式:

返回类型 operator 操作符(参数1,参数2...){
    实现体...
    return 返回值
}
void main(List<String> args) {
  Musical musical = Musical();
  musical.doSomethin();
}
mixin Person {
  bool canCook = true;
  bool canSay = false;

  // mixin 模式不可以定义构造函数
  // Person();

  void doSomethin() {
    if (canCook == true) {
      print('可以做饭');
    } else if (canSay == true) {
      print('可以说话');
    }
  }
}
class Musical with Person{
  @override
  void doSomethin() {
    // TODO: implement doSomethin
    super.doSomethin();   // 直接调用父类
    print('我是子类哦');
  }
}

类变量和方法

静态变量

  • 静态变量在其首次被使用的时候才被初始化
void main(List<String> args) {
  print(Person.name); // test static
}
class Person{
  static final String name = 'test static';

}

静态方法

  • 对于一些通用或常用的静态方法,应该将其定义为顶级函数而非静态方法
  • 可以将静态方法作为编译时常量
import 'dart:math';

class Point {
  num x, y;
  Point(this.x, this.y);

  static num distanceBetween(Point a, Point b) {
    var dx = a.x - b.x;
    var dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
  }
}

void main() {
  var a = Point(2, 2);
  var b = Point(4, 4);
  // 对于一些通用或常用的静态方法,应该将其定义为顶级函数而非静态方法。
  var distance = Point.distanceBetween(a, b);
  assert(2.8 < distance && distance < 2.9);
  print(distance);
}

泛型

为什么使用泛型

  • 通常使用一个字母来代表类型参数,比如E、T、S、K 和 V 等等
  • 适当地指定泛型可以更好地帮助代码生成
  • 使用泛型可以减少代码重复

代码错误提示

void main(List<String> args) {
  var names = List<String>(); // 声明为字符串数组,一旦不是则报错
  names.addAll(['Seth', 'Kathy', 'Lars']);
  // 提示报错
  // names.add(42); // Error
}

减少重复代码 使用泛型声明一个类,让不同类型的缓存实现该类做出不同的具体实现。

void main(List<String> args) {}

abstract class Cache<T> {
  T getByKey(String key);
  void setByKey(String key, T value);
}

class Acache extends Cache<String> {
  String getByKey(String key) {
    // 具体实现时指定
    return 'hello';
  }

  void setByKey(String key, String value) {
    // 具体实现时指定
    print(11);
  }
}

使用集合字面量

void main(List<String> args) {
  List list = <String>['1', '2', '3'];  // 字符串集合
  Set set = <String>{'1','2','3'}; // 字符串集合
  Map map = <String, int>{'age': 1, 'size':12}; // Map
}

使用类型参数化的构造函数

void main(List<String> args) {
  // 与字面量相对应,也可以通过构造函数的方式使用泛型
  Map map = Map<String, int>();
}

泛型集合以及他们所包含的类型

void main(List<String> args) {
  List list = List<String>();
  // list.addAll(['1','2']); 
  // 如果此时使用addAll则会报错
  list.add('1');
  list.add('2');
  print(list is List<String>); // true

  var names = List<String>();
  names.addAll(['小芸', '小芳', '小民']);
  print(names is List<String>); // true
}

限制参数化类型

  • 指定参数类型
  • 不指定参数类型,使用默认类型
  • 错误参数类型,编译报错
void main(List<String> args) {
  var someBaseClassFoo = Foo<SomeBaseClass>();
  var extenderFoo = Foo<Extender>();

  print(someBaseClassFoo.toString()); // 'Foo<SomeBaseClass>' 的实例
  print(extenderFoo.toString()); // 'Foo<Extender>' 的实例

  // 如果不指定泛型,默认是SomeBaseClass
  var foo = Foo();
  print(foo);
  // 将非 SomeBaseClass 的类型作为泛型参数则会导致编译错误
  // var foo = Foo<Object>(); 
}

class SomeBaseClass {}

// 这里的T,其实可以随意指定。一般是T、E、S、K等
class Foo<T extends SomeBaseClass> {
  // 具体实现……
  String toString() => "'Foo<$T>' 的实例";
}

class Extender extends SomeBaseClass {}

使用泛型方法

  • 函数的返回类型
  • 参数的类型List
  • 局部变量的类型
void main(List<String> args) {
  var list = List<String>();
  list.addAll(['1','2']);

  var firstValue = first(list);
  print(firstValue);  // 1
}
T first<T>(List<T> ts) {
  // 处理一些初始化工作或错误检测……
  T tmp = ts[0];
  // 处理一些额外的检查……
  return tmp;
}

异步支持

处理Future

  • 使用 async 和 await 的代码是异步的,但是看起来有点像同步代码
  • 必须在带有 async 关键字的 异步函数 中使用 await
  • 使用 try、catch 以及 finally 来处理使用 await 导致的异常
  • await 表达式的返回值是一个 Future 对象
  • Future 对象代表一个“承诺”,await 表达式会阻塞直到需要的对象返回
void main(List<String> args) {}
// async 与 await同时使用
Future checkVersion() async {
  // 通过 try-catch 捕获异常
  try {
    var version = await lookUpVersion();
  } catch (e) {
    // 无法找到版本时做出的反应
  }
}

void lookUpVersion() {}

异步函数

void main(List<String> args) {

}
// 普通函数直接添加async关键字即可
Future<String> lookUpVersion() async => '1.0.0';

处理Stream

  • 使用async和await for循环
  • 使用Stream API
  • 表达式 的类型必须是 Stream
  • 使用 break 和 return 语句停止接收 Stream 数据,跳出循环
  • 1.等待直到 Stream 返回一个数据
  • 2.使用 1 中 Stream 返回的数据执行循环体
  • 3.重复 1、2 过程直到 Stream 数据返回完毕

可调用类

通过实现类的 call() 方法,允许使用类似函数调用的方式来使用该类的实例。

// WannabeFunction 类定义了一个 call() 函数,函数接受三个字符串参数,函数体将三个字符串拼接,字符串间用空格分割,并在结尾附加了一个感叹号

class WannabeFunction {
  String call(String a, String b, String c) => '$a $b $c!';
}

var wf = WannabeFunction();
var out = wf('Hi', 'there,', 'gang');

main() => print(out);

思维导图

制作的思维导图,加深学习印象。如有错误欢迎指正。

原始图片比较大,为了保证打开速度只上传了一张截图。如果需要高清图片可以在我的源码「https://github.com/siberiawolf/dart_study」文件中找到。

思维导图 (完结)


参考资料:

  • Dart语法学习 「https://www.jianshu.com/p/9e5f4c81cc7d」
  • 官方文档中文版「https://dart.cn/guides/language/language-tour」
  • 官网文档英文版「https://dart.dev/guides/language/language-tour」
  • Dart SDK API 中文版「http://www.shutongye.com/dartapi/index.html」
  • Flutter开发第一步-Dart编程语言入门「https://www.imooc.com/learn/1035」

本文分享自微信公众号 - 前端修炼之路(siberiawolf0307),作者:siberiawolf

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-03-20

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Dart 学习之开发语言概览,带思维导图(一)

    之前在学习flutter,本以为自己可以轻松上手掌握dart,结果发现经常有不懂的语法。所以决定踏踏实实的学习一遍dart。网上有很多相关学习资料.我主要从官网...

    siberiawolf
  • Flutter 学习路线图

    Flutter越来越火,学习Flutter的人越来越多,对于刚接触Flutter的人来说最重要的是如何学习Flutter,重点学习Flutter的哪些内容。下面...

    老孟Flutter
  • 全网最全 Flutter 与 React Native 深入对比分析

    作为 GSY 开源系列的作者,在去年也整理过 《移动端跨平台开发的深度解析》 的对比文章,时隔一年之后,本篇将重新由 环境搭建、实现原理、编程开发、插件开发、编...

    GSYTech
  • 关于移动互联网的跨平台技术演进

    随着移动互联网的普及和快速发展,手机成了互联网行业最大的流量分发入口。以及随着5G的快速发展,未来越来越多的“端”也会如雨后春笋般快速兴起。而“快”作为互联网的...

    Android技术干货分享
  • Dart语言概览

    前面对Dart语言的基本语法做了简单介绍,本篇文章我们站在一个更高的维度来聊一聊Dart。

    拉维
  • 当 Flutter 遇见 Web,会有怎样的秘密?

    ? 作者:haigecao,腾讯 CSIG Web 开发工程师 在线教育团队(简称:OED)已经将 Flutter 这样技术在业务中落地了,做为 IMWe...

    腾讯技术工程官方号
  • 如何快速学一门新语言,以 Dart 为例

    世界上没有一种可以各个领域通吃的语言,为了应对不同的场景和需求,我们摆脱不了要学习一门新的语言。最近准备入坑 Flutter(技术储备),学了点 Dart, 一...

    桃翁
  • 自绘引擎时代,为什么Flutter能突出重围?

    如上图所示,与2019年1月相比,全球使用互联网的人数已增加到45.4亿,增长了7%(2.98亿新用户)。

    腾小云
  • 起飞了!Git新开源高星《Flutter跨平台开发入门与实战笔记》安卓高阶必备

    有了Flutter,就有了几乎无穷无尽的可能性,因此即使是体量巨大的App也可以轻松地被创建出来。如果你是做移动App开发的并且尚未尝试过Flutter,我强烈...

    用户1907613
  • 【科普】Dart语言

    Dart是一门新的编程语言,如同JAVA、PHP一样,是为了解决编写应用程序中的一些实际问题而被造轮子发明出来的,而这个造轮子的人就是 Google。可能大家都...

    Jean
  • 150多个Flutter组件详细介绍送给你

    150+Flutter组件详细介绍地址:http://laomengit.com/

    老孟Flutter
  • 初学者如何快速上手Flutter开发?

    其中Widget、状态机制、调试技巧以及深入原理在课程后面会有相应的章节进行讲解,在这里以我们主要聚焦在走进和认识它、掌握它的语言以及合理利用工具这些环节上。

    CrazyCodeBoy
  • Flutter终将逆袭!1.2版本发布,或将统一江湖

    在去年 MWC 大展上发布首个 Beta 版后,Flutter 1.0 正式版于 2018 年 12 月召开的 Flutter Live 2018 上正式发布。...

    猿哥
  • Flutter为什么使用Dart?

    老孟导读:关于Flutter为什么使用Dart?这个话题,就像PHP是世界上最好的语言一样,争论从来没有停止过,有很多说法,比如:

    老孟Flutter
  • 前端每周清单第 56 期: D3 5.0,深入 React 事件系统,SketchCode 界面生成

    前端每周清单专注大前端领域内容,以对外文资料的搜集为主,帮助开发者了解一周前端热点;分为新闻热点、开发教程、工程实践、深度阅读、开源项目、巅峰人生等栏目。欢迎关...

    王下邀月熊
  • Flutter 核心原理与混合开发模式

    在 「Fan 直播」的 Flutter 混合开发实践中,我们总结了一些 Flutter 混合开发的经验。本文第一篇章将从 Flutter 原理出发,详细介绍 ...

    QQ音乐技术团队
  • 移动跨平台框架Flutter详细介绍和学习线路分享

    Flutter是一款移动应用程序SDK,一份代码可以同时生成iOS和Android两个高性能、高保真的应用程序。 Flutter目标是使开发人员能够交付在不同...

    Android技术干货分享
  • 2021年如何学习Flutter?

    Flutter之所以变得流行,是因为它具有快速构建应用程序的灵活性以及易于学习语言的灵活性。不管您是经验丰富的开发人员还是新手,观看一些有用的视频,收集一些在线...

    蓝默空间
  • Flutter系列(一)——详细介绍

    Flutter 是谷歌推出的开发移动UI框架,可以快速的在IOS和Android上构建高质量的原生用户界面。

    Demo_Yang

扫码关注云+社区

领取腾讯云代金券