我写了这样的测试代码:

class MyProgram
{
    int count = 0;
    public static void main(String[] args)
    {
        System.out.println(count);
    }
}

但它给出了以下错误:

Main.java:6: error: non-static variable count cannot be referenced from a static context
        System.out.println(count);
                           ^

我如何让我的方法识别我的类变量?


当前回答

静态字段和方法连接到类本身,而不是它的实例。如果你有一个类a,一个“正常”(通常称为实例)方法b和一个静态方法c,并且你为你的类a创建了一个实例a,那么对A.c()和a.b()的调用是有效的。方法c()不知道连接的是哪个实例,因此它不能使用非静态字段。

解决方案是要么使字段静态,要么使方法非静态。你的主要内容可以是这样的:

class Programm {

    public static void main(String[] args) {
        Programm programm = new Programm();
        programm.start();
    }

    public void start() {
        // can now access non-static fields
    }
}

其他回答

为了能够从静态方法中访问它们,它们需要是静态成员变量,如下所示:

public class MyProgram7 {
  static Scanner scan = new Scanner(System.in);
  static int compareCount = 0;
  static int low = 0;
  static int high = 0;
  static int mid = 0;  
  static int key = 0;  
  static Scanner temp;  
  static int[]list;  
  static String menu, outputString;  
  static int option = 1;  
  static boolean found = false;

  public static void main (String[]args) throws IOException {
  ...

ClassLoader负责加载类文件。让我们看看当我们编写自己的类时会发生什么。

示例1:

class StaticTest {

      static int a;
      int b;
      int c;
}

现在我们可以看到类“StaticTest”有3个字段。但实际上不存在b c成员变量。但是为什么??好的,让我看看。这里b c是实例变量。因为实例变量在对象创建时获得内存。所以这里b c还没有内存。这就是不存在b c的原因。所以只有a的存在。 对于ClassLoader,它只有一个关于a的信息。ClassLoader还不能识别b,c,因为它的对象还没有实例化。

让我们看另一个例子: 示例2:

class StaticTest {

      public void display() {
          System.out.println("Static Test");
      }


      public static void main(String []cmd) {

             display();       
      }

}

现在如果我们尝试编译这段代码,编译器会给出CE错误。 不能从静态上下文中引用非静态方法display()。

对于ClassLoader,它看起来是这样的:

class StaticTest {

      public static void main(String []cmd) {

             display();       
      }

}

在例2中,CE错误是因为我们从静态上下文调用非静态方法。因此ClassLoader不可能在编译时识别方法display()。因此会发生编译时错误。

对于所有初学者来说,解释静态关键词有点困难。 当你更多地使用类和对象时,你会清楚地了解它。

|*| Static:静态项可以用类名调用 如果你在代码中观察,有些函数是直接用类名调用的,比如

NamCls.NamFnc();

System.out.println();

这是因为NamFnc和println将在它们之前使用关键字static来声明。

|*|非静态:非静态项目可以用类变量调用 如果它不是静态的,你需要类的一个变量, 在类变量和后面加上点 然后调用function。

NamCls NamObjVar = new NamCls();
NamObjVar.NamFnc();

下面的代码简洁地解释了你

类中的静态和非静态函数:

public class NamCls
{
    public static void main(String[] args)
    {
        PlsPrnFnc("Tst Txt");

        NamCls NamObjVar = new NamCls();
        NamObjVar.PrnFnc("Tst Txt");
    }

    static void PlsPrnFnc(String SrgPsgVal)
    {
        System.out.println(SrgPsgVal);
    }

    void PrnFnc(String SrgPsgVal)
    {
        System.out.println(SrgPsgVal);
    }
}

类中的静态类和非静态类:

public class NamCls
{
    public static void main(String[] args)
    {
        NamTicCls NamTicVaj = new NamTicCls();
        NamTicVaj.PrnFnc("Tst Txt");

        NamCls NamObjVar = new NamCls();
        NamNicCls NamNicVar = NamObjVar.new NamNicCls();
        NamNicVar.PrnFnc("Tst Txt");
    }

    static class NamTicCls
    {
        void PrnFnc(String SrgPsgVal)
        {
            System.out.println(SrgPsgVal);
        }
    }

    class NamNicCls
    {
        void PrnFnc(String SrgPsgVal)
        {
            System.out.println(SrgPsgVal);
        }
    }
}

在这个程序中,你想使用count,所以将count方法声明为静态方法

class MyProgram<br>
{
    int count = 0;
    public static void main(String[] args)
    {
        System.out.println(count);
    }
}

您可以将此方法声明为公共私有并受保护。如果使用此方法,则可以创建安全应用程序。

class MyProgram
{
    static int count = 0;
    public static void main(String[] args)
    {
        System.out.println(count);
    }
}

Before you call an instance method or instance variable It needs a object(Instance). When instance variable is called from static method compiler doesn't know which is the object this variable belongs to. Because static methods doesn't have an object (Only one copy always). When you call an instance variable or instance methods from instance method it refer the this object. It means the variable belongs to whatever object created and each object have it's own copy of instance methods and variables.

静态变量被标记为静态,实例变量没有特定的关键字。