在 BLoC 架构中，每个状态是否应该是一个独立的类可以根据具体的情况来考虑。通常情况下，每个状态都应该是一个独立的类，这样可以更好地封装并描述应用程序的不同状态。

下面是一个示例，展示了如何在 BLoC 中创建独立的状态类：

首先，创建一个抽象类来表示不同的状态：

abstract class CounterState {}

class InitialState extends CounterState {}

class LoadingState extends CounterState {}

class LoadedState extends CounterState {
  final int count;
  
  LoadedState(this.count);
}

class ErrorState extends CounterState {
  final String error;
  
  ErrorState(this.error);
}

然后，创建一个 BLoC 类来处理状态和业务逻辑：

class CounterBloc {
  final _counterStateController = StreamController();
  
  Stream get counterStateStream => _counterStateController.stream;
  
  void fetchCount() async {
    _counterStateController.add(LoadingState());
    
    try {
      // 模拟异步获取计数
      await Future.delayed(Duration(seconds: 1));
      
      int count = 10; // 假设获取到的计数是 10
      _counterStateController.add(LoadedState(count));
    } catch (error) {
      _counterStateController.add(ErrorState(error.toString()));
    }
  }
  
  void dispose() {
    _counterStateController.close();
  }
}

在这个示例中，我们定义了四个不同的状态类：InitialState、LoadingState、LoadedState 和 ErrorState。每个状态类都可以携带一些附加信息，例如计数值、错误信息等。

BLoC 类（CounterBloc）中有一个用于管理状态的 StreamController。当调用 fetchCount 方法时，我们首先向流中添加一个 LoadingState 对象，然后模拟异步获取计数值，根据结果向流中添加相应的状态对象。

在使用 BLoC 类的界面或其他地方，可以通过监听 counterStateStream 来获取最新的状态，并根据不同的状态来更新界面的显示。

void main() {
  final counterBloc = CounterBloc();
  
  counterBloc.counterStateStream.listen((state) {
    if (state is InitialState) {
      // 处理初始状态
    } else if (state is LoadingState) {
      // 处理加载状态
    } else if (state is LoadedState) {
      // 处理加载完成状态，并更新界面显示计数值
      print(state.count);
    } else if (state is ErrorState) {
      // 处理错误状态，并显示错误信息
      print(state.error);
    }
  });
  
  counterBloc.fetchCount();
  
  // 清理资源
  counterBloc.dispose();
}

在这个示例中，我们监听了 counterStateStream，并根据不同的状态来执行相应的逻辑。在 fetchCount 方法中，我们模拟了异步获取计数值的过程，并根据结果向流中添加了不同的状态对象。

总结来说，每个状态都应该是一个独立的类，这样可以更好地封装并描述应用程序的不同状态。通过使用不同的状态类，可以更清晰地管理和处理不同的状态，并在界面或其他地方根据状态来更新显示。