用外行术语来说，Java中的“静态”是什么意思？[重复]

在Java中，static关键字可以以几种不同的方式使用，并且在几乎所有情况下，它都是一个修饰符，这意味着它所修饰的对象无需封闭对象实例就可以使用。

Java是一种面向对象的语言，默认情况下，您编写的大多数代码都需要使用该对象的实例。

public class SomeObject {
    public int someField;
    public void someMethod() { };
    public Class SomeInnerClass { };
}

为了使用someField，someMethod或SomeInnerClass，我必须首先创建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关键字也可以应用于内部接口，注释和枚举。

public class SomeObject {
    public static interface SomeInterface { };
    public static @interface SomeAnnotation { };
    public static enum SomeEnum { };
}

在所有这些情况下，关键字都是多余的，并且无效。接口，注释和枚举在默认情况下是静态的，因为它们从不与内部类有关系。

这只是描述了关键字的作用。它没有描述使用关键字是否是一个坏主意。可以在其他问题中对此进行更详细的介绍，例如使用大量静态方法是否不好？

关键字static还有一些较不常用的用法。有静态导入，这些静态导入使您可以使用无限制的静态类型（包括接口，注释和未冗余标记为静态的枚举）。

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