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

在这个程序中，你想使用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);
    }
}

最基本的事情是静态变量或静态方法是在类级别。类级变量或方法在实例级方法或变量之前加载。显然，没有加载的东西是不能使用的。所以java编译器不让在运行时处理的事情在编译时解决。这就是为什么它会给你错误非静态的东西不能从静态上下文中引用。你只需要阅读类级作用域、实例级作用域和局部作用域。

在Java编程语言中，关键字static指示特定成员属于类型本身，而不是该类型的实例。

这意味着只创建了该静态成员的一个实例，该类的所有实例都共享该实例。

如果你想使用int count = 0;在static void main()中，count变量必须声明为static

static int count = 0;

静态字段和方法连接到类本身，而不是它的实例。如果你有一个类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关键字修改类中方法或变量的生命周期。静态方法或变量是在装入类时创建的。未声明为静态的方法或变量仅在类实例化为对象(例如使用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
    }
}