访问修饰符：

public（默认）：

• 成员默认是 public，可以在任何地方访问。

  class MyClass {
        
        
    int publicField = 1; // public成员
  }
  

private：

• 通过使用下划线（_）前缀，将成员标记为私有，只能在类内部访问。

  class MyClass {
        
        
    int _privateField = 2; // private成员
  }
  

library（库私有）：

• 使用 library 关键字定义一个库私有成员，只有在定义它的库内部可以访问。

  library my_library;
  
  class MyClass {
        
        
    int _libraryPrivateField = 3; // 库私有成员
  }
  

可变性修饰符：

final：

• final 修饰的成员只能被赋值一次。

  class MyClass {
        
        
    final int finalField = 4; // final成员
  }
  

const：

• const 修饰的成员是编译时常量。

  class MyClass {
        
        
    static const int constField = 5; // const成员
  }
  

类型修饰符：

static：

• static 成员属于类本身，而不是类的实例。

  class MyClass {
        
        
    static int staticField = 6; // static成员
  }
  

late：

• late 用于延迟初始化的变量，必须是 final 或非空的。

  class MyClass {
        
        
    late final int lateField; // late final成员，延迟初始化
    MyClass() {
        
        
      lateField = 7; // 在构造函数中初始化
    }
  }
  

var：

• var 声明一个变量，类型由编译器自动推断。

  var variable = 'I am a string'; // var变量，类型自动推断为String
  

dynamic：

• dynamic 变量可以是任何类型，类型检查发生在运行时。

  dynamic dynamicVar = 8; // dynamic变量，可以是任何类型
  dynamicVar = 'Now I am a string'; // 类型可以更改
  

其他关键字：

abstract：

• 用于定义抽象类或抽象方法。

  abstract class AbstractClass {
        
        
    void abstractMethod(); // 抽象方法，没有实现
  }
  

typedef：

• 用于定义函数类型的别名。

  typedef NumberGetter = int Function();
  

extension：

• 用于为现有类型添加功能。

  extension MyStringExtension on String {
        
        
    int wordCount() => split(' ').length;
  }
  

covariant：

• covariant 用于方法参数，表示子类中可以使用比父类更具体的类型。

  class Animal {
        
        
    void makeSound() {
        
        }
  }
  
  class Dog extends Animal {
        
        
    @override
    void makeSound() {
        
        }
  }
  
  class NoisyDog extends Dog {
        
        
    @override
    void makeSound() {
        
        
      // Do something more noisy
    }
  }
  
  class Zoo {
        
        
    void feedAnimal(covariant Animal animal) {
        
        
      animal.makeSound();
    }
  }
  

on：

• 用于 mixin 声明，指定 mixin 可以应用于哪些类型的类。

  mixin LoggerMixin on Object {
        
        
    void log(String msg) {
        
        
      print(msg);
    }
  }
  

operator：

• 用于定义或重载操作符。

  class Vector {
        
        
    int x, y;
    Vector(this.x, this.y);
  
    Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  }
  

factory：

• factory 构造函数返回一个实例，可能不是新创建的对象。

  class Logger {
        
        
    final String name;
    bool mute = false;
  
    // _cache是库私有的，因为它的名字前面有_
    static final Map<String, Logger> _cache = <String, Logger>{
        
        };
  
    factory Logger(String name) {
        
        
      return _cache.putIfAbsent(name, () => Logger._internal(name));
    }
  
    Logger._internal(this.name);
  
    void log(String msg) {
        
        
      if (!mute) {
        
        
        print('$name: $msg');
      }
    }
  }
  

额外修饰符或关键字：

rethrow：

• 用于重新抛出当前捕获的异常。

  try {
        
        
    throw FormatException('Bad format');
  } catch (e) {
        
        
    rethrow; // 重新抛出异常
  }
  

await：

• 用于异步操作，等待异步任务完成。

  Future<void> fetchData() async {
        
        
    var data = await fetchFromServer();
    print(data);
  }
  

async：

• 用于声明异步函数。

  Future<String> fetchFromServer() async {
        
        
    await Future.delayed(Duration(seconds: 2));
    return 'Data from server';
  }
  

yield：

• 用于生成器函数，返回一个值给调用者。

  Iterable<int> countTo(int max) sync* {
        
        
    for (var i = 0; i <= max; i++) {
        
        
      yield i;
    }
  }
  

super：

• 用于调用父类的方法或构造函数。

  class Parent {
        
        
    void sayHello() {
        
        
      print('Hello from Parent');
    }
  }
  
  class Child extends Parent {
        
        
    @override
    void sayHello() {
        
        
      super.sayHello(); // 调用父类的方法
      print('Hello from Child');
    }
  }