The first thing is to know the difference between an instance of a class, and the class itself. A class models certain properties, and the behaviour of the whole in the context of those properties. An instance will define specific values for those properties. Anything bound to the static keyword is available in the context of the class rather than in the context of an instance of the class As a corollary to the above variables within a method can not be static static fields, and methods must be invoked using the class-name e.g. MyProgram7.main(...) The lifetime of a static field/method is equivalent to the lifetime of your application

如。 例如，汽车具有属性颜色，并表现出行为“运动”。 以25公里每小时的速度行驶的红色大众甲壳虫为例。

现在，汽车的静态属性将是道路上的车轮数量(4)，这将适用于所有汽车。

HTH

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

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 {
  ...

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

|*| 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);
        }
    }
}

现在您可以在方法中添加/使用实例with

public class Myprogram7 {

  Scanner scan;
  int compareCount = 0;
  int low = 0;
  int high = 0;
  int mid = 0;  
  int key = 0;  
  Scanner temp;  
  int[]list;  
  String menu, outputString;  
  int option = 1;  
  boolean found = false;  

  private void readLine() {

  }

  private void findkey() {

  }

  private void printCount() {

  }
  public static void main(String[] args){

    Myprogram7 myprg=new Myprogram7();
    myprg.readLine();
    myprg.findkey();
    myprg.printCount();
  }
}

这是因为您不创建模型类的实例，您必须在每次使用非静态方法或变量时创建实例。

你可以很容易地修复这个，看看下面的图片

没有创建类的实例

我的模型类文件

通过创建实例，然后使用类的非静态方法或变量，很容易出错

static关键字修改类中方法或变量的生命周期。静态方法或变量是在装入类时创建的。未声明为静态的方法或变量仅在类实例化为对象(例如使用new操作符)时创建。

广义来说，类的生命周期是:

类的源代码是创建模板或 图案或邮票，然后可以使用 使用类创建一个带有new操作符的对象，使类的实例作为实际对象，然后在处理对象时 在垃圾收集期间销毁对象，回收它所持有的资源，例如内存。

为了为应用程序提供一个初始入口点，Java采用了这样的约定:Java程序必须有一个类，该类包含一个具有一致同意的或特殊名称的方法。这个特殊的方法称为main()。因为无论包含main方法的类是否已被实例化，方法都必须存在，所以main()方法必须用静态修饰符声明，以便一旦装入类，main()方法就可用。

The result is that when you start your Java application by a command line such as java helloworld a series of actions happen. First of all a Java Virtual Machine is started up and initialized. Next the helloworld.class file containing the compiled Java code is loaded into the Java Virtual Machine. Then the Java Virtual Machine looks for a method in the helloworld class that is called main(String [] args). this method must be static so that it will exist even though the class has not actually been instantiated as an object. The Java Virtual Machine does not create an instance of the class by creating an object from the class. It just loads the class and starts execution at the main() method.

因此，您需要创建类的实例作为对象，然后可以访问未使用静态修饰符声明的类的方法和变量。一旦您的Java程序开始使用main()函数，您就可以使用任何具有static修饰符的变量或方法，因为它们作为正在加载的类的一部分存在。

However, those variables and methods of the class which are outside of the main() method which do not have the static modifier can not be used until an instance of the class has been created as an object within the main() method. After creating the object you can then use the variables and methods of the object. An attempt to use the variables and methods of the class which do not have the static modifier without going through an object of the class is caught by the Java compiler at compile time and flagged as an error.

import java.io.*;

class HelloWorld {
    int myInt;      // this is a class variable that is unique to each object
    static int myInt2;  // this is a class variable shared by all objects of this class

    static void main (String [] args) {
        // this is the main entry point for this Java application
        System.out.println ("Hello, World\n");
        myInt2 = 14;    // able to access the static int
        HelloWorld myWorld = new HelloWorld();
        myWorld.myInt = 32;   // able to access non-static through an object
    }
}