Flutter 如何从dart中的其他类访问公共静态变量？

我无法从其他类访问公共静态布尔值，例如，我的

StudyjiosListviewScreen

类中有一个布尔值

isFull

，如图所示：

class StudyjiosListviewScreen extends StatefulWidget {

  @override
  _StudyjiosListviewScreenState createState() => _StudyjiosListviewScreenState();
}

class _StudyjiosListviewScreenState extends State<StudyjiosListviewScreen> {
  static bool isFull = false;
 ...

但是当我尝试使用布尔值

isFull

时，如下所示：

StudyjiosListviewScreen listviewScreen = StudyjiosListviewScreen();

if (listviewScreen.isFull) {

...

---

我犯了一个错误。我已经在

联合研究jio

类的文件中导入了

研究jiosListViewScreen

类的文件。

这是因为

研究jiosListViewScreen

和

研究jiosListViewScreenState

是两个不同的类

---

您试图访问的静态变量

isFull

属于后一个变量，您试图通过创建第一个变量的实例来访问它。如果它是类

StudyjiosListviewScreen

的一个静态变量，您可以访问它，而无需像这样创建该类的实例

StudyjiosListviewScreen.isFull

，如果我正确理解您的问题，并遵循我在评论中提出的建议，下面是一个共享变量的代码示例，以及将其值从父类更改为两个类的方法：

class VariableSharing62951032 extends StatefulWidget {
  @override
  _VariableSharing62951032State createState() => _VariableSharing62951032State();
}

class _VariableSharing62951032State extends State<VariableSharing62951032> {
  bool isFull = false;

  @override
  Widget build(BuildContext context) {
    return Column(
      children: <Widget>[
        ClassA62951032(isFull: isFull, swapIsFull: swapIsFull,),
        ClassB62951032(isFull: isFull, swapIsFull: swapIsFull,),
      ],
    );
  }

  void swapIsFull(){
    setState(() {
      isFull = !isFull;
    });
  }
}

class ClassA62951032 extends StatefulWidget {
  final bool isFull;
  final Function swapIsFull;

  ClassA62951032({
    this.isFull,
    this.swapIsFull
  });

  @override
  _ClassA62951032State createState() => _ClassA62951032State();
}

class _ClassA62951032State extends State<ClassA62951032> {
  @override
  Widget build(BuildContext context) {
    return Column(
      children: <Widget>[
        Text('Class A'),
        Text(widget.isFull.toString()),
        RaisedButton(
          child: Text('Swap isFull'),
          onPressed: () => widget.swapIsFull(),
        ),
      ],
    );
  }
}

class ClassB62951032 extends StatefulWidget {
  final bool isFull;
  final Function swapIsFull;

  ClassB62951032({
    this.isFull,
    this.swapIsFull
  });

  @override
  _ClassB62951032State createState() => _ClassB62951032State();
}

class _ClassB62951032State extends State<ClassB62951032> {
  @override
  Widget build(BuildContext context) {
    return Column(
      children: <Widget>[
        Text('Class B'),
        Text(widget.isFull.toString()),
        RaisedButton(
          child: Text('Swap isFull'),
          onPressed: () => widget.swapIsFull(),
        ),
      ],
    );
  }
}

class VariableSharing62951032扩展了StatefulWidget{
@凌驾
_VariableSharing62951032State createState（）=>_VariableSharing62951032State（）；
}
类_variableSharing62951032状态扩展状态{
bool isFull=false；
@凌驾
小部件构建（构建上下文）{
返回列(
儿童：[
ClassA62951032（已满：已满，已满：已满，），
类别B62951032（已满：已满，已满：已满，），
],
);
}
无效{
设置状态（）{
isFull=！isFull；
});
}
}
类ClassA62951032扩展了StatefulWidget{
最终目标已满；
最终功能完整；
类别A62951032({
这个是满的，
这是斯瓦皮斯满
});
@凌驾
_ClassA62951032State createState（）=>类A62951032State（）；
}
类_classA62951032状态扩展状态{
@凌驾
小部件构建（构建上下文）{
返回列(
儿童：[
文本（“A类”），
文本（widget.isFull.toString（）），
升起的按钮(
子项：文本（'Swap isFull'），
onPressed:（）=>widget.swapIsFull（），
),
],
);
}
}
类ClassB62951032扩展了StatefulWidget{
最终目标已满；
最终功能完整；
类别B62951032({
这个是满的，
这是斯瓦皮斯满
});
@凌驾
_ClassB62951032State createState（）=>ClassB62951032State（）；
}
类_classb62951032状态扩展状态{
@凌驾
小部件构建（构建上下文）{
返回列(
儿童：[
文本（“B类”），
文本（widget.isFull.toString（）），
升起的按钮(
子项：文本（'Swap isFull'），
onPressed:（）=>widget.swapIsFull（），
),
],
);
}
}

在类之间共享变量和方法在颤振中是一件大事

首先，你以错误的方式传递它。该变量保存在state小部件中，该小部件定义为private。 所以，或者您将其定义为public，然后传递与您的状态相关联的密钥，或者您完全更改方法。我不喜欢传递密钥，这对生产不好，因此我将使用提供者为您提供一个更好的示例：

将提供程序库添加到pubspec.yaml：

provider: ^4.3.1 // Or latest version

创建一个可以保存该值的类：

class valuesHelper {

  //In this class we are storing global, dynamic values


  bool _isSeen;

  valuesHelper() {
    this._isSeen = false;
  }

  void setValue(bool value) {
    this._isSeen = value;
  }
  
  bool getValue(){
    return this._isSeen;
  }
}

现在用提供程序包装main并传递valuesHelper（）

现在，在任何需要的地方调用Provider.of（context）

//Somwhere in your code when you have access to context:
ValueHelper helper = Provider.of<valueHelper>(context);

helper.setValue(true);



//Somwhereelse in your code when you have access to context:
ValueHelper helper = Provider.of<valueHelper>(context);

bool theValueIWant = helper.getValue();

//当您可以访问上下文时，在代码中的位置：
ValueHelper=Provider.of（上下文）；
helper.setValue（true）；
//SOM当您有权访问上下文时，代码中的其他位置：
ValueHelper=Provider.of（上下文）；
bool theValueIWant=helper.getValue（）；

---

如果你有异步的东西和巨大的状态管理集团，那就更好了，更有趣了，但是对于这类东西，提供程序已经足够了。

如果你有一个变量想要在类之间共享，那么将该值和可能修改它的方法传递给你提到的两个类会更有意义，从父类或应用程序中的其他地方。我尝试过使用

StudyjiosListviewScreen.isFull

，但它也不起作用。正如我提到的，只有当

isFull

是class

StudyjiosListviewScreen

的静态变量时，这才可能。不是该类的变量。

//Somwhere in your code when you have access to context:
ValueHelper helper = Provider.of<valueHelper>(context);

helper.setValue(true);



//Somwhereelse in your code when you have access to context:
ValueHelper helper = Provider.of<valueHelper>(context);

bool theValueIWant = helper.getValue();