Question

为什么你不能在Java中将类声明为静态？

Answer 1

只有嵌套类可以是静态的。通过这样做，您可以使用嵌套类，而无需外部类的实例。

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 tutorial on nested classes

关于同一主题：

Answer 2

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

Answer 3

所以，我来参加聚会，但这是我的两分钱 - 哲学上补充了科林赫伯特的回答。

在较高级别，您的问题处理对象和类型之间的差异。虽然有很多汽车（物体），但只有一种汽车类（类型）。将某些内容声明为静态意味着您正在使用＆＃34;类型＆＃34;空间。只有一个。顶级class关键字已经在＆＃34; type＆＃34;中定义了一个类型。空间。结果＆＃34;公共静态类Car＆＃34;是多余的。

Answer 4

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

像这样声明你的课：

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

Answer 5

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

但对于顶级课程，语言设计师无法想到对关键字有用的任何内容，因此不允许这样做。

Answer 6

您可以通过声明没有实例的枚举类型来创建实用程序类（不能创建实例）。即你特别声明没有实例。

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

Answer 7

public class Outer {
   public static class Inner {}
}

...它可以声明为static - 只要它是一个成员类。

来自JLS：

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

在这里：

static关键字可以修改非内部类T体内成员类型C的声明。其效果是声明C不是内部类。就像静态一样T的方法在其体内没有T的当前实例，C也没有T的当前实例，也没有任何词法封闭实例。

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

Answer 8

如上所述，除非Class是另一个Class的成员，否则Class不能是静态的。

如果您正在设计一个“不能有多个实例”的类，您可能需要查看“Singleton”设计模式。

初学者单身人士信息here。

警告：

如果您正在考虑使用单身模式，全部抗拒你的力量。这是最简单的之一可能是DesignPatterns要理解的最受欢迎的，绝对是最受虐待的。 （来源：上面链接的JavaRanch）

Answer 9

除了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();
    }
}

Answer 10

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

public class whatever {
    static class innerclass {
    }
}

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

Answer 11

我们在java中编写代码的所有东西都进入了一个类。每当我们运行类时，JVM都会实例化一个对象。根据定义，JVM可以创建许多对象。静态意味着您对所有对象具有相同的副本集。

因此，如果Java在运行程序时允许顶级类是静态的，那么它会创建一个Object并继续覆盖到相同的Memory Location。

如果您只是在每次运行时更换对象，那么创建它的目的是什么？

因此，这就是Java摆脱顶级类静态的原因。

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

Answer 12

我认为这可以像喝一杯咖啡一样简单！看看这个。我们在定义类时不会显式使用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);
    }
}

Answer 13

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

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

Answer 14

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

为什么你不能在Java中将类声明为静态？

14 个答案: