Java中的静态类

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

Declare your class final - 防止扩展类，因为扩展静态类没有意义

将构造函数设为私有 - 防止客户端代码实例化，因为实例化静态类没有意义

将类的所有成员和函数设为静态 - 由于无法实例化类，因此无法调用实例方法或访问实例字段

请注意，编译器不会阻止您声明实例（非静态）成员。仅当您尝试调用实例成员时才会出现此问题

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

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 类和 source code。请注意，它是 final，它的所有成员都是 static。如果 Java 允许声明顶级类 static 那么 Math 类确实是静态的。

---

好吧，Java 有“静态嵌套类”，但它们与 C# 的静态类完全不同，如果你是从那里来的话。静态嵌套类只是一个没有隐式引用外部类实例的类。

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

Java 中没有顶级静态类。

---

有一个静态 nested class，这个 [静态嵌套] 类不需要封闭类的实例就可以自己实例化。

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

代码示例：

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

---

是的，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();

---

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

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

public class A {
    public static class B {

    }
}

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

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

static 个类也可以有 non-static 个成员。只有类是静态的。

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

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

但是我们不能在 non-static 内部类中有 static 成员。

---

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

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

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

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

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

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

见这里：https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

---

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

摘自 Joshua Bloch 的“Effective Java - Second Edition”（被广泛认为是最好的 Java 风格指南之一）：

从 1.5 版开始，还有第三种实现单例的方法。只需使用一个元素创建一个枚举类型： // Enum singleton - 首选方法 public enum Elvis { INSTANCE; public void leaveTheBuilding() { ... } } 这种方法在功能上等价于 public field 方法，只是它更简洁，免费提供序列化机制，并且提供了针对多次实例化的铁定保证，即使面对复杂的序列化或反射攻击。虽然这种方法尚未被广泛采用，但单元素枚举类型是实现单例的最佳方式。 （强调作者的）

约书亚·布洛赫 (2008-05-08)。有效的 Java（Java 系列）（第 18 页）。培生教育。

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

---

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

---

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

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

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

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

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

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

---

除非它是内部类，否则不能对类使用 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();
   }
}

---

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/etc... 如果您经常从多个区域收集、更新、复制集合并且需要这些集合同步。或多对一。

---

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

---

静态方法意味着可以在不创建类的对象的情况下访问它，与 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
  }
}

---

所有好的答案，但我没有看到对 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);
}

---