blocks|key|1319408|text|由于内部类的实例与其外部类的实例隐式关联，因此它本身不能定义任何静态方法。由于静态嵌套类不能直接引用其封闭类中定义的实例变量或方法，因此只能通过对象引用使用它们，因此在静态嵌套类中声明静态方法是安全的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1319409|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Because an instance of an inner class is implicitly associated with an instance of its outer class, it cannot define any static methods itself. Since a static nested class cannot refer directly to instance variables or methods defined in its enclosing class, it can use them only through an object reference, it's safe to declare static methods in a static nested class.

blocks|key|1534654|text|内部类与静态嵌套类完全不同，尽管它们在语法上相似。静态嵌套类只是一种分组方式，而内部类具有很强的关联性，并且可以访问其外部类的所有值。你应该确定为什么你想要使用一个内部类，然后它应该是非常自然的，你必须使用哪一个。如果您需要声明一个静态方法，那么它很可能是您想要的静态嵌套类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1534655|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

An inner class is something completely different from a static nested class although both are similar in syntax. Static nested classes are only a means for grouping whereas inner classes have a strong association - and access to all values of - their outer class. You should be sure why you want to use an inner class and then it should come pretty natural which one you have to use. If you need to declare a static method it's probably a static nested class you want anyway.

blocks|key|1534697|text|允许在静态嵌套类上使用静态方法。例如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1534698|public+class+Outer+{

++public+static+class+Inner+{

++++public+static+void+method()+{

++++}
++}
}|code-block|syntax|javascript|1534699|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You are allowed static methods on static nested classes. For example

<pre><code>public class Outer {

 public static class Inner {

 public static void method() {

 }
 }
}
</code></pre>

blocks|key|1534794|text|假设有两个外部类的实例，它们都实例化了内部class.Now如果内部类有一个静态成员，那么它将只在堆中保留该成员的一个副本，这种情况下，外部类的两个对象都将引用这个副本&它们可以修改它，together.This可能会导致“脏读”的情况，因此为了防止这种情况，Java应用了这个restriction.Another来支持这个参数，java允许在这里使用最终的静态成员，那些值不能从任何外部类对象更改的成员。如果我错了，请告诉我。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1534795|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

suppose there are two instances of outer class &amp; they both have instantiated inner class.Now if inner class has one static member then it will keep only one copy of that member in heap area.In this case both objects of outer class will refer to this single copy &amp; they can alter it together.This can cause "Dirty read" situation hence to prevent this Java has applied this restriction.Another strong point to support this argument is that java allows final static members here, those whose values can't be changed from either of outer class object.
Please do let me if i am wrong.

blocks|key|1319645|text|唯一的原因是“不是必须的”，那么为什么还要费心去支持它呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1319646|从语法上讲，没有理由禁止内部类具有静态成员。尽管Inner的一个实例与Outer的一个实例相关联，但是如果java决定这样做的话，仍然可以使用Outer.Inner.myStatic来引用Inner的静态成员。|offset|length|style|CODE|1319647|如果您需要在所有Inner实例之间共享某些内容，只需将它们作为静态成员放入Outer即可。这并不比在Inner中使用静态成员更糟糕，在这种情况下，Outer仍然可以访问Inner的任何私有成员(不会改进封装)。|1319648|如果您需要在由一个outer对象创建的所有Inner实例之间共享某些内容，将它们作为普通成员放入Outer类中会更有意义。|1319649|我不同意“静态嵌套类几乎只是一个顶级类”的观点。我认为真正将静态嵌套类/内部类视为外部类的一部分会更好，因为它们可以访问外部类的私有成员。外部类的成员也是“内部类的成员”。因此不需要在内部类中支持静态成员。外部类中的一个普通/静态成员就足够了。|1319650|entityMap^0|0|O|5|Z|5|1Z|K|2M|5|0|8|5|11|5|1E|5|21|5|2C|5|0|9|5|L|5|1C|5|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]|$D|T|E|U|F|G]|$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@$D|10|E|11|F|G]|$D|12|E|13|F|G]|$D|14|E|15|F|G]|$D|16|E|17|F|G]|$D|18|E|19|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1A|8|@$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]|$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|1H|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|O|$]]

The only reason is "not a must", so why bother to support it?

Syntactically,there is no reason to prohibit an inner class from having static members. Although an instance of <code>Inner</code> is associated with an instance of <code>Outer</code>, it's still possible to use <code>Outer.Inner.myStatic</code> to refer a static member of <code>Inner</code> if java decides to do so.

If you need to share something among all the instances of <code>Inner</code>, you can just put them into <code>Outer</code> as static members. This is not worse than you use static members in <code>Inner</code>, where <code>Outer</code> can still access any private member of <code>Inner</code> anyway(does not improve encapsulation).

If you need to share something among all the instances of <code>Inner</code> created by one <code>outer</code> object,it makes more sense to put them into <code>Outer</code> class as ordinary members.

I don't agree the opinion that "a static nested class is pretty much just a top level class". I think its better to really regard a static nested class/inner class as a part of the outer class, because they can access outer class's private members. And members of outer class are "members of inner class" as well. So there is no need to support static member in inner class. An ordinary/static member in outer class will suffice.

blocks|key|1319775|text|将内部类成员设置为静态是没有用的，因为您一开始就无法访问它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1319776|想想看，要访问使用className.memberName的静态成员，在我们的例子中，它应该类似于outerclassName.innerclassName.memberName，，，现在你明白为什么内部类必须是静态的了吗……|1319777|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

It is useless to have inner class members as static because you won't be able to access them in the first place.

Think about this, to access a static member you use className.memberName ,, in our case , it should be something like outerclassName.innerclassName.memberName,,, now do you see why innerclass must be static....

blocks|key|1319846|text|首先，为什么有人要在非静态内部类中定义静态成员？答案是，这样外部类成员就可以使用那些只有内部类名的静态成员，对吧？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1319847|但是对于这种情况，我们可以直接在外部类中定义成员。它将与外部类实例中内部类的所有对象相关联。|1319848|就像下面的代码，|1319849|public+class+Outer+{

++class+Inner+{

++++public+static+void+method()+{

++++}

++}

}|code-block|syntax|javascript|1319850|可以写成这样|1319851|public+class+Outer+{

++void+method()+{

+++}

+++class+Inner+{


++}

}|1319852|因此，在我看来，为了不使代码复杂化，java+designer不允许使用此功能，否则我们可能会在将来的版本中看到此功能，并提供更多功能。|1319853|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

First of all why someone want to define the static member in a non-static inner class? answer is, so that the outer class member can use those static member with the inner class name only, Right?

But for this case we can directly define the member in outer class. which will be associated with all object of inner class, within the outer class instance.

like below code,

<pre><code>public class Outer {

 class Inner {

 public static void method() {

 }

 }

}
</code></pre>

can be written like this 

<pre><code>public class Outer {

 void method() {

 }

 class Inner {


 }

}
</code></pre>

So in my opinion not to complicate the code java designer is not allowing this functionality or we may see this functionality in future releases with some more features.

blocks|key|1319903|text|试着把这个类当作一个普通的字段，然后你就会明白了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1319904|//something+must+be+static.+Suppose+something+is+an+inner+class,+then+it+has+static+keyword+which+means+it's+a+static+class
Outer.something+|code-block|syntax|javascript|1319905|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try to treat the class as a normal field, then you will understand. 

<pre><code>//something must be static. Suppose something is an inner class, then it has static keyword which means it's a static class
Outer.something 
</code></pre>

blocks|key|1319965|text|向JDK16添加记录的工作还提到，静态方法和字段现在可以与内部类一起使用，甚至允许main()启动该类。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1319966|例如，这段代码在JDK16中编译和运行，并且可以选择作为java+Outer或java+Outer$Inner运行main()|1319967|public+class+Outer+{
++++public+static+void+main(String[]+args)+{
++++++++System.out.println("Outer+class+main+xxx="%2BInner.xxx%2B"+nnn="%2B(%2B%2BInner.nnn)%2B"+iii="%2B(--iii));
++++++++aaa();
++++++++Inner.zzz();
++++}
++++public+static+void+aaa()+{
++++++++System.out.println("aaa()+nnn="%2B(%2B%2BInner.nnn)%2B"+iii="%2B(--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()+"%2B"+nnn="%2B(%2B%2Bnnn)%2B"+iii="%2B(--iii));
++++++++}
++++++++public+static+void+main(String[]+args)+{
++++++++++++System.out.println("Inner+class+main+xxx="%2Bxxx%2B"+nnn="%2B(%2B%2Bnnn)%2B"+iii="%2B(--iii));
++++++++++++zzz();
++++++++++++aaa();
++++++++}
++++}
}|code-block|syntax|javascript|1319968|entityMap|0|LINK|mutability|MUTABLE|url|https://openjdk.java.net/jeps/395^0|15|6|1|5|0|0|S|A|13|G|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

The work to add records to <a href="https://openjdk.java.net/jeps/395" rel="nofollow noreferrer">JDK16</a> also mentions that static methods and fields can now be used with inner classes, even permitting <code>main()</code> to launch the class.
For example this compiles and runs in JDK16, and can select either main() to be run as <code>java Outer</code> or <code>java Outer$Inner</code>:
<pre><code>public class Outer {
 public static void main(String[] args) {
 System.out.println(&quot;Outer class main xxx=&quot;+Inner.xxx+&quot; nnn=&quot;+(++Inner.nnn)+&quot; iii=&quot;+(--iii));
 aaa();
 Inner.zzz();
 }
 public static void aaa() {
 System.out.println(&quot;aaa() nnn=&quot;+(++Inner.nnn)+&quot; iii=&quot;+(--iii));
 }
 public static int iii = 100;

 class Inner {
 public static final String xxx= &quot;yyy&quot;;
 public static int nnn = 0;

 public static void zzz() {
 System.out.println(&quot;zzz() &quot;+&quot; nnn=&quot;+(++nnn)+&quot; iii=&quot;+(--iii));
 }
 public static void main(String[] args) {
 System.out.println(&quot;Inner class main xxx=&quot;+xxx+&quot; nnn=&quot;+(++nnn)+&quot; iii=&quot;+(--iii));
 zzz();
 aaa();
 }
 }
}
</code></pre>

Why can't we have static method in a non-static inner class?
<pre><code>public class Foo {
 class Bar {
 static void method() {} // Compiler error
 }
}
</code></pre>
If I make the inner class static it works. Why?
<pre><code>public class Foo {
 static class Bar { // now static
 static void method() {}
 }
}
</code></pre>
In Java 16+, both of these are valid.

Why can't we have static method in a (non-static) inner class (pre-Java 16)?

Java

为什么我们不能在非静态内部类中使用静态方法呢？public class Foo {    class Bar {        static void method() {} // Compiler error    }}如果我把内部类设为静态的，它就能工作。为什么？public class Foo {    stat...

问为什么我们不能在(非静态)内部类中使用静态方法(Java 16之前的版本)？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我们不能在(非静态)内部类中使用静态方法(Java 16之前的版本)？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我们不能在(非静态)内部类中使用静态方法(Java 16之前的版本)？
EN