具体来说,我正在尝试以下代码:
package hello;
public class Hello {
Clock clock = new Clock();
public static void main(String args[]) {
clock.sayTime();
}
}
但是它给了错误
无法在静态方法main中访问非静态字段
因此,我将clock
的声明更改为:
static Clock clock = new Clock();
而且有效。 将关键字放在声明之前是什么意思? 就可以对对象执行的操作而言,它将确切地执行和/或限制什么?
#1楼
Java中的static
关键字表示变量或函数在该类的所有实例之间共享,因为它属于类型 ,而不是实际对象本身。
因此,如果您有一个变量: private static int i = 0;
并且在一个实例中将其递增( i++
),更改将反映在所有实例中。 i
现在在所有情况下都是1。
可以使用静态方法而无需实例化对象。
#2楼
static
关键字表示某项(字段,方法或嵌套类)与该类型有关,而不是与该类型的任何特定实例有关。 因此,例如,在没有Math
类的任何实例的情况下调用Math.sin(...)
,实际上您无法创建Math
类的实例。
有关更多信息,请参见Oracle Java Tutorial的相关部分 。
边注
不幸的是, Java 允许您访问静态成员,就像它们是实例成员一样,例如
// Bad code!
Thread.currentThread().sleep(5000);
someOtherThread.sleep(5000);
这看起来好像sleep
是实例方法,但实际上是静态方法-它总是使当前线程处于睡眠状态。 更好的做法是在调用代码中明确指出:
// Clearer
Thread.sleep(5000);
#3楼
我对“ helper”类中的静态方法(仅在可能的情况下)很喜欢。
调用类无需创建辅助类的另一个成员(实例)变量。 您只需调用助手类的方法。 辅助类也得到了改进,因为您不再需要构造函数,也不需要成员(实例)变量。
可能还有其他优点。
#4楼
静态成员的基本用法...
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";
#5楼
关键字static
用于表示字段或方法属于类本身而不是实例。 使用您的代码,如果对象Clock
是静态的,则Hello
类的所有实例将共享该Clock
数据成员(字段)。 如果将其设为非静态,则Hello
每个单独实例都可以具有唯一的Clock
字段。
问题是您在类Hello
添加了main方法,以便您可以运行代码。 这里的问题是main方法是静态的,因此,它不能引用非静态字段或其中的方法。 您可以通过两种方式解决此问题:
- 将
Hello
类的所有字段和方法设为静态,以便可以在main方法内部引用它们。 这确实不是一件好事(或将字段和/或方法设为静态的错误原因) - 在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();
}
}
#6楼
main()
是一个静态方法,它具有两个基本限制:
- 静态方法不能使用非静态数据成员或直接调用非静态方法。
this()
和super()
不能在静态上下文中使用。class A { int a = 40; //non static public static void main(String args[]) { System.out.println(a); } }
输出:编译时错误
#7楼
静态变量只能在静态方法中访问,因此,当我们声明静态变量时,那些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;
}
}
#8楼
在Java中, static
关键字可以简单地视为指示以下内容:
“不考虑或与任何特定情况无关”
如果您以这种方式考虑static
,那么会更容易理解它在遇到各种上下文中的用法:
static
字段是属于该类而不是任何特定实例的字段static
方法是没有this
概念的方法; 它是在类上定义的,除非对该类传递了引用,否则它不知道该类的任何特定实例static
成员类是一个嵌套类,对它的封闭类的实例没有任何概念或了解(除非将对封闭类实例的引用传递给它)
#9楼
要添加到现有答案中,让我尝试一下图片:
所有储蓄账户的利率为2%。 因此它是静态的 。
余额应为个人 ,因此不是静态的。
#10楼
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的变量有时称为常量。 接口的所有字段都称为常量,因为默认情况下它们是最终的和静态的。
图片资源: 最终静态
#11楼
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或线程可以是一个,但是那不是重点。
#12楼
静态意味着您不必创建类的实例即可使用与该类关联的方法或变量。 在您的示例中,您可以调用:
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类的每个实例将具有不同的值/引用,因此您无法从该类的静态部分访问它。
#13楼
这意味着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();
}
}
#14楼
静态使时钟成员成为类成员,而不是实例成员。 如果没有static关键字,则需要创建Hello类的实例(具有时钟成员变量)-例如
Hello hello = new Hello();
hello.clock.sayTime();
#15楼
静态方法不使用其定义的类的任何实例变量。关于区别的很好解释可以在此页上找到
#16楼
可以将字段分配给类或类的实例。 默认情况下,字段是实例变量。 通过使用static
该字段成为一个类变量,因此只有一个clock
。 如果您在一个地方进行更改,则随处可见。 实例变量彼此独立更改。
#17楼
到目前为止,该讨论都忽略了类加载器的考虑。 严格来说,对于给定的classloader ,Java静态字段在类的所有实例之间共享。
#18楼
也可以想到静态成员没有“ this”指针。 它们在所有实例之间共享。
#19楼
了解静态概念
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");
}
}
#20楼
在运行某些项目时,首先要加载静态内容(变量,方法,块..)。
运行此项目时,首先加载主方法。 因为它是static method
。 然后,它看起来是对象"a" object
。但是对象a尚未定义。 因为它是非静态的。 然后出现此错误。
#21楼
//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
}
}