本文共 7897 字，大约阅读时间需要 26 分钟。
具体来说，我正在尝试以下代码：
package hello;public class Hello { Clock clock = new Clock(); public void main(String args[]) { clock.sayTime(); }} 但是它给了错误
无法在静态方法main中访问非静态字段
因此，我将clock的声明更改为：
static Clock clock = new Clock();
而且有效。 将关键字放在声明之前是什么意思？ 就可以对对象执行的操作而言，它将确切地执行和/或限制什么？
Java中的static关键字表示变量或函数在该类的所有实例之间共享，因为它属于类型 ，而不是实际对象本身。
因此，如果您有一个变量： private static int i = 0; 并且在一个实例中将其递增（ i++ ），更改将反映在所有实例中。 i现在在所有情况下都是1。
可以使用静态方法而无需实例化对象。
static关键字表示某项（字段，方法或嵌套类）与该类型有关，而不是与该类型的任何特定实例有关。 因此，例如，在没有Math类的任何实例的情况下调用Math.sin(...) ，实际上您无法创建Math类的实例。
有关更多信息，请参见的 。
边注
不幸的是， Java 允许您访问静态成员，就像它们是实例成员一样，例如
// Bad code!Thread.currentThread().sleep(5000);someOtherThread.sleep(5000);
这看起来好像sleep是实例方法，但实际上是静态方法-它总是使当前线程处于睡眠状态。 更好的做法是在调用代码中明确指出：
// ClearerThread.sleep(5000);
我对“ helper”类中的静态方法（仅在可能的情况下）很喜欢。
调用类无需创建辅助类的另一个成员（实例）变量。 您只需调用助手类的方法。 辅助类也得到了改进，因为您不再需要构造函数，也不需要成员（实例）变量。
可能还有其他优点。
静态成员的基本用法...
public class Hello{ // value / method public static String staticValue; public String nonStaticValue;}class A{ Hello hello = new Hello(); hello.staticValue = "abc"; hello.nonStaticValue = "xyz";}class B{ Hello hello2 = new Hello(); // here staticValue = "abc" hello2.staticValue; // will have value of "abc" hello2.nonStaticValue; // will have value of null} 这样，您就可以在所有类成员中共享值，而无需将类实例Hello发送给其他类。 而静态的则不需要创建类实例。
Hello hello = new Hello();hello.staticValue = "abc";
您可以按类名称调用静态值或方法：
Hello.staticValue = "abc";
关键字static用于表示字段或方法属于类本身而不是实例。 使用您的代码，如果对象Clock是静态的，则Hello类的所有实例将共享该Clock数据成员（字段）。 如果将其设为非静态，则Hello每个单独实例都可以具有唯一的Clock字段。
问题是您在类Hello添加了main方法，以便您可以运行代码。 这里的问题是main方法是静态的，因此，它不能引用非静态字段或其中的方法。 您可以通过两种方式解决此问题：
Hello类的所有字段和方法设为静态，以便可以在main方法内部引用它们。 这确实不是一件好事（或将字段和/或方法设为静态的错误原因） Hello类的实例，并首先访问它们的所有字段和方法。 对您来说，这意味着对代码进行以下更改：
package hello;public class Hello { private Clock clock = new Clock(); public Clock getClock() { return clock; } public static void main(String args[]) { Hello hello = new Hello(); hello.getClock().sayTime(); }} main()是一个静态方法，它具有两个基本限制：
this()和super()不能在静态上下文中使用。
class A { int a = 40; //non static public static void main(String args[]) { System.out.println(a); } }输出：编译时错误
静态变量只能在静态方法中访问，因此，当我们声明静态变量时，那些getter和setter方法将是静态方法
静态方法是一个类级别，我们可以使用类名称进行访问
以下是静态变量获取器和设置器的示例：
public class Static { private static String owner; private static int rent; private String car; public String getCar() { return car; } public void setCar(String car) { this.car = car; } public static int getRent() { return rent; } public static void setRent(int rent) { Static.rent = rent; } public static String getOwner() { return owner; } public static void setOwner(String owner) { Static.owner = owner; }} 在Java中， static关键字可以简单地视为指示以下内容：
“不考虑或与任何特定情况无关”
如果您以这种方式考虑static ，那么会更容易理解它在遇到各种上下文中的用法：
static字段是属于该类而不是任何特定实例的字段
static方法是没有this概念的方法; 它是在类上定义的，除非对该类传递了引用，否则它不知道该类的任何特定实例
static成员类是一个嵌套类，对它的封闭类的实例没有任何概念或了解（除非将对封闭类实例的引用传递给它）
要添加到现有答案中，让我尝试一下图片：
所有储蓄账户的利率为2％。 因此它是静态的 。
余额应为个人 ，因此不是静态的。
Java中的静态：
静态是非访问修饰符。 static关键字属于该类，而不是该类的实例。 可用于将变量或方法附加到类。
静态关键字可以用于：
方法
变量
嵌套在另一个类中的类
初始化块
不能用于：
类（未嵌套）
建设者
介面
方法本地内部类（与嵌套类不同）
内部类方法
实例变量
局部变量
例：
想象以下示例，该示例具有一个名为count的实例变量 ，该实例变量在构造函数中递增：
package pkg;class StaticExample { int count = 0;// will get memory when instance is created StaticExample() { count++; System.out.println(count); } public static void main(String args[]) { StaticExample c1 = new StaticExample(); StaticExample c2 = new StaticExample(); StaticExample c3 = new StaticExample(); }} 输出：
1 1 1
由于实例变量在创建对象时会获得内存，因此每个对象都将具有实例变量的副本，如果递增，则不会反映到其他对象。
现在，如果我们将实例变量计数更改为静态变量，那么程序将产生不同的输出：
package pkg;class StaticExample { static int count = 0;// will get memory when instance is created StaticExample() { count++; System.out.println(count); } public static void main(String args[]) { StaticExample c1 = new StaticExample(); StaticExample c2 = new StaticExample(); StaticExample c3 = new StaticExample(); }} 输出：
1 2 3
在这种情况下，静态变量将仅获得一次内存，如果任何对象更改了静态变量的值，它将保留其值。
静态与最终：
在整个执行过程中，声明为final和static的全局变量保持不变。 因为，静态成员存储在类内存中，并且在整个执行过程中仅加载一次。 它们是该类的所有对象共有的。 如果将静态变量声明为final，则任何对象都无法更改其值，因为它是final。 因此，声明为final和static的变量有时称为常量。 接口的所有字段都称为常量，因为默认情况下它们是最终的和静态的。
图片资源：
static成员属于该类，而不是特定的实例。
这意味着，即使您创建了该类的一百万个实例，也没有创建任何static实例 ，但仅存在一个static字段实例 [1] 。 它将被所有实例共享。
由于static方法也不属于特定实例，因此它们不能引用实例成员。 在给出的示例中， main不知道应引用Hello类的哪个实例（以及Clock类的哪个实例）。 static成员只能引用static成员。 实例成员当然可以访问static成员。
Of course, static members can access instance members through an object reference . 当然， static成员可以通过对象引用访问实例成员。
例：
public class Example { private static boolean staticField; private boolean instanceField; public static void main(String[] args) { // a static method can access static fields staticField = true; // a static method can access instance fields through an object reference Example instance = new Example(); instance.instanceField = true; } [1]：根据运行时的特性，每个ClassLoader或AppDomain或线程可以是一个，但是那不是重点。
静态意味着您不必创建类的实例即可使用与该类关联的方法或变量。 在您的示例中，您可以调用：
Hello.main(new String[]()) //main(...) is declared as a static function in the Hello class
直接，而不是：
Hello h = new Hello();h.main(new String[]()); //main(...) is a non-static function linked with the "h" variable
从静态方法（属于一个类）内部，您不能访问任何非静态的成员，因为它们的值取决于您对类的实例化。 作为实例成员的非静态Clock对象对于Hello类的每个实例将具有不同的值/引用，因此您无法从该类的静态部分访问它。
这意味着Hello中只有一个“ clock”实例，而“ Hello”类的每个单独实例中没有一个实例，或者更多，因此，这意味着在Hello的所有实例中将有一个共同共享的“ clock”引用。 “ Hello”类。
因此，如果您要在代码中的任何位置进行“新Hello”操作：A-在第一种情况下（更改之前，不使用“静态”），每次调用“新Hello”都会产生一个新时钟，但是B-在第二种情况下（更改后，使用“静态”），每个“新Hello”实例仍将共享并使用最初创建的初始且相同的“时钟”引用。
除非您需要在main之外的某个地方设置“时钟”，否则它将同样有效：
package hello;public class Hello{ public static void main(String args[]) { Clock clock=new Clock(); clock.sayTime(); }} 静态使时钟成员成为类成员，而不是实例成员。 如果没有static关键字，则需要创建Hello类的实例（具有时钟成员变量）-例如
Hello hello = new Hello();hello.clock.sayTime();
静态方法不使用其定义的类的任何实例变量。关于区别的很好解释可以在上找到
可以将字段分配给类或类的实例。 默认情况下，字段是实例变量。 通过使用static该字段成为一个类变量，因此只有一个clock 。 如果您在一个地方进行更改，则随处可见。 实例变量彼此独立更改。
到目前为止，该讨论都忽略了类加载器的考虑。 严格来说，对于给定的classloader ，Java静态字段在类的所有实例之间共享。
也可以想到静态成员没有“ this”指针。 它们在所有实例之间共享。
了解静态概念
public class StaticPractise1 { public static void main(String[] args) { StaticPractise2 staticPractise2 = new StaticPractise2(); staticPractise2.printUddhav(); //true StaticPractise2.printUddhav(); /* false, because printUddhav() is although inside StaticPractise2, but it is where exactly depends on PC program counter on runtime. */ StaticPractise2.printUddhavsStatic1(); //true staticPractise2.printUddhavsStatic1(); /*false, because, when staticPractise2 is blueprinted, it tracks everything other than static things and it organizes in its own heap. So, class static methods, object can't reference */ }} 二等
public class StaticPractise2 { public static void printUddhavsStatic1() { System.out.println("Uddhav"); } public void printUddhav() { System.out.println("Uddhav"); }} 在运行某些项目时，首先要加载静态内容（变量，方法，块..）。
运行此项目时，首先加载主方法。 因为它是static method 。 然后，它看起来是对象"a" object 。但是对象a尚未定义。 因为它是非静态的。 然后出现此错误。
//Here is an example public class StaticClass { static int version; public void printVersion() { System.out.println(version); }}public class MainClass { public static void main(String args[]) { StaticClass staticVar1 = new StaticClass(); staticVar1.version = 10; staticVar1.printVersion() // Output 10 StaticClass staticVar2 = new StaticClass(); staticVar2.printVersion() // Output 10 staticVar2.version = 20; staticVar2.printVersion() // Output 20 staticVar1.printVersion() // Output 20 }} 转载地址：http://cwcnb.baihongyu.com/