用术语来说，Java中的“静态”意味着什么？
我已经被告知了它的几个定义，看了维基百科，但作为Java的初学者，我还不确定这是什么意思。 任何人都可以stream利地使用Java和白痴？
静态意味着标记为这样的variables或方法在类级别是可用的。 换句话说，你不需要创build一个类的实例来访问它。
public class Foo { public static void doStuff(){ // does stuff } } 所以，而不是创build一个Foo的实例，然后像这样调用doStuff ：
Foo f = new Foo(); f.doStuff();
你只需要直接调用这个方法，就像这样：
Foo.doStuff();
非常外行的讲课是一个模具，而对象是用这个模具制作的。 静态属于模具，可以直接访问而不需要复制，因此上面的例子
在Java中，静态关键字可以以几种不同的方式使用，在几乎所有情况下，它都是一个修饰符，这意味着它正在修改的内容可以在没有封闭对象实例的情况下使用 。
Java是面向对象的语言，默认情况下，大部分代码都需要使用对象的实例。
public class SomeObject { public int someField; public void someMethod() { }; public Class SomeInnerClass { }; }
为了使用someField，someMethod或SomeInnerClass， 我必须先创build一个SomeObject的实例 。
public class SomeOtherObject { public void doSomeStuff() { SomeObject anInstance = new SomeObject(); anInstance.someField = 7; anInstance.someMethod(); //Non-static inner classes are usually not created outside of the //class instance so you don't normally see this syntax SomeInnerClass blah = anInstance.new SomeInnerClass(); } }
如果我声明这些东西静态，那么他们不需要一个封闭的实例 。
public class SomeObjectWithStaticStuff { public static int someField; public static void someMethod() { }; public static Class SomeInnerClass { }; } public class SomeOtherObject { public void doSomeStuff() { SomeObjectWithStaticStuff.someField = 7; SomeObjectWithStaticStuff.someMethod(); SomeObjectWithStaticStuff.SomeInnerClass blah = new SomeObjectWithStaticStuff.SomeInnerClass(); //Or you can also do this if your imports are correct SomeInnerClass blah2 = new SomeInnerClass(); } }
声明静态有一些含义。
首先， 在整个应用程序中只能有一个静态字段的值 。
public class SomeOtherObject { public void doSomeStuff() { //Two objects, two different values SomeObject instanceOne = new SomeObject(); SomeObject instanceTwo = new SomeObject(); instanceOne.someField = 7; instanceTwo.someField = 10; //Static object, only ever one value SomeObjectWithStaticStuff.someField = 7; SomeObjectWithStaticStuff.someField = 10; //Redefines the above set } }
第二个问题是静态方法和内部类不能访问封闭对象中的字段 （因为没有一个）。
public class SomeObjectWithStaticStuff { private int nonStaticField; private void nonStaticMethod() { }; public static void someStaticMethod() { nonStaticField = 7; //Not allowed this.nonStaticField = 7; //Not allowed, can never use *this* in static nonStaticMethod(); //Not allowed super.someSuperMethod(); //Not allowed, can never use *super* in static } public static class SomeStaticInnerClass { public void doStuff() { someStaticField = 7; //Not allowed nonStaticMethod(); //Not allowed someStaticMethod(); //This is ok } } }
static关键字也可以应用于内部接口，注释和枚举。
公共类SomeObject {公共静态接口SomeInterface {}; public static @interface SomeAnnotation {}; 公共静态枚举SomeEnum {}; }
在所有这些情况下，关键字是多余的，并且不起作用。 接口，注释和枚举默认是静态的，因为它们从来没有与内部类的关系。
这只是描述了他们的关键字。 它没有描述是否使用关键字是一个坏主意。 这可以在其他问题更详细的覆盖，如使用大量的静态方法是一件坏事？
关键字static也有一些不太常用的用法。 有静态导入，允许您使用静态types（包括接口，注释和枚举不冗余标记为静态）不合格。
//SomeStaticThing.java public class SomeStaticThing { public static int StaticCounterOne = 0; } //SomeOtherStaticThing.java public class SomeOtherStaticThing { public static int StaticCounterTwo = 0; } //SomeOtherClass.java import static some.package.SomeStaticThing.*; import some.package.SomeOtherStaticThing.*; public class SomeOtherClass { public void doStuff() { StaticCounterOne++; //Ok StaticCounterTwo++; //Not ok SomeOtherStaticThing.StaticCounterTwo++; //Ok } }
最后，还有一些静态的初始化器，它们是在第一次加载类时运行的代码块（ 通常是在应用程序中第一次实例化类之前），并且（像静态方法一样）不能访问非静态字段或方法。
public class SomeObject { private static int x; static { x = 7; } }
如果这件事情比所需要的细节更为详细，我很抱歉，我被要求把这个答案从另一个问题转移到细节更为合适的地方。
另一个很好的例子，当你想要应用Singletondevise模式时，使用静态属性和操作。 简而言之，Singletondevise模式可以确保在系统的生命周期中build立一个特定类的唯一一个对象。 为了确保只有一个对象被构造，Singleton模式的典型实现保持对单个允许对象实例的内部静态引用，并且使用static操作来控制对该实例的访问
除了@inkedmn指出的，静态成员是在课堂上的。 因此，所述成员被JVM一次加载到内存中（当类被加载时）。 也就是说，对于它所属的类的n个实例，不存在n个静态成员的实例。
以上几点是正确的，我想添加一些关于Static关键字更重要的一点。
在内部使用static关键字时会发生什么，它会存储在永久内存中 （即在堆内存中 ），我们知道有两种types的内存是堆栈内存 （临时内存）和堆内存 （永久内存），所以如果不使用静态关键字，则将存储在堆栈内存的临时内存中（或者可以将其称为易失性内存 ）。
所以你会怀疑这是什么使用权？
例如 ：static int a = 10;（1程序）
刚才我告诉你如果你使用static关键字的variables或方法它将存储在永久内存中 。
所以我在其他程序中用关键字static声明了不同的值。
例如 ：static int a = 20;（2程序）
variables'a'被程序1存储在堆内存中， 程序2中find了同样的静态variables'a'，那时它不会在堆内存中再次创build'a'variables，而只是代替值从10到20 。
一般情况下，如果不声明'a'作为静态variables，它将在栈内存（临时内存）中再次创buildvariables'a'。
总体而言，我可以说，如果我们使用静态关键字
我们可以节省内存
我们可以避免重复
3.不需要通过类名的访问来创build对象，以便访问静态variables。
