具体来说，我正在尝试以下代码:
package hello;
public class Hello {
Clock clock = new Clock();
public static void main(String args[]) {
clock.sayTime();
}
}
但是它给出了错误
不能访问静态方法主中的非静态字段
所以我把时钟的声明改为这样:
static Clock clock = new Clock();
这招奏效了。将该关键字放在声明之前意味着什么?它究竟会做什么和/或限制可以对该对象做什么?
当前回答
字段可以分配给类或类的实例。默认情况下，字段是实例变量。通过使用static，字段变成了类变量，因此有且只有一个时钟。如果你在一个地方做了改动，它就会随处可见。实例变量的改变是彼此独立的。
其他回答
Java中的静态:
Static是一个非访问修饰符。 static关键字属于该类的类的实例。 可用于将变量或方法附加到类。
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:
The global variable which is declared as final and static remains unchanged for the whole execution. Because, Static members are stored in the class memory and they are loaded only once in the whole execution. They are common to all objects of the class. If you declare static variables as final, any of the objects can’t change their value as it is final. Therefore, variables declared as final and static are sometimes referred to as Constants. All fields of interfaces are referred as constants, because they are final and static by default.
图片来源:最终静态
这里有一个问题是关于这个概念中“静态”一词的选择。这个问题已经解决了，但我认为词源问题还没有明确解决。所以…
这是由于关键字重用，从C开始。
考虑C语言中的数据声明(在函数体中):
void f() {
int foo = 1;
static int bar = 2;
:
}
变量foo在输入函数时在堆栈上创建(并在函数终止时销毁)。相比之下，bar总是在那里，所以在普通英语中它是“静态的”——它不会去任何地方。
Java和类似的语言对数据有相同的概念。数据可以为类的每个实例(每个对象)分配，也可以为整个类分配一次。因为Java的目标是为C/ c++程序员提供熟悉的语法，所以这里使用“static”关键字是合适的。
class C {
int foo = 1;
static int bar = 2;
:
}
最后，我们来谈谈方法。
class C {
int foo() { ... }
static int bar() { ... }
:
}
从概念上讲，类c的每个实例都有一个foo()实例，整个类c只有一个bar()实例。这与我们讨论的数据的情况类似，因此使用'static'也是一个明智的选择，特别是如果你不想在你的语言中添加更多保留的关键字。
Static使时钟成员成为类成员而不是实例成员。如果没有static关键字，你需要创建一个Hello类的实例(它有一个时钟成员变量)。
Hello hello = new Hello();
hello.clock.sayTime();
static关键字意味着某些东西(字段、方法或嵌套类)与类型相关，而不是与类型的任何特定实例相关。例如，在没有Math类实例的情况下调用Math.sin(…)，实际上您无法创建Math类的实例。
有关更多信息，请参阅Oracle的Java教程的相关部分。
旁注
不幸的是，Java允许你像访问实例成员一样访问静态成员。
// Bad code!
Thread.currentThread().sleep(5000);
someOtherThread.sleep(5000);
这使它看起来好像sleep是一个实例方法，但实际上它是一个静态方法——它总是使当前线程休眠。更好的做法是在调用代码中清楚地说明这一点:
// Clearer
Thread.sleep(5000);
//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
}
}
