您必须理解类和该类的示例之间的区别。如果你在街上看到一辆车，即使你看不出是哪种型号或类型，你也会立刻知道那是辆车。这是因为你把你所看到的与“车”类进行比较。该类包含类似于所有汽车的。把它当作一个模板或想法。
同时，你所看到的汽车是“car”类的一个示例，因为它具有你所期望的所有属性：有人驾驶它，它有一个引擎和轮子。
所以这个类说“所有的车都有一种颜色”，这个示例说“这个特定的车是红色的”。
在oo世界中，定义类，在类内部定义类型为的字段 Color . 示例化类时（创建特定示例时），会为颜色保留内存，您可以为该特定示例指定颜色。因为这些属性是特定的，所以它们是非静态的。
静态字段和方法与所有示例共享。它们用于特定于类而不是特定示例的值。对于方法，这通常是全局助手方法（如 Integer.parseInt() ). 对于字段，它通常是常量（比如汽车类型，也就是说，有一个不经常更改的有限集合）。
为了解决您的问题，您需要示例化类的一个示例（创建一个对象），这样运行时就可以为示例保留内存（否则，不同的示例会相互覆盖，这是您不需要的）。
在您的情况下，请尝试以下代码作为起始块：

public static void main (String[] args)
{
    try
    {
        MyProgram7 obj = new MyProgram7 ();
        obj.run (args);
    }
    catch (Exception e)
    {
        e.printStackTrace ();
    }
}

// instance variables here

public void run (String[] args) throws Exception
{
    // put your code here
}

新的 main() 方法创建它所包含的类的示例（听起来很奇怪，但因为 main() 是用类而不是示例创建的，它可以这样做），然后调用示例方法( run() ).

静态字段和方法连接到类本身，而不是它的示例。如果你有课 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
    }
}

这个 static 关键字修改类中方法或变量的生命周期。一 static 方法或变量是在加载类时创建的。未声明为 static 仅当类被示例化为对象时（例如通过使用 new 接线员。
从广义上讲，类的生命周期是：
该类的源代码是通过创建模板、模式或戳记来编写的，然后可以使用这些模板、模式或戳记
使用 new 运算符使用该类将该类的示例作为实际对象，然后在处理完该对象后
销毁对象，回收它所拥有的资源，如垃圾回收期间的内存。
为了有一个应用程序的初始入口点，java采用了这样的约定：java程序必须有一个类，该类包含一个具有约定名称或特殊名称的方法。这种特殊方法称为 main() . 由于无论包含主方法的类是否已示例化，该方法都必须存在，因此 main() 方法必须用 static 修饰符，以便在加载类时 main() 方法可用。
结果是，当您通过命令行启动java应用程序时，例如 java helloworld 一系列的行动发生了。首先，启动并初始化java虚拟机。接下来，包含已编译java代码的helloworld.class文件被加载到java虚拟机中。然后java虚拟机在 helloworld 被称为 main(String [] args) . 此方法必须 static 因此，即使类实际上没有被示例化为对象，它也会存在。java虚拟机不会通过从类创建对象来创建类的示例。它只是加载类并在 main() 方法。
因此，您需要创建一个类的示例作为对象，然后可以访问该类中尚未用 static 修饰语。一旦java程序开始使用 main() 函数，然后可以使用具有 static 因为它们作为被加载的类的一部分而存在。
但是，类的那些变量和方法 main() 方法没有 static 在类的示例被创建为 main() 方法。创建对象之后，您可以使用对象的变量和方法。试图使用类中没有 static 不经过类对象的修饰符在编译时被java编译器捕获并标记为错误。

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
    }
}

让我们先分析一下你的程序。。在程序中，第一种方法是 main() ，记住这是静态方法。。。然后为该方法声明局部变量（comparecount、low、high等）。此变量的作用域仅为声明的方法，而不管它是静态方法还是非静态方法。所以你不能在这个方法之外使用这些变量。这是你犯的基本错误。
然后我们来讨论下一点。你说静电会杀了你(它可能会杀了你，但它只会给你的程序带来生命！！）首先你必须了解基本的东西静态方法只调用静态方法，并且只使用静态变量静态变量或静态方法不依赖于该类的任何示例(i、 如果你改变静态变量的任何状态，它将反映在类的所有对象中）*因此你称它为类变量或类方法。关于“static”关键字还有很多。我希望你现在明白了。首先更改变量的作用域并将其声明为静态（以便能够在静态方法中使用它）。
给你的建议是：你误解了变量和静态功能的范围。弄清楚这个。

最基本的是静态变量或静态方法在类级别。类级别的变量或方法在示例级别的方法或变量之前被加载。显然，没有加载的东西不能被使用。所以java编译器不允许在运行时处理的事情在编译时解决。这就是为什么它给你的错误非静态的东西不能从静态上下文中引用。您只需要了解类级范围、示例级范围和本地范围。

要从静态方法访问它们，它们必须是静态成员变量，如下所示：

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

现在可以在方法中添加/使用示例

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

我会尽力向你解释静态的东西。首先，静态变量不属于类的任何特定示例。它们以类的名称被识别。静态方法不再属于任何特定示例。它们只能访问静态变量。假设您调用myclass.mymethod（），mymethod是一个静态方法。如果在方法中使用非静态变量，它究竟如何知道要使用哪些变量？这就是为什么只能从静态方法使用静态变量。我再说一遍，它们不属于任何特定的示例。

首先要知道类的示例和类本身之间的区别。类对某些属性以及在这些属性的上下文中整体的行为进行建模。示例将为这些属性定义特定的值。
任何绑定到static关键字的内容都可以在类的上下文中使用，而不是在类示例的上下文中使用
作为上述的推论
方法中的变量不能是静态的
静态字段和方法必须使用类名调用，例如myprogram7.main（…）
静态字段/方法的生存期等同于应用程序的生存期
e、 比如说，汽车具有属性颜色，表现出“运动”的行为。这辆车的一个例子就是一辆时速25公里的红色大众甲壳虫。
现在汽车的静态特性是道路上车轮的数量（4），这将适用于所有汽车。
hth公司

在调用示例方法或示例变量之前，它需要一个对象（示例）。当从静态方法调用示例变量时，编译器不知道该变量属于哪个对象。因为静态方法没有对象（总是只有一个副本）。当您从示例方法调用示例变量或示例方法时，它引用 this 对象。这意味着变量属于创建的任何对象，每个对象都有自己的示例方法和变量副本。
静态变量标记为 static 示例变量没有特定的关键字。

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

class StaticTest {

      static int a;
      int b;
      int c;
}

现在我们可以看到“statictest”类有3个字段，但是实际上不存在b，c成员变量，但是为什么呢？？？。好吧，让我看看。这里b，c是示例变量，因为示例变量在创建对象时获取内存。所以这里b，c还没有记忆。这就是为什么不存在b，c。所以只有a的存在。对于classloader，它只有一个关于a的信息。类加载器还不能识别b，c，因为它是obj