blocks|key|1396578|text|内部类(出于访问控制的目的)被认为是包含类的一部分。这意味着对所有私人的完全访问权限。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1396579|实现方法是使用合成的包保护方法:内部类将被编译为同一个包中的单独类(ABC$XYZ)。JVM不直接支持这种级别的隔离，因此在字节码级别，ABC$XYZ将具有外部类用来访问私有方法/字段的包保护方法。|1396580|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|$]]

The inner class is (for purposes of access control) considered to be part of the containing class. This means full access to all privates.

The way this is implemented is using synthetic package-protected methods: The inner class will be compiled to a separate class in the same package (ABC$XYZ). The JVM does not support this level of isolation directly, so that at the bytecode-level ABC$XYZ will have package-protected methods that the outer class uses to get to the private methods/fields.

blocks|key|1181187|text|访问限制是基于每个类进行的。在类中声明的方法不可能不能访问所有的实例/类成员。因此，内部类也可以不受限制地访问外部类的成员，外部类也可以不受限制地访问内部类的成员。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1181188|通过将一个类放在另一个类中，您可以将其与实现紧密地绑定在一起，并且任何属于实现的部分都应该能够访问其他部分。|1181189|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|$]]

Access restrictions are done on a per class basis. There is no way for a method declared in a class to not be able to access all of the instance/class members. It this stands to reason that inner classes also have unfettered access to the members of the outer class, and the outer class has unfettered access to the members of the inner class.

By putting a class inside another class you are making it tightly tied to the implementation, and anything that is part of the implementation should have access to the other parts.

blocks|key|1181238|text|内部类背后的逻辑是，如果您在外部类中创建内部类，这是因为它们将需要共享一些东西，因此它们能够比“常规”类具有更多的灵活性是有意义的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1181239|在您的例子中，如果两个类都不能看到彼此的内部工作-这基本上意味着内部类可以简单地变成一个常规类，那么您可以将内部类声明为static+class+XYZ。使用static将意味着它们不会共享状态(例如，new+ABC().new+XYZ()将无法工作，您将需要使用new+ABC.XYZ()。|offset|length|style|CODE|1181240|但是，如果是这样的话，你应该考虑XYZ是否真的应该是一个内部类，也许它应该有自己的文件。有时创建一个静态内部类是有意义的(例如，如果您需要一个小类来实现您的外部类正在使用的接口，而这在其他任何地方都没有帮助)。但在大约一半的时间里，它应该成为一个外部类。|1181241|entityMap^0|0|1O|G|27|6|2T|J|3O|D|0|G|3|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]|$D|R|E|S|F|G]|$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$]]

The logic behind inner classes is that if you create an inner class in an outer class, that's because they will need to share a few things, and thus it makes sense for them to be able to have more flexibility than "regular" classes have.

If, in your case, it makes no sense for the classes to be able to see each other's inner workings - which basically means that the inner class could simply have been made a regular class, you can declare the inner class as <code>static class XYZ</code>. Using <code>static</code> will mean they will not share state (and, for example <code>new ABC().new XYZ()</code> won't work, and you will need to use <code>new ABC.XYZ()</code>. 
But, if that's the case, you should think about whether <code>XYZ</code> should really be an inner class and that maybe it deserves its own file. Sometimes it makes sense to create a static inner class (for example, if you need a small class that implements an interface your outer class is using, and that won't be helpful anywhere else). But at about half of the time it should have been made an outer class.

blocks|key|1181291|text|内部类的一个重要用例是工厂模式。封闭的类可以准备一个没有访问限制的内部类的实例，并将该实例传递给将尊重私有访问的外部世界。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1181292|与abyx声明类静态不同，静态类不会更改对包含类的访问限制，如下所示。同样，同一封闭类中的静态类之间的访问限制也在起作用。我很惊讶。|offset|length|1181293|class+MyPrivates+{
++++static+class+Inner1+{+private+int+test1+=+2;+}
++++static+class+Inner2+{+private+int+test2+=+new+Inner1().test1;+}

++++public+static+void+main(String[]+args)+{
++++++++System.out.println("Inner+:+"%2Bnew+Inner2().test2);
++++}
}|code-block|syntax|javascript|1181294|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1801718/outer-java-class-is-able-to-access-inner-class-private-members/1801925#1801925^0|0|1|4|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|@$D|U|E|V|1|W]]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

An IMHO important use case for inner classes is the factory pattern.
The enclosing class may prepare an instance of the inner class w/o access restrictions and pass the instance to the outside world, where private access will be honored.

In contradiction to <a href="https://stackoverflow.com/questions/1801718/outer-java-class-is-able-to-access-inner-class-private-members/1801925#1801925" title="abyx">abyx</a> declaring the class static doesn't change access restrictions to the enclosing class, as shown below. Also the access restrictions between static classes in the same enclosing class are working. I was surprised ...

<pre><code>class MyPrivates {
 static class Inner1 { private int test1 = 2; }
 static class Inner2 { private int test2 = new Inner1().test1; }

 public static void main(String[] args) {
 System.out.println("Inner : "+new Inner2().test2);
 }
}
</code></pre>

blocks|key|1396814|text|如果您想隐藏内部类的私有成员，您可以定义一个具有公共成员的接口，并创建一个实现此接口的匿名内部类。示例如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1396815|class+ABC{
++++private+interface+MyInterface{
+++++++++void+printInt();
++++}

++++private+static+MyInterface+mMember+=+new+MyInterface(){
++++++++private+int+x=10;

++++++++public+void+printInt(){
++++++++++++System.out.println(String.valueOf(x));
++++++++}
++++};

++++public+static+void+main(String...+args){
++++++++System.out.println("Hello+::+"%2BmMember.x);+///not+allowed
++++++++mMember.printInt();+//+allowed
++++}
}|code-block|syntax|javascript|1396816|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|$]]

If you like to hide the private members of your inner class, you may define an Interface with the public members and create an anonymous inner class that implements this interface. Example bellow:

<pre><code>class ABC{
 private interface MyInterface{
 void printInt();
 }

 private static MyInterface mMember = new MyInterface(){
 private int x=10;

 public void printInt(){
 System.out.println(String.valueOf(x));
 }
 };

 public static void main(String... args){
 System.out.println("Hello :: "+mMember.x); ///not allowed
 mMember.printInt(); // allowed
 }
}
</code></pre>

blocks|key|1181495|text|Thilo为你的第一个问题“这怎么可能？”添加了一个很好的answer。我想对第二个被问到的问题做一点阐述:为什么允许这种行为？|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1181496|对于初学者来说，让我们非常清楚的是，这种行为并不局限于内部类，根据定义，内部类是非静态嵌套类型。所有嵌套类型都允许此行为，包括嵌套枚举和接口，它们必须是静态的，并且不能具有封闭实例。基本上，该模型是对以下语句的简化:嵌套代码可以完全访问封闭代码-反之亦然。|1181497|那么，为什么呢？我认为一个例子能更好地说明这一点。|1181498|想想你的身体和大脑。如果你在手臂上注射海洛因，你的大脑就会兴奋起来。如果你大脑的杏仁核区域看到他认为是对你个人安全的威胁，比如一只黄蜂，他会让你的身体转向另一个方向，跑向山丘，而你不会再“想”这一点。|1181499|因此，大脑是身体固有的一部分--奇怪的是，反过来也是如此。在这种紧密相关的实体之间使用访问控制将丧失其关系的权利。如果您确实需要访问控制，那么您需要将类更多地划分为真正不同的单元。在此之前，它们是同一个单元。进一步研究的一个驱动示例将是查看Java+Iterator通常是如何实现的。|style|CODE|1181500|从封闭代码到嵌套代码的无限制访问使得在大多数情况下，向嵌套类型的字段和方法添加访问修饰符是相当无用的。这样做会增加混乱，并可能给Java编程语言的新手带来一种错误的安全感。|1181501|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/1801801/1268003|1|http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html^0|T|6|0|0|0|0|0|3H|8|3H|8|1|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|16|8|@$A|17|B|18|L|M]]|9|@$A|19|B|1A|1|1B]]|C|$]]|$1|N|3|O|5|6|7|1C|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|Q|$R|$5|S|T|U|C|$V|W]]|X|$5|S|T|U|C|$V|Y]]]]

Thilo added a good <a href="https://stackoverflow.com/a/1801801/1268003">answer</a> for your first question "How is this possible?". I wish to elaborate a bit on the second asked question: Why is this behavior allowed?

For starters, let's just be perfectly clear that this behavior is not limited to inner classes, which by definition are non-static nested types. This behavior is allowed for all nested types, including nested enums and interfaces which must be static and cannot have an enclosing instance. Basically, the model is a simplification down to the following statement: Nested code have full access to enclosing code - and vice versa.

So, why then? I think an example illustrate the point better.

Think of your body and your brain. If you inject heroin into your arm, your brain gets high. If the amygdala region of your brain see what he believe is a threat to your personally safety, say a wasp for example, he'll make your body turn the other way around and run for the hills without You "thinking" twice about it.

So, the brain is an intrinsic part of the body - and strangely enough, the other way around too. Using access control between such closely related entities forfeit their claim of relationship. If you do need access control, then you need to separate the classes more into truly distinct units. Until then, they are the same unit. A driving example for further studies would be to look at how a Java <a href="http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html" rel="noreferrer"><code>Iterator</code></a> usually is implemented.

Unlimited access from enclosing code to nested code makes it, for the most part, rather useless to add access modifiers to fields and methods of a nested type. Doing so is adding clutter and might provide a false sense of safety for new comers of the Java programming language.

blocks|key|1181566|text|内部类被认为是外部类的一个属性。因此，无论内部类实例变量是否是私有的，外部类都可以像访问它的其他私有属性(变量)一样进行访问，而不会出现任何问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1181567|class+Outer{

private+int+a;

class+Inner{
private+int+b=0;
}

void+outMethod(){
a+=+new+Inner().b;
}
}|code-block|syntax|javascript|1181568|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|$]]

Inner class is regarded as an attribute of the Outer class. Therefore, no matter the Inner class instance variable is private or not, Outer class can access without any problem just like accessing its other private attributes(variables).

<pre><code>class Outer{

private int a;

class Inner{
private int b=0;
}

void outMethod(){
a = new Inner().b;
}
}
</code></pre>

I observed that Outer classes can access inner classes private instance variables. How is this possible? Here is a sample code demonstrating the same:

<pre><code>class ABC{
 class XYZ{
 private int x=10;
 }

 public static void main(String... args){
 ABC.XYZ xx = new ABC().new XYZ();
 System.out.println("Hello :: "+xx.x); ///Why is this allowed??
 }
}
</code></pre>

Why is this behavior allowed?

Why can outer Java classes access inner class private members?

Java

我观察到外部类可以访问内部类的私有实例变量。这怎麽可能？下面是一个示例代码，演示了这一点：class ABC{    class XYZ{        private int x=10;    }    public static void main(String... args){        ABC.XYZ x...

问为什么外部Java类可以访问内部类私有成员？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么外部Java类可以访问内部类私有成员？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么外部Java类可以访问内部类私有成员？
EN