变量

void main() {
  // 1. 显式类型声明 (Explicit Type Declaration)
  // 你明确告诉编译器这个变量是什么类型
  String name = 'Alice'; // 声明一个String类型的变量name，并初始化为'Alice'
  int age = 30;           // 声明一个int类型的变量age，并初始化为30
  double height = 1.75;   // 声明一个double类型的变量height，并初始化为1.75
  bool isActive = true;   // 声明一个bool类型的变量isActive，并初始化为true

  print('显式类型声明:');
  print('Name: $name (Type: ${name.runtimeType})');
  print('Age: $age (Type: ${age.runtimeType})');
  print('Height: $height (Type: ${height.runtimeType})');
  print('Is Active: $isActive (Type: ${isActive.runtimeType})');
  print('--------------------');

  // 2. 类型推断 (Type Inference) - 使用 `var` 关键字
  // Dart会根据赋给变量的初始值自动推断其类型
  var city = 'New York'; // Dart推断 city 为 String 类型
  var population = 8400000; // Dart推断 population 为 int 类型
  var temperature = 25.5; // Dart推断 temperature 为 double 类型
  var isRaining = false; // Dart推断 isRaining 为 bool 类型

  print('类型推断 (var):');
  print('City: $city (Type: ${city.runtimeType})');
  print('Population: $population (Type: ${population.runtimeType})');
  print('Temperature: $temperature (Type: ${temperature.runtimeType})');
  print('Is Raining: $isRaining (Type: ${isRaining.runtimeType})');

  // 注意：一旦 `var` 变量推断出类型，就不能再赋其他类型的值
  // city = 123; // 这行代码会报错：A value of type 'int' can't be assigned to a variable of type 'String'.
  print('--------------------');

  // 3. 未初始化的变量 (Uninitialized Variables)
  // Dart中未初始化的变量默认值为 `null`
  int? count; // 使用 `?` 表示这个变量可以为 null (可空类型)
  String? message; // 字符串也可以是可空的

  print('未初始化的变量:');
  print('Count: $count (Type: ${count.runtimeType})');
  print('Message: $message (Type: ${message.runtimeType})');

  // 注意：自 Dart 2.12 起，如果你不使用 `?` 声明可空类型，
  // 那么未初始化的非 'late' 变量将无法通过编译：
  // int price; // 这行会报错：The non-nullable local variable 'price' must be assigned before it can be used.
  // 除非你声明为 `late` 或者给它一个初始值。
  print('--------------------');

  // 4. `final` 关键字
  // `final` 变量只能被赋值一次。
  // 它的值可以是运行时确定的，即在程序运行时计算。
  final DateTime now = DateTime.now(); // `now` 在运行时被赋值，之后不能再改变
  final String heroName = 'Superman'; // 也可以进行类型推断 `final heroName = 'Superman';`

  print('final 变量:');
  print('Current Time: $now');
  print('Hero Name: $heroName');
  // now = DateTime(2023); // 这行会报错：A final variable 'now' can only be set once.
  print('--------------------');

  // 5. `const` 关键字
  // `const` 变量是编译时常量。
  // 它的值必须在编译时就能确定，不能依赖于运行时才能确定的值。
  const double PI = 3.14159; // PI 是一个编译时常量
  const String appName = 'My Dart App'; // appName 也是一个编译时常量

  print('const 变量:');
  print('PI Value: $PI');
  print('App Name: $appName');
  // PI = 3.0; // 这行会报错：Constant variables can't be assigned a value.
  // const DateTime compileTime = DateTime.now(); // 这行会报错：Const variables must be initialized with a constant value.
  print('--------------------');

  // 比较 `final` 和 `const`
  // 编译时常量列表 (List of const values)
  const List<int> constNumbers = [1, 2, 3];
  // 运行时常量列表 (List of final values)
  final List<int> finalNumbers = [4, 5, 6];

  print('constNumbers: $constNumbers');
  print('finalNumbers: $finalNumbers');

  // 深入理解 const：
  // 如果一个 `const` 对象的所有成员都是编译时常量，那么这个对象本身也是编译时常量。
  // 且 `const` 对象是规范化的（canonicalized），意味着如果两个 `const` 对象具有相同的值，
  // 它们实际上会指向内存中的同一个对象。
  const List<int> list1 = [1, 2, 3];
  const List<int> list2 = [1, 2, 3];
  print('list1 == list2 (const): ${list1 == list2}'); // 输出 true，因为它们是同一个对象

  final List<int> list3 = [1, 2, 3];
  final List<int> list4 = [1, 2, 3];
  print('list3 == list4 (final): ${list3 == list4}'); // 输出 false，因为它们是不同的对象实例
}

// 模拟一个需要一些时间初始化的复杂对象
class HeavyResource {
  String _data;

  HeavyResource() {
    print('HeavyResource: 正在执行耗时操作...');
    // 模拟耗时操作，比如读取文件或网络请求
    Future.sync(() => _data = "数据已加载").then((_) {
      print('HeavyResource: 数据加载完成。');
    });
    // 在构造函数执行结束时，_data 可能还没有被完全初始化
  }

  String get data => _data; // Getter 确保在访问时数据是可用的

  void connect() {
    print('HeavyResource: 连接到 $_data');
  }
}

class MyController {
  // 示例 1: 延迟初始化实例变量 (Lazy Initialization of Instance Variable)
  // 这个 heavyResource 只有在第一次被访问时才会创建 HeavyResource 实例
  late final HeavyResource heavyResource = HeavyResource();

  // 示例 2: 在构造函数体内初始化非空变量 (Initializing Non-nullable Variable in Constructor Body)
  // 这里展示了如何在构造函数体内部初始化一个 `late` 变量，
  // 即使它没有在初始化列表中或声明时初始化。
  late String configSetting;
  MyController(bool isProduction) {
    if (isProduction) {
      configSetting = '生产环境配置'; // 在构造函数体内部初始化
    } else {
      configSetting = '开发环境配置';
    }
  }

  // 示例 3: 顶层 `late` 变量 (Top-level late variable)
  // 只有在第一次访问 mainConfig 时，它才会被初始化
  // late final String mainConfig = _loadConfigFromFile(); // 假设这是一个耗时操作
  // String _loadConfigFromFile() {
  //   print('正在从文件中加载配置...');
  //   return '文件配置数据';
  // }
}


// 示例 4: 无需立即初始化的非空变量 (Non-nullable variable without immediate initialization)
// late var price; // 声明 'late' 可以不立即初始化
late double price; // 推荐显式声明类型

void initPrice() {
  price = 99.99; // 在某个函数或方法中赋值
  print('价格已初始化为 $price');
}

void main() {
  print('--- main 函数开始 ---');

  // 示例 1 的使用
  print('\n-- 示例 1: 延迟初始化实例变量 --');
  final controller = MyController(false); // 此时 HeavyResource 还没有被创建
  print('controller 对象已创建，但 heavyResource 尚未初始化。');

  // 第一次访问 heavyResource，它才会被初始化
  controller.heavyResource.connect();
  controller.heavyResource.connect(); // 第二次访问时不会再重新初始化

  // 示例 2 的使用
  print('\n-- 示例 2: 构造函数体内初始化 --');
  final devController = MyController(false);
  print('开发环境配置: ${devController.configSetting}');

  final prodController = MyController(true);
  print('生产环境配置: ${prodController.configSetting}');

  // 示例 4 的使用
  print('\n-- 示例 4: 无需立即初始化的非空变量 --');
  // print(price); // 这行代码会抛出 LateInitializationError，因为 price 尚未初始化
  initPrice();
  print('当前价格: $price');

  // 演示 `LateInitializationError`
  print('\n-- 演示 `LateInitializationError` --');
  late String uninitializedVar;
  try {
    // print(uninitializedVar); // 尝试访问未初始化的 late 变量会抛出错误
    uninitializedVar = '已初始化'; // 实际使用前赋值
    print(uninitializedVar);
  } catch (e) {
    print('捕获到错误: $e');
  }

  print('\n--- main 函数结束 ---');
}