为什么不能在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内部类和静态嵌套类

默认情况下，顶级类是静态的。内部类默认情况下是非静态的。您可以通过将内部类显式标记为静态来更改它们的默认值。由于是顶级，所以顶级类不能具有非静态语义，因为没有父类可以引用。因此，无法更改顶级类的默认设置。

所以，我来晚了，但是这是我的两分钱-从哲学上讲增加了科林·赫伯特的回答。

从高层次上讲，您的问题涉及对象和类型之间的差异。尽管有许多汽车（对象），但只有一种汽车类别（类型）。将某些事物声明为静态意味着您正在“类型”空间中进行操作。只有一个。顶级class关键字已经在“类型”空间中定义了一种类型。结果，“公共静态类汽车”是多余的。

具有私有构造函数的类是静态的。

像这样声明您的课程：

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();
...

当然可以，但是只能是内部嵌套的类。在那里，这意味着嵌套类的实例不需要外部类的封闭实例。

但是对于顶级类，语言设计人员无法想到与该关键字有关的任何有用信息，因此是不允许的。

您可以通过声明没有实例的枚举类型来创建实用程序类（不能创建实例）。即，您具体是在声明没有实例。

public enum MyUtilities {;
   public static void myMethod();
}

public class Outer {
   public static class Inner {}
}

...可以声明为静态-只要它是成员类。

从JLS：

成员类可能是静态的，在这种情况下，它们无法访问周围类的实例变量；或者它们可以是内部类（第8.1.3节）。

和这里：

static关键字可以在非内部类T的主体内修改成员类型C的声明。其作用是声明C不是内部类。正如T的静态方法在其主体中没有T的当前实例一样，C也没有T的当前实例，也没有任何词法包围的实例。

静态关键字对于顶级类没有任何意义，仅因为顶级类没有封闭类型。

如上所述，一个类不能为静态，除非它是另一个类的成员。

如果要设计一个“不能有多个实例的类”，则可能需要研究“单人”设计模式。

初学者Singleton信息在这里。

警告：

如果您想使用单例模式，请全力以赴。它是最容易理解的DesignPatterns之一，可能是最受欢迎的，而且肯定是最滥用的。 （来源：上面链接的JavaRanch）

除了Java如何定义静态内部类之外，还有根据C＃world [1]定义的静态类。静态类是仅具有静态方法（函数）的类，它旨在支持过程编程。这样的类并不是真正的类，因为该类的用户仅对帮助器函数感兴趣，而对创建该类的实例不感兴趣。尽管C＃支持静态类，但是Java中不存在这种直接支持。但是，您可以使用枚举来模仿Java中的C＃静态类，以使用户永远无法创建给定类的实例（即使使用反射）[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();
    }
}

我们用Java编写的所有代码都归为一类。每当我们运行类时，JVM都会实例化一个对象。JVM可以创建许多对象，根据定义，静态意味着您具有到所有对象的相同副本集。

因此，如果Java在每次运行程序时都允许顶级类为静态，则它将创建一个Object并继续覆盖相同的Memory Location。

如果您每次运行时都只是替换对象，那么创建它的意义何在？

因此，这就是Java放弃了用于顶级类的静态方法的原因。

可能有更具体的原因，但这对我来说很合乎逻辑。

内部类只能是静态的。以下代码可以正常工作：

public class whatever {
    static class innerclass {
    }
}

静态内部类的要点是它们没有对外部类对象的引用。

我认为这和喝一杯咖啡一样容易！看看这个。定义类时，我们不会显式使用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);
    }
}

可以PlatformUI在Eclipse中查看具有静态方法和私有构造函数的类，而它们本身是最终的。

public final class <class name>
{
   //static constants
   //static memebers
}

如果使用静态类的好处不是实例化对象并使用方法，则只需将该类声明为public并将此方法声明为static。