鸿蒙NEXT-Flutter（2）

基础语法省略过多，但基本通用（类，函数，选择，循环）

类的继承扩展（mixin）

代码如下

scala 复制代码

void main() {
  student s = new student();
  s.printInfo();
  s.study();
}

class person {
  String username = "父类";
  num age = 18;
  void printInfo() {
    print("username = $username, age = $age");
  }
}

mixin Study {
  void study() {
    print("学习");
  }
}

class student extends person with Study {
  String username = "子类";
  num age = 20;
  void printInfo() {
    print("username = $username, age = $age");
  }
}

异步编程

主要用于解决项目中的耗时操作，但dart跟js一样都是单线程的。

如何解决这一问题呢？

本质上解决问题，语言不通处理方式不同。

多线程，比如Java、C++、鸿蒙中，我们普遍的做法是开启一个新的线程（Thread），在新的线程中完成这些异步的操作，再通过线程间通信的方式，将拿到的数据传递给主线程。
单线程+事件循环，比如JavaScript、Dart都是基于单线程加事件循环来完成耗时操作的处理。

写一个小demo演示一下耗时操作

kotlin 复制代码

import 'dart:io';

void main() {
  fun();
}

void fun() {
  print("开始");
  sleep(Duration(seconds: 3));  //延时器
  print("结束");
}

future（类似于Promise）

基本语法

kotlin 复制代码

void main() {
  fun();
}

Future<返回值类型> fun() {
  return Future<返回值类型>(() {
    //需要异步的代码
    sleep(Duration(seconds: 3));
    print(2);
    // return 返回值类型
    return 100;
  });
}

将同步进程改为异步进程：

kotlin 复制代码

import 'dart:io';

void main() {
  print(1);
  fun();
  print(3);
}

Future<num> fun() {
  return Future<num>(() {
    sleep(Duration(seconds: 3));
    print(2);
    return 100;
  });
}

链式调用

.then .catchError

kotlin 复制代码

import 'dart:io';

void main() {
  print(1);
  fun().then((res) {
    print('return结果$res');
  }).catchError((err) {
    print('异常信息$err');
  });
  print(3);
}

Future<num> fun() {
  return Future<num>(() {
    sleep(Duration(seconds: 3));
    print(2);
    //主动抛出异常
    throw Exception('网络异常');
   // return 100;
  });
}

async和await

如果你已经完全搞懂了Future，那么学习await、async应该没有什么难度。

await、async是什么呢？

它们是Dart中的关键字
它们可以让我们用同步的代码格式，去实现异步的调用过程。
并且，通常一个async的函数会返回一个Future。

我们已经知道，Future可以做到不阻塞我们的线程，让线程继续执行，并且在完成某个操作时改变自己的状态，并且回调then或者errorCatch回调。

如何生成一个Future呢？

1、通过我们前面学习的Future构造函数，或者后面学习的Future其他API都可以。
2、还有一种就是通过async的函数。

通常使用 async await 解决Future链式调用带来的回调地狱的问题

csharp 复制代码

import 'dart:io';

//
void main() async {
  try {
    int result1 = await getFirstData(); //
    print(result1);
    int result2 = await getSecondData(); //
    print(result2);
    int result3 = await getThirdData(); //
    print(result3);
  } catch (e) {
    print(e);
  }
}

// async / await 让我们用同步的方式去写异步
// 前端鸿蒙 async 必须配套await出现
// await总是会强制等待后面的promise进行resolve
// 如果没有resolve 需要使用try catch进行捕获

Future<int> getFirstData() {
  return Future<int>(() {
    sleep(Duration(seconds: 2));
    print("获取第一层数据成功");
    return 1;
  });
}

Future<int> getSecondData() {
  return Future<int>(() {
    sleep(Duration(seconds: 2));
    print("获取第二层数据成功");
    return 2;
  });
}

Future<int> getThirdData() {
  return Future<int>(() {
    sleep(Duration(seconds: 2));
    throw new Exception("获取第三层数据失败");
    // print("获取第三层数据成功");
    // return 3;
  });
}

泛型

[泛型的作用] ：在程序设计中提供一种机制，使得代码能够在编写时不指定具体类型，从而实现更灵活、可复用、类型安全的代码结构，能适应多种不同类型的数据处理需求。

比如：List和Map中的元素使用泛型限定为可以是任意类型的，从而不需要单独去封装存储某一种数据类型的List和Map

dart 复制代码

/*
 泛型的作用：使用泛型可以减少重复的代码
 封装函数：接收字符串就返回字符串，接收数字就返回数字，接收bool就返回bool
 */
void main() {
  // 1. 普通封装
  // String demoString(String str) {
  //   return str;
  // }

  // int demoInt(int a) {
  //   return a;
  // }

  // bool demoBool(bool b) {
  //   return b;
  // }

  // 2. 基于泛型封装
  T demo<T>(T parm) {
    return parm;
  }

  // 调用
  String ret1 = demo<String>('itcast');
  print(ret1);
  int ret2 = demo<int>(17);
  print(ret2);
  bool ret3 = demo<bool>(true);
  print(ret3);
}