为什么非静态内部类中不能有静态方法？
public class Foo {
class Bar {
static void method() {} // Compiler error
}
}
如果我把内部类设为静态，它就能正常工作。为什么？
public class Foo {
static class Bar { // now static
static void method() {}
}
}
由于内部类的实例隐式关联着其外部类的实例，因此它本身不能定义任何静态方法。由于静态嵌套类无法直接引用其封闭类中定义的实例变量或方法，因此它只能通过对象引用来使用它们，所以在静态嵌套类中声明静态方法是安全的。
A.B.sync(X) 或者（在 A 中）B.sync(x)？ - Edward Falk在非静态内部类中允许静态方法没有太大的意义，因为你如何访问它呢？除非通过外部类实例访问非静态内部类实例，否则无法访问（至少最初）。没有纯粹的静态方法可以创建非静态内部类。
对于外部类Outer，你可以像这样访问静态方法test():
Outer.test();
对于一个静态内部类 Inner，你可以这样访问它的静态方法 innerTest()：
Outer.Inner.innerTest();
Inner不是静态的，现在就没有纯静态的方法可以引用方法innertest。非静态内部类与其外部类的特定实例绑定在一起。函数与常量不同，在引用Outer.Inner.CONSTANT时保证是无歧义的，但调用Outer.Inner.staticFunction();则不然。假设您有一个调用getState()的Inner.staticFunction()，后者在Outer中定义。如果尝试调用该静态函数，则现在对内部类存在一个模糊的引用。也就是说，在哪个内部类实例上调用静态函数很重要。这很重要。因为由于对外部对象的隐式引用，没有真正静态的方法可以引用那个静态方法。
Paul Bellora正确地指出，语言设计人员本可以允许这样做。然后他们必须小心地禁止访问非静态内部类的静态方法中的隐式外部类引用。此时，如果您不能除了静态方式以外引用外部类，那么内部类作为内部类的价值何在呢? 如果静态访问是可以接受的，那么为什么不将整个内部类声明为静态呢? 如果简单地将内部类本身设置为静态，则不再具有对外部类的隐式引用，也就不存在这种歧义。
如果您实际上需要在非静态内部类中使用静态方法，那么您可能需要重新考虑您的设计。
Outer.Inner i = new Outer().new Inner(); 此外，根据 JLS §15.28 的规定，内部类允许声明静态常量。 - Paul BelloraOuter.Inner.CONSTANT一样调用Outer.Inner.staticMethod()。如果没有通过外部类实例，你无法访问非静态内部类的实例。但是为什么你需要这个实例呢？你不需要Outer类的实例来调用Outer.staticMethod()。我知道这有些苛刻，但我的观点是以这种方式来表述你的答案是没有意义的。我认为如果语言设计者希望的话是可以允许这一点的。 - Paul BelloraOuter.Inner.CONSTANT和Outer.Inner.staticMethod()之间的区别在于对常量的引用没有机会隐式地引用实例化Inner的Outer实例。所有对Outer.staticMethod()的引用共享完全相同的状态。所有对Outer.Inner.CONSTANT的引用共享完全相同的状态。然而，对Outer.Inner.staticMethod()的引用是不明确的：由于每个Inner实例中都有对外部类的隐式引用，因此“静态”状态并不真正是静态的。没有真正明确、静态的方法来访问它。 - EddieOuter.this相关的冲突不存在。我同意Java语言设计者的观点，不应该在内部类中允许静态方法或非最终静态字段，因为内部类中的所有内容都应该在封闭类的上下文中。 - Theodore Murdock我有一个理论，它可能正确，也可能不正确。
首先，你需要了解一些关于Java内部类实现的知识。假设你有这样一个类：
class Outer {
private int foo = 0;
class Inner implements Runnable {
public void run(){ foo++; }
}
public Runnable newFooIncrementer(){ return new Inner(); }
}
class Outer {
private int foo = 0;
static class Inner implements Runnable {
private final Outer this$0;
public Inner(Outer outer){
this$0 = outer;
}
public void run(){ this$0.foo++; }
}
public Runnable newFooIncrementer(){ return new Inner(this); }
}
现在，如果我们允许在非静态内部类中使用静态方法，您可能希望执行以下操作。
class Outer {
private int foo = 0;
class Inner {
public static void incrFoo(){ foo++; }
}
}
... 这看起来相当合理，因为 Inner 类似乎每个 Outer 实例都有一个版本。但是如上所述，非静态内部类实际上只是静态“内部”类的语法糖，因此最后一个示例将近似于：
class Outer {
private int foo = 0;
static class Inner {
private final Outer this$0;
public Inner(Outer outer){
this$0 = outer;
}
public static void incrFoo(){ this$0.foo++; }
}
}
很明显这不会起作用，因为this$0是非静态的。这也解释了为什么不允许静态方法（尽管你可以认为只要它们不引用封闭对象就可以允许静态方法），以及为什么您不能拥有非最终的静态字段（如果来自不同对象的非静态内部类的实例共享“静态状态”将是违反直觉的）。这也解释了为什么允许final字段（只要它们不引用封闭对象）。
public static double sinDeg(double theta) { ... }呢？ - Edward FalkInner实例与一个Outer实例相关联，但如果Java决定这样做，仍然可以使用Outer.Inner.myStatic来引用Inner的静态成员。Inner实例之间共享某些东西，你可以将它们作为静态成员放入Outer中。这并不比在Inner中使用静态成员更糟糕，因为Outer仍然可以访问Inner的任何私有成员（并未提高封装性）。outer对象创建的所有Inner实例之间共享某些东西，那么将它们作为普通成员放入Outer类中就更有意义了。来自：https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html
与实例方法和变量一样，内部类与其封闭类的实例相关联，并直接访问该对象的方法和字段。此外，由于内部类与实例相关联，因此它本身无法定义任何静态成员。
Oracle的解释过于肤浅和含糊。由于在内部类中没有技术或语法上的先发制人理由来阻止静态成员（其他语言如C#允许这样做），Java设计者的动机可能是概念品味和/或技术便利性问题。
以下是我的推测：
与顶级类不同，内部类是实例相关的：一个内部类实例与其外部类的每个实例相关联，并直接访问它们的成员。这是Java中拥有它们的主要动机。换句话说：内部类是为了在外部类实例的上下文中实例化而设计的。没有外部类实例，内部类就不应该比外部类的其他实例成员更可用。让我们把这称为内部类的实例相关精神。另一方面，静态常量不涉及此类冒犯，因为它们没有实质性地构成状态，因此是允许的。为什么不禁止静态常量以实现最大的“依赖于实例的精神”一致性？也许是因为常量不需要占用比必要更多的内存（如果它们被强制为非静态，则将复制到每个内部类实例中，这可能是浪费的）。否则，我无法想象有例外的原因。
这可能不是牢固的推理，但在我看来，它对Oracle关于此问题的概略评论最有意义。
在添加记录到JDK16的工作中，还提到静态方法和字段现在可以与内部类一起使用，甚至允许main()启动该类。
例如，在JDK16中，以下代码可以编译并运行，并且可以选择将哪个main()作为java Outer或java Outer$Inner运行：
public class Outer {
public static void main(String[] args) {
System.out.println("Outer class main xxx="+Inner.xxx+" nnn="+(++Inner.nnn)+" iii="+(--iii));
aaa();
Inner.zzz();
}
public static void aaa() {
System.out.println("aaa() nnn="+(++Inner.nnn)+" iii="+(--iii));
}
public static int iii = 100;
class Inner {
public static final String xxx= "yyy";
public static int nnn = 0;
public static void zzz() {
System.out.println("zzz() "+" nnn="+(++nnn)+" iii="+(--iii));
}
public static void main(String[] args) {
System.out.println("Inner class main xxx="+xxx+" nnn="+(++nnn)+" iii="+(--iii));
zzz();
aaa();
}
}
}
class Outer {
int outID;
class Inner {
static int nextID;
int id = nextID++;
String getID() {
return outID + ":" + id;
}
}
}
Outer -> Inner -> getID()
这里再次强调，由于javac编译器的工作原理，"Outer"级别的作用域包括Outer类的静态和实例成员。这很令人困惑，因为通常我们会认为类的静态部分是作用域的另一个级别：
Outer static -> Outer instance -> instanceMethod()
\----> staticMethod()
Outer static -> Outer instance -> Inner instance -> getID()
\------ Inner static ------^
这个话题引起了很多人的关注，我会尽最大努力用最简单的语言来解释。
首先，参考http://docs.oracle.com/javase/specs/jls/se7/html/jls-12.html#jls-12.4.1，在任何以static关键字为前缀的成员的第一次出现/调用之前，类或接口会立即进行初始化。
因此，如果我们在内部类中放置一个静态成员，它将导致内部类的初始化，但不一定是外部/包含类。因此，我们破坏了类初始化顺序。
还要考虑到非静态内部类与外部类的实例相关联。因此，与实例相关联意味着内部类将存在于Outer类实例中，并且在实例之间将有所不同。
简化一下，为了访问静态成员，我们需要一个Outer类的实例，从中我们还需要创建一个非静态内部类的实例。静态成员不应绑定到实例，因此您会收到编译错误。
内部类与静态嵌套类完全不同，尽管两者在语法上相似。静态嵌套类只是一种分组的方式，而内部类具有强关联性，并且可以访问其外部类的所有值。您应该确信为什么要使用内部类，然后就应该很自然地知道要使用哪个类。如果需要声明一个静态方法，则可能需要使用静态嵌套类。