什么是“静态类”？在Java中？

Question

Closed. This question needs details or clarity. It is not currently accepting answers.

---

想要改进这个问题？通过编辑这篇文章添加详细信息并澄清问题。

6 个月前已关闭。

社区5个月前审查了是否重新开放此问题，并将其关闭：

原始关闭原因未解决

Answer 1

Java 有静态嵌套类，但听起来您正在寻找顶级静态类。 Java 无法使顶级类静态，但您可以像这样模拟静态类：

• 声明您的类 final - 防止扩展该类，因为扩展静态类没有意义
• 使构造函数private - 防止客户端代码实例化，因为实例化静态类是没有意义的
• 使所有类的成员和函数static - 由于该类无法实例化，无法调用实例方法或访问的实例字段
• 请注意，编译器不会阻止您声明实例（非静态）成员。仅当您尝试调用实例成员时，该问题才会出现

根据上面建议的简单示例：

public class TestMyStaticClass {
     public static void main(String []args){
        MyStaticClass.setMyStaticMember(5);
        System.out.println("Static value: " + MyStaticClass.getMyStaticMember());
        System.out.println("Value squared: " + MyStaticClass.squareMyStaticMember());
        // MyStaticClass x = new MyStaticClass(); // results in compile time error
     }
}

// A top-level Java class mimicking static class behavior
public final class MyStaticClass {
    private MyStaticClass () { // private constructor
        myStaticMember = 1;
    }
    private static int myStaticMember;
    public static void setMyStaticMember(int val) {
        myStaticMember = val;
    }
    public static int getMyStaticMember() {
        return myStaticMember;
    }
    public static int squareMyStaticMember() {
        return myStaticMember * myStaticMember;
    }
}

静态类有什么好处？ 静态类的一个很好的用途是定义一次性的、实用的和/或实例化没有意义的库类。一个很好的例子是 Math 类，它包含一些数学常量，例如 PI 和 E，并且仅提供数学计算。在这种情况下要求实例化是不必要的并且会造成混乱。请参阅 Math 类和 源代码< /a>.请注意，它是final，并且它的所有成员都是static。如果 Java 允许将顶级类声明为静态，那么 Math 类确实是静态的。

Answer 2

嗯，Java 有“静态嵌套类”，但它们与 C# 的静态类完全不同（如果您来自 C#）。静态嵌套类只是一种不隐式引用外部类实例的类。

静态嵌套类可以具有实例方法和静态方法。

Java 中不存在顶级静态类这样的东西。

Answer 3

有一个静态嵌套类，这个[静态嵌套]类不需要封闭类的实例即可实例化自身。

这些类[静态嵌套类]只能访问封闭类的静态成员[因为它没有对封闭类的实例的任何引用...]

代码示例：

public class Test { 
  class A { } 
  static class B { }
  public static void main(String[] args) { 
    /*will fail - compilation error, you need an instance of Test to instantiate A*/
    A a = new A(); 
    /*will compile successfully, not instance of Test is needed to instantiate B */
    B b = new B(); 
  }
}

Answer 4

是的，java中有一个静态嵌套类。
当您将嵌套类声明为静态时，它会自动成为一个独立的类，可以实例化该类，而无需实例化它所属的外部类。

示例：

public class A
{

 public static class B
 {
 }
}

由于 class B 被声明为静态，因此您可以显式实例化为：

B b = new B();

请注意，如果 class B 未声明为静态以使其独立，实例对象调用将如下所示：

A a= new A();
B b = a.new B();

Answer 5

当 class 内的成员声明为 static 时会发生什么？无需实例化类即可访问这些成员。因此，使外部类（顶级类）static没有任何意义。因此这是不允许的。

但是您可以将内部类设置为静态（因为它是顶级类的成员）。然后可以访问该类，而无需实例化顶级类。考虑以下示例。

public class A {
    public static class B {

    }
}

现在，在不同的类 C 中，可以访问类 B，而无需创建类 A 的实例。

public class C {
    A.B ab = new A.B();
}

静态类也可以有非静态成员。只有类变得静态。

但是，如果从类 B 中删除 static 关键字，则在不创建 A 实例的情况下无法直接访问它。

public class C {
    A a = new A();
    A.B ab = a. new B();
}

但是我们不能在非静态内部类中拥有static成员。

Answer 6

Java中的类可以是静态的吗？

答案是可以，我们可以在Java中拥有静态类。在java中，我们有静态实例变量以及静态方法和静态块。 Java 中的类也可以设为静态。

在java中，我们不能将顶级（外部）类设为静态。 只有嵌套类可以是静态的。

静态嵌套类与非静态嵌套类

1）嵌套静态类不需要外部类的引用，但是
非静态嵌套类或内部类需要外部类
参考。

2）内部类（或非静态嵌套类）可以访问静态
和外部类的非静态成员。静态类不能访问外部类的非静态成员。它只能访问静态
外层阶级的成员。

请参阅此处： https://docs.oracle.com/javase/tutorial/ java/javaOO/nested.html

Answer 7

鉴于这是 Google 上“static class java”的最高结果，而最佳答案不在这里，我想我应该添加它。我将 OP 的问题解释为有关 C# 中的静态类，这些类在 Java 世界中被称为单例。对于那些不知道的人来说，在 C# 中，“static”关键字可以应用于类声明，这意味着生成的类永远不能被实例化。

摘自 Joshua Bloch 的《Effective Java - 第二版》（被广泛认为是最好的 Java 风格指南之一）：

从 1.5 版开始，有第三种方法来实现单例。只需使用一个元素创建一个枚举类型：

// 枚举单例 - 首选方法
公共枚举猫王{
    实例;
    公共无效离开建筑物（）{...}
}

这种方法在功能上与公共字段方法等效，只是它更简洁，免费提供序列化机制，并提供针对多重实例化的铁定保证，即使面对复杂的序列化或反射攻击也是如此。虽然这种方法尚未被广泛采用，但单元素枚举类型是实现单例的最佳方式。（强调作者的）

Bloch, Joshua (2008-05-08)。有效的 Java（Java 系列）（第 18 页）。培生教育。

我认为实施和理由是非常不言自明的。

Answer 8

外部类不能是静态的，但嵌套/内部类可以是静态的。这基本上可以帮助您使用嵌套/内部类，而无需创建外部类的实例。

Answer 9

简单来说，Java 仅支持内部类将类声明为静态，而不支持顶级类。

顶级类一个java项目在每个java源文件中可以包含多个顶级类，其中一个类以文件名命名。顶级类前面只允许使用三个选项或关键字：public、abstract 和 Final。

内部类：顶级类内部的类称为内部类，这基本上是嵌套类的概念。 内部类可以是静态的。使内部类静态的想法是利用实例化内部类的对象而不实例化顶级类的对象。这与静态方法和变量在顶级类中的工作方式完全相同。

因此Java支持内部类级别的静态类（在嵌套类中）

并且Java不支持顶级类的静态类。

我希望这能为这个问题提供一个更简单的解决方案对 Java 中的静态类有基本的了解。

Answer 10

除非它是内部类，否则不能对类使用 static 关键字。静态内部类是一个嵌套类，它是外部类的静态成员。可以使用其他静态成员来访问它，而无需实例化外部类。就像静态成员一样，静态嵌套类无法访问外部类的实例变量和方法。

public class Outer {
   static class Nested_Demo {
      public void my_method() {
          System.out.println("This is my nested class");
      }
   }
public static void main(String args[]) {
      Outer.Nested_Demo nested = new Outer.Nested_Demo();
      nested.my_method();
   }
}

Answer 11

java中有类似静态类的东西吗？

单例“就像”静态类。我很惊讶还没有人提到过它们。

public final class ClassSingleton { 

private static ClassSingleton INSTANCE;
private String info = "Initial info class";

private ClassSingleton() {        
}

public static ClassSingleton getInstance() {
    if(INSTANCE == null) {
        INSTANCE = new ClassSingleton();
    }
    
    return INSTANCE;
}

// getters and setters

public String getInfo(){
    return info;
  }
}

用法类似于：

String infoFromSingleton = ClassSingleton.getInstance().getInfo()

单例非常适合存储 ArrayLists/List/Collection Classes/等等...如果您经常从多个区域收集、更新、复制集合并且需要这些集合同步。或多对一。

Answer 12

静态类是属于类本身而不是类的任何特定实例的类。它用于将相关方法或常量分组在一起，并且不需要创建实例来访问其成员。静态类通常用于实用函数或组织代码。

需要记住的一些要点：

• 静态类始终是嵌套类
• 只能访问外部类的静态成员。
• 外部类不能是静态的。
• 过度使用静态类可能会导致代码紧密耦合，从而更难以维护和测试

Answer 13

我的答案将与上面的答案类似，尽管我的答案可能更清晰并且有更清晰的示例。

通过说你希望类是静态的，你是说你基本上只需要该类的一个实例存在，因此我们可以在类本身中创建该类的实例变量，我实际上只看到它与用于返回硬编码或默认值的对象。

您基本上是在类本身内创建类的静态实例。这是根据被调用的类自动构造的，并且由于 INSTANCE 是静态的，因此该类只有一个实例。这有效地使您的顶级 Java 类静态化。

这是一个示例：

public class A {
    private static final A INSTANCE = new A();

    public static A getInstance() {
        return INSTANCE;
    }
}

然后您可以将所有其他方法添加到该类中。这会导致该类仅存在一个实例。在这种情况下，您不使用构造函数。

Answer 14

Java 具有与类关联的静态方法（例如 java.lang.Math 仅具有静态方法），但类本身不是静态的。

Answer 15

所有好的答案，但我没有看到对 java.util.Collections 的引用，它使用大量静态内部类作为其静态因子方法。所以添加相同的。

添加来自 java.util.Collections 的示例，该示例具有多个静态内部类。内部类对于将需要通过外部类访问的代码进行分组非常有用。

/**
 * @serial include
 */
static class UnmodifiableSet<E> extends UnmodifiableCollection<E>
                             implements Set<E>, Serializable {
    private static final long serialVersionUID = -9215047833775013803L;

    UnmodifiableSet(Set<? extends E> s)     {super(s);}
    public boolean equals(Object o) {return o == this || c.equals(o);}
    public int hashCode()           {return c.hashCode();}
}

这是 java.util.Collections 类中的静态因子方法

public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
    return new UnmodifiableSet<>(s);
}

Answer 16

静态方法意味着无需创建类的对象即可访问它，这与 public 不同：

public class MyClass {
   // Static method
   static void myStaticMethod() {
      System.out.println("Static methods can be called without creating objects");
   }

  // Public method
  public void myPublicMethod() {
      System.out.println("Public methods must be called by creating objects");
   }

  // Main method
  public static void main(String[ ] args) {
      myStaticMethod(); // Call the static method
    // myPublicMethod(); This would output an error

    MyClass myObj = new MyClass(); // Create an object of MyClass
    myObj.myPublicMethod(); // Call the public method
  }
}