Flutter面试基础知识：dart 语法基础与重点

在Dart中，抽象类（abstract class）允许你定义一个类的结构，但不完全实现它。抽象类可以包含抽象方法（由`abstract`关键字标记的方法），这些方法在抽象类中没有实现，必须在任何继承该抽象类的非抽象子类中实现。

对于抽象类中的方法，以下是一些关键点：

1. **抽象方法**：在抽象类中定义的方法，如果标记为`abstract`，则不需要（也不可以）在抽象类本身中提供方法体。这样的方法必须在任何非抽象子类中实现。

2. **非抽象方法**：抽象类也可以包含非抽象方法，这些方法在抽象类中有具体的实现。子类可以选择重写这些方法，也可以继承它们的默认实现。

3. **子类必须实现所有抽象方法**：任何继承抽象类的非抽象子类都必须实现抽象类中定义的所有抽象方法。如果子类没有实现所有抽象方法，那么它本身也必须被标记为`abstract`。

所以，对于你的问题，“抽象类中的方法必须被重写吗？”答案是：抽象方法必须在非抽象子类中被重写，但非抽象方法则不是必需的。

以下是一个简单的例子：

```dart
abstract class Animal {
  // 抽象方法，必须在子类中实现
  abstract void makeSound();

  // 非抽象方法，子类可以选择重写或者继承默认实现
  void eat() {
    print('The animal eats.');
  }
}

class Dog extends Animal {
  // 必须实现从Animal继承来的抽象方法makeSound
  @override
  void makeSound() {
    print('The dog barks.');
  }

  // 可以选择重写eat方法，也可以继承默认实现
  @override
  void eat() {
    print('The dog eats dog food.');
  }
}

void main() {
  Dog dog = Dog();
  dog.makeSound(); // 输出: The dog barks.
  dog.eat();       // 输出: The dog eats dog food.
}
```

在这个例子中，`Animal`是一个抽象类，它有一个抽象方法`makeSound`和一个非抽象方法`eat`。`Dog`类继承了`Animal`类，并且实现了`makeSound`方法。同时，它也重写了`eat`方法，但如果不重写，它将继承`Animal`类中`eat`方法的默认实现。

抽象父类

简述

使用方法

串行（串联操作）

并发（平行操作）（parallel operations）

串行和并行的区别

Future 类在 Dart 中提供了一系列静态方法，其中包括 any、doWhile、forEach 和 wait。这些方法用于处理一组 Future 对象，但它们在用法和用途上有一些区别。

1. Future.any：
用途： Future.any 用于从一组 Future 中取得第一个完成的 Future 的结果，无论它是成功还是失败。
方法签名：
static Future<dynamic> any(Iterable<Future<dynamic>> futures)
示例：
Future<String> fetchUserData() async {
  // 模拟异步操作
  await Future.delayed(Duration(seconds: 2));
  return 'User data';
}

Future<String> fetchProductData() async {
  // 模拟异步操作
  await Future.delayed(Duration(seconds: 3));
  return 'Product data';
}

void main() async {
  List<Future<String>> futures = [
    fetchUserData(),
    fetchProductData(),
  ];

  try {
    var result = await Future.any(futures);
    print('First completed result: $result');
  } catch (error) {
    print('All futures failed: $error');
  }
}

2. Future.doWhile：
用途： Future.doWhile 用于在条件为真的情况下反复执行异步操作，直到条件为假。
方法签名：
dart
Copy code
static Future<void> doWhile(FutureOr<bool> Function() action)
示例：
dart
Copy code
Future<void> fetchData() async {
  // 模拟异步操作
  await Future.delayed(Duration(seconds: 1));
  print('Data fetched');
}

void main() async {
  bool condition = true;

  await Future.doWhile(() async {
    await fetchData();
    condition = /* some condition */;
    return condition;
  });

  print('Do-while loop completed');
}

3. Future.forEach：
用途： Future.forEach 用于遍历一组元素，并为每个元素执行异步操作。
方法签名：
dart
Copy code
static Future<void> forEach<T>(Iterable<T> elements, FutureOr<void> Function(T element) action)
示例：
dart
Copy code
Future<void> processItem(String item) async {
  // 模拟异步操作
  await Future.delayed(Duration(seconds: 1));
  print('Processed: $item');
}

void main() async {
  List<String> items = ['Item 1', 'Item 2', 'Item 3'];

  await Future.forEach(items, (item) async {
    await processItem(item);
  });

  print('All items processed');
}

4. Future.wait：
用途： Future.wait 用于等待一组 Future 全部完成，并返回一个包含所有结果的 List。
方法签名：
dart
Copy code
static Future<List<T>> wait<T>(Iterable<Future<T>> futures, {bool eagerError = false})
示例：
dart
Copy code
Future<String> fetchUserData() async {
  // 模拟异步操作
  await Future.delayed(Duration(seconds: 2));
  return 'User data';
}

Future<String> fetchProductData() async {
  // 模拟异步操作
  await Future.delayed(Duration(seconds: 3));
  return 'Product data';
}

void main() async {
  List<Future<String>> futures = [
    fetchUserData(),
    fetchProductData(),
  ];

  try {
    var results = await Future.wait(futures);
    print('All results: $results');
  } catch (error) {
    print('One or more futures failed: $error');
  }
}
这些方法提供了对异步操作的不同处理方式，根据具体需求选择合适的方法。要注意的是，这些方法返回的 Future 会在所有操作完成后才完成，可以通过 await 来等待这个结果。

使用方法：https://dart.dev/tools/linter-rules/unawaited_futures

单个
样例：
BAD:
void main() async {
  doSomething(); // Likely a bug.
}
GOOD:
Future doSomething() => print("doSomething");
void main() async {
  await doSomething();
  unawaited(doSomething()); // Explicitly-ignored fire-and-forget.
}

listen 和 await for 都是用于监听 Dart 中的 Stream 事件，但它们在使用方式和用途上有一些区别。

listen 方法：
使用方式： listen 方法是 Stream 提供的方法之一，通过调用 stream.listen 来注册事件监听器。
stream.listen(
  (data) {
    // 处理数据
  },
  onError: (error) {
    // 处理错误
  },
  onDone: () {
    // 处理完成事件
  },
  cancelOnError: false, // 可选参数，设置为 true 时遇到错误会立即取消订阅
);
场景： 适用于需要手动管理订阅过程，对每个事件分别进行处理的场景。常见用于异步编程、非 UI 相关的业务逻辑。
取消订阅： 如果不再需要监听事件，需要手动调用 cancel 或等到 Stream 关闭。

await for 循环：
使用方式： await for 循环是 Dart 中用于迭代异步 Stream 的语法糖，可以在异步函数中使用。
await for (var data in stream) {
  // 处理数据
}
场景： 适用于在异步函数中等待和处理整个 Stream 的事件序列，通常用于处理异步操作的结果。
取消订阅： 不需要手动取消订阅，await for 会自动处理订阅和取消订阅的过程，当 Stream 关闭时，循环会自动退出。
区别总结：
listen 适用于手动管理订阅过程，对每个事件进行个性化处理，可以在非异步函数中使用。
await for 更适用于在异步函数中等待和处理整个 Stream 的事件序列，不需要手动取消订阅，对于异步操作的结果处理更为方便。
在实际开发中，根据具体需求选择合适的方式。通常，如果你只关心某个特定时间范围内的事件，使用 listen 更合适；如果你需要一直监听整个 Stream 的事件，而且可能在异步函数中处理结果，那么 await for 循环更方便。

在Dart中，尤其是与Flutter框架结合使用时，监听用户输入（如TextField的文本变化）并展示到Text widget上通常不需要使用`await for`。`await for`通常用于遍历异步产生的Stream数据，这在处理如文件读取、网络请求或其他异步数据流时很有用。

对于用户输入，Flutter提供了`TextField` widget，它有一个`onChanged`回调，该回调会在用户输入文本时触发。你可以使用这个回调来更新状态，并反映到Text widget上。

下面是一个简单的例子，展示了如何使用`TextField`的`onChanged`回调来监听用户输入，并将输入文本展示到另一个Text widget上：

```dart
import 'package:flutter/material.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('User Input Example'),
        ),
        body: Center(
          child: MyInputField(),
        ),
      ),
    );
  }
}

class MyInputField extends StatefulWidget {
  @override
  _MyInputFieldState createState() => _MyInputFieldState();
}

class _MyInputFieldState extends State<MyInputField> {
  String _userInput = '';

  void _handleTextChange(String text) {
    setState(() {
      _userInput = text;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: <Widget>[
        TextField(
          decoration: InputDecoration(labelText: 'Enter Text'),
          onChanged: _handleTextChange, // 当文本变化时调用此回调
        ),
        SizedBox(height: 20), // 添加一些间距
        Text('You entered: $_userInput'), // 显示用户输入的文本
      ],
    );
  }
}
```

在这个例子中，`TextField`的`onChanged`属性接受一个函数，该函数会在用户每次键入字符时被调用。这个函数接收一个参数，即用户当前输入的文本。我们使用`setState`方法来更新状态，这会导致Flutter重新构建widget，从而更新UI以反映新的用户输入。

因此，对于监听用户输入并展示到Text widget上的情况，你不需要使用`await for`。相反，你应该使用Flutter提供的响应式编程模式，利用状态管理和widget重建来更新UI。

入口函数

是什么❓了解绑定做了什么，flutter框架

WidgetsFlutterBinding.ensureInitialized()

例如：网络、推送、地图等模块的初始化。

插入根控件、开始构建UI。（将根 Widget 插入 Widget 树中，并通知框架开始构建 UI。）

allprojects {
    repositories {
        google()
        mavenCentral()
    }
    configurations.all {
        resolutionStrategy {
//    force 'androidx.lifecycle:lifecycle-common:2.5.1'
            //                failOnVersionConflict()
        }
    }
}