为什么你不能在Java中声明一个静态的类？
为什么你不能在Java中声明一个静态的类？
只有嵌套的类可以是静态的。 通过这样做，您可以使用嵌套类而不需要外部类的实例。
class OuterClass{ public static class StaticNestedClass{ } public class InnerClass{ } public InnerClass getAnInnerClass(){ return new InnerClass(); } //This method doesn't work public static InnerClass getAnInnerClassStatically(){ return new InnerClass(); } } class OtherClass{ //Use of a static nested class: private OuterClass.StaticNestedClass staticNestedClass = new OuterClass.StaticNestedClass(); //Doesn't work private OuterClass.InnerClass innerClass = new OuterClass.InnerClass(); //Use of an inner class: private OuterClass outerclass= new OuterClass(); private OuterClass.InnerClass innerClass2 = outerclass.getAnInnerClass(); private OuterClass.InnerClass innerClass3 = outerclass.new InnerClass(); }
来源：
- 关于嵌套类的Oracle教程
在同一主题上：
- Java：静态与非静态内部类
- Java内部类和静态嵌套类
具有私有构造函数的类是静态的。
像这样声明你的类：
public class eOAuth { private eOAuth(){} public final static int ECodeOauthInvalidGrant = 0x1; public final static int ECodeOauthUnknown = 0x10; public static GetSomeStuff(){} }
你可以使用没有初始化：
if (value == eOAuth.ECodeOauthInvalidGrant) eOAuth.GetSomeStuff(); ...
所以，我迟到了，但是这里是我的两分钱 – 在科林·赫伯特（Colin Hebert）的回答中，哲学上增加了一点。
在高层次上，你的问题涉及对象和types之间的差异。 虽然有很多汽车（物体），但只有一个汽车类（types）。 声明一些静态的东西意味着你正在“types”空间中运行。 只有一个。 顶级类关键字已经在“types”空间中定义了一个types。 结果“公共静态class车”是多余的。
顶层类默认是静态的。 内部类默认是非静态的。 您可以通过明确地将它们标记为静态来更改内部类的默认值。 顶级类由于是顶级，所以不能有非静态语义，因为没有父类可以引用。 因此，无法更改顶级类的默认值。
当然，他们可以，但只有内在的嵌套类。 在那里，这意味着嵌套类的实例不需要外部类的封闭实例。
但是对于顶级的课程，语言devise师不能想到任何有用的关键字，所以这是不允许的。
您可以通过声明不带实例的枚举types来创build实用程序类（不能创build实例）。 即你具体声明没有实例。
public enum MyUtilities {; public static void myMethod(); }
public class Outer { public static class Inner {} }
…它可以被声明为静态 – 只要它是一个成员类。
从JLS：
成员类可能是静态的，在这种情况下，它们不能访问周围类的实例variables; 或者他们可能是内部类（§8.1.3）。
和这里：
static关键字可以修改非内部类T中的成员typesC的声明。 其效果是声明C不是内部类。 就像T的一个静态方法在它的正文中没有T的当前实例一样，C也没有T的当前实例，也没有任何词法封闭的实例。
一个static关键字对顶级类没有任何意义，因为顶级类没有包含types。
如上所述，一个类不能是静态的，除非它是另一个类的成员。
如果你正在devise一个“不能有多个实例”的类，你可能想看看“Singleton”的devise模式。
初学者单身信息在这里 。
警告：
如果您正在考虑使用单身模式，请尽量抵制。 这是最容易理解的DesignPatterns之一，可能是最受欢迎的，也是最受虐待的。 （来源：上面链接的JavaRanch）
除了Java定义静态内部类之外，还有另外一个定义静态类的C＃世界[1] 。 静态类是只有静态方法（函数），它是为了支持程序编程。 这样的类并不是真正的类，因为类的用户只对帮助函数感兴趣，而不是创build类的实例。 虽然C＃支持静态类，但Java中不存在这种直接的支持。 但是，您可以使用枚举来模仿Java中的C＃静态类，以便用户永远不会创build给定类的实例（即使使用reflection） [2] ：
public enum StaticClass2 { // Empty enum trick to avoid instance creation ; // this semi-colon is important public static boolean isEmpty(final String s) { return s == null || s.isEmpty(); } }
唯一可以是静态的类是内部类。 下面的代码工作得很好：
public class whatever { static class innerclass { } }
静态内部类的要点是它们没有对外部类对象的引用。
我们在java中编写的所有东西都进入了一个类。 每当我们运行一个类JVM实例化一个对象。 JVM可以创build一些对象，按照定义，静态意味着你有相同的一组拷贝到所有的对象。
所以，如果Java允许顶级类在运行程序时是静态的，它将创build一个对象并继续保持相同的内存位置。
如果你每次运行都只是replace对象，那么创build它的意义何在？
所以这就是Java为顶级Class抛弃静态的原因。
可能有更多的具体原因，但是这对我来说合乎逻辑。
我想这可能就像喝一杯咖啡一样简单！ 只要看看这个。 定义类时，我们不明确地使用static关键字。
public class StaticClass { static private int me = 3; public static void printHelloWorld() { System.out.println("Hello World"); } public static void main(String[] args) { StaticClass.printHelloWorld(); System.out.println(StaticClass.me); } }
这不是静态类的定义吗？ 我们只是使用绑定到一个类的函数。 在这种情况下要小心，我们可以使用嵌套的另一个类。 看这个：
class StaticClass1 { public static int yum = 4; static void printHowAreYou() { System.out.println("How are you?"); } } public class StaticClass { static int me = 3; public static void printHelloWorld() { System.out.println("Hello World"); StaticClass1.printHowAreYou(); System.out.println(StaticClass1.yum); } public static void main(String[] args) { StaticClass.printHelloWorld(); System.out.println(StaticClass.me); } }
我们可以看一下Eclipse中的PlatformUI ，它包含静态方法和私有构造函数，本身是最终的。
public final class <class name> { //static constants //static memebers }
如果使用静态类的好处不是实例化一个对象并使用一个方法，那么只需将该类声明为public，并将此方法声明为static。
