设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Java中”失效”的private修饰符解析

2016-12-20 13:13| 发布者: zhangjf| 查看: 502| 评论: 0

摘要: 在java编程中，使用private关键字修饰了某个成员，只有这个成员所在的类和这个类的方法可以使用，其他的类都无法访问到这个private成员。 上面描述了private修饰符的基本职能，今天来研究一下private功能失效的情 ...

在java编程中，使用private关键字修饰了某个成员，只有这个成员所在的类和这个类的方法可以使用，其他的类都无法访问到这个private成员。

上面描述了private修饰符的基本职能，今天来研究一下private功能失效的情况。

Java内部类

在Java中相信很多人都用过内部类，Java允许在一个类里面定义另一个类，类里面的类就是内部类，也叫做嵌套类。一个简单的内部类实现可以如下

  1. class OuterClass {
  2. class InnerClass{
  3. }
  4. }
复制代码

今天的问题和Java内部类相关，只涉及到部分和本文研究相关的内部类知识，具体关于Java内部类后续的文章会介绍。

第一次失效?

一个我们在编程中经常用到的场景，就是在一个内部类里面访问外部类的private成员变量或者方法，这是可以的。如下面的代码实现。

  1. public class OuterClass {
  2. private String language = "en";
  3. private String region = "US";
  5. public class InnerClass {
  6. public void printOuterClassPrivateFields() {
  7. String fields = "language=" + language + ";region=" + region;
  8. System.out.println(fields);
  9. }
  10. }
  12. public static void main(String[] args) {
  13. OuterClass outer = new OuterClass();
  14. OuterClass.InnerClass inner = outer.new InnerClass();
  15. inner.printOuterClassPrivateFields();
  16. }
  17. }
复制代码

这是为什么呢，不是private修饰的成员只能被成员所述的类才能访问么？难道private真的失效了么？

编译器在捣鬼？

我们使用javap命令查看一下生成的两个class文件

OuterClass的反编译结果

  1. 15:30 $ javap -c OuterClass
  2. Compiled from "OuterClass.java"
  3. public class OuterClass extends java.lang.Object{
  4. public OuterClass();
  5. Code:
  6. 0: aload_0
  7. 1: invokespecial #11; //Method java/lang/Object."<init>":()V
  8. 4: aload_0
  9. 5: ldc #13; //String en
  10. 7: putfield #15; //Field language:Ljava/lang/String;
  11. 10: aload_0
  12. 11: ldc #17; //String US
  13. 13: putfield #19; //Field region:Ljava/lang/String;
  14. 16: return
  16. public static void main(java.lang.String[]);
  17. Code:
  18. 0: new #1; //class OuterClass
  19. 3: dup
  20. 4: invokespecial #27; //Method "<init>":()V
  21. 7: astore_1
  22. 8: new #28; //class OuterClass$InnerClass
  23. 11: dup
  24. 12: aload_1
  25. 13: dup
  26. 14: invokevirtual #30; //Method java/lang/Object.getClass:()Ljava/lang/Class;
  27. 17: pop
  28. 18: invokespecial #34; //Method OuterClass$InnerClass."<init>":(LOuterClass;)V
  29. 21: astore_2
  30. 22: aload_2
  31. 23: invokevirtual #37; //Method OuterClass$InnerClass.printOuterClassPrivateFields:()V
  32. 26: return
  34. static java.lang.String access$0(OuterClass);
  35. Code:
  36. 0: aload_0
  37. 1: getfield #15; //Field language:Ljava/lang/String;
  38. 4: areturn
  40. static java.lang.String access$1(OuterClass);
  41. Code:
  42. 0: aload_0
  43. 1: getfield #19; //Field region:Ljava/lang/String;
  44. 4: areturn
  46. }
复制代码

咦？不对，在OuterClass中我们并没有定义这两个方法

  1. static java.lang.String access$0(OuterClass);
  2. Code:
  3. 0: aload_0
  4. 1: getfield #15; //Field language:Ljava/lang/String;
  5. 4: areturn
  7. static java.lang.String access$1(OuterClass);
  8. Code:
  9. 0: aload_0
  10. 1: getfield #19; //Field region:Ljava/lang/String;
  11. 4: areturn
  13. }
复制代码

从给出来的注释来看，access$0返回outerClass的language属性；access$1返回outerClass的region 属性。并且这两个方法都接受OuterClass的实例作为参数。这两个方法为什么生成呢，有什么作用呢？我们看一下内部类的反编译结果就知道了。

OuterClass$InnerClass的反编译结果

  1. 15:37 $ javap -c OuterClass$InnerClass
  2. Compiled from "OuterClass.java"
  3. public class OuterClass$InnerClass extends java.lang.Object{
  4. final OuterClass this$0;
  6. public OuterClass$InnerClass(OuterClass);
  7. Code:
  8. 0: aload_0
  9. 1: aload_1
  10. 2: putfield #10; //Field this$0:LOuterClass;
  11. 5: aload_0
  12. 6: invokespecial #12; //Method java/lang/Object."<init>":()V
  13. 9: return
  15. public void printOuterClassPrivateFields();
  16. Code:
  17. 0: new #20; //class java/lang/StringBuilder
  18. 3: dup
  19. 4: ldc #22; //String language=
  20. 6: invokespecial #24; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
  21. 9: aload_0
  22. 10: getfield #10; //Field this$0:LOuterClass;
  23. 13: invokestatic #27; //Method OuterClass.access$0:(LOuterClass;)Ljava/lang/String;
  24. 16: invokevirtual #33; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  25. 19: ldc #37; //String ;region=
  26. 21: invokevirtual #33; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  27. 24: aload_0
  28. 25: getfield #10; //Field this$0:LOuterClass;
  29. 28: invokestatic #39; //Method OuterClass.access$1:(LOuterClass;)Ljava/lang/String;
  30. 31: invokevirtual #33; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  31. 34: invokevirtual #42; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
  32. 37: astore_1
  33. 38: getstatic #46; //Field java/lang/System.out:Ljava/io/PrintStream;
  34. 41: aload_1
  35. 42: invokevirtual #52; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
  36. 45: return
  37. }
复制代码

下面代码调用access$0的代码,其目的是得到OuterClass的language 私有属性。

  1. 13: invokestatic #27; //Method OuterClass.access$0:(LOuterClass;)Ljava/lang/String;
复制代码

下面代码调用了access$1的代码，其目的是得到OutherClass的region 私有属性。

  1. 28: invokestatic #39; //Method OuterClass.access$1:(LOuterClass;)Ljava/lang/String;
复制代码

注意：在内部类构造的时候，会将外部类的引用传递进来，并且作为内部类的一个属性，所以内部类会持有一个其外部类的引用。

this$0就是内部类持有的外部类引用，通过构造方法传递引用并赋值。

  1. final OuterClass this$0;
  3. public OuterClass$InnerClass(OuterClass);
  4. Code:
  5. 0: aload_0
  6. 1: aload_1
  7. 2: putfield #10; //Field this$0:LOuterClass;
  8. 5: aload_0
  9. 6: invokespecial #12; //Method java/lang/Object."<init>":()V
  10. 9: return
复制代码
小结

这部分private看上去失效可，实际上并没有失效，因为当内部类调用外部类的私有属性时，其真正的执行是调用了编译器生成的属性的静态方法（即acess$0,access$1等）来获取这些属性值。这一切都是编译器的特殊处理。

这次也失效？

如果说上面的写法很常用，那么这样的写法是不是很少接触，但是却可以运行。

  1. public class AnotherOuterClass {
  2. public static void main(String[] args) {
  3. InnerClass inner = new AnotherOuterClass().new InnerClass();
  4. System.out.println("InnerClass Filed = " + inner.x);
  5. }
  7. class InnerClass {
  8. private int x = 10;
  9. }
  11. }
复制代码

和上面一样，使用javap反编译看一下。不过这次我们先看一下InnerClass的结果

  1. 16:03 $ javap -c AnotherOuterClass$InnerClass
  2. Compiled from "AnotherOuterClass.java"
  3. class AnotherOuterClass$InnerClass extends java.lang.Object{
  4. final AnotherOuterClass this$0;
  6. AnotherOuterClass$InnerClass(AnotherOuterClass);
  7. Code:
  8. 0: aload_0
  9. 1: aload_1
  10. 2: putfield #12; //Field this$0:LAnotherOuterClass;
  11. 5: aload_0
  12. 6: invokespecial #14; //Method java/lang/Object."<init>":()V
  13. 9: aload_0
  14. 10: bipush 10
  15. 12: putfield #17; //Field x:I
  16. 15: return
  18. static int access$0(AnotherOuterClass$InnerClass);
  19. Code:
  20. 0: aload_0
  21. 1: getfield #17; //Field x:I
  22. 4: ireturn
  24. }
复制代码

又出现了，编译器又自动生成了一个获取私有属性的后门方法access$0一次来获取x的值。

AnotherOuterClass.class的反编译结果

  1. 16:08 $ javap -c AnotherOuterClass
  2. Compiled from "AnotherOuterClass.java"
  3. public class AnotherOuterClass extends java.lang.Object{
  4. public AnotherOuterClass();
  5. Code:
  6. 0: aload_0
  7. 1: invokespecial #8; //Method java/lang/Object."<init>":()V
  8. 4: return
  10. public static void main(java.lang.String[]);
  11. Code:
  12. 0: new #16; //class AnotherOuterClass$InnerClass
  13. 3: dup
  14. 4: new #1; //class AnotherOuterClass
  15. 7: dup
  16. 8: invokespecial #18; //Method "<init>":()V
  17. 11: dup
  18. 12: invokevirtual #19; //Method java/lang/Object.getClass:()Ljava/lang/Class;
  19. 15: pop
  20. 16: invokespecial #23; //Method AnotherOuterClass$InnerClass."<init>":(LAnotherOuterClass;)V
  21. 19: astore_1
  22. 20: getstatic #26; //Field java/lang/System.out:Ljava/io/PrintStream;
  23. 23: new #32; //class java/lang/StringBuilder
  24. 26: dup
  25. 27: ldc #34; //String InnerClass Filed =
  26. 29: invokespecial #36; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
  27. 32: aload_1
  28. 33: invokestatic #39; //Method AnotherOuterClass$InnerClass.access$0:(LAnotherOuterClass$InnerClass;)I
  29. 36: invokevirtual #43; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
  30. 39: invokevirtual #47; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
  31. 42: invokevirtual #51; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
  32. 45: return
  34. }
复制代码

其中这句调用就是外部类通过内部类的实例获取私有属性x的操作

  1. 33: invokestatic #39; //Method AnotherOuterClass$InnerClass.access$0:(LAnotherOuterClass$InnerClass;)I
复制代码
再来个总结

其中java官方文档 有这样一句话

意思是 如果（内部类的）成员和构造方法设定成了私有修饰符，当且仅当其外部类访问时是允许的。

如何让内部类私有成员不被外部访问

相信看完上面两部分，你会觉得，内部类的私有成员想不被外部类访问都很困难吧，谁让编译器“爱管闲事”呢，其实也是可以做到的。那就是使用匿名内部类。

由于mRunnable对象的类型为Runnable，而不是匿名内部类的类型（我们无法正常拿到），而Runanble中没有x这个属性，所以mRunnable.x是不被允许的。

  1. public class PrivateToOuter {
  2. Runnable mRunnable = new Runnable(){
  3. private int x=10;
  4. @Override
  5. public void run() {
  6. System.out.println(x);
  7. }
  8. };
  10. public static void main(String[] args){
  11. PrivateToOuter p = new PrivateToOuter();
  12. //System.out.println("anonymous class private filed= "+ p.mRunnable.x); //not allowed
  13. p.mRunnable.run(); // allowed
  14. }
  15. }
复制代码
最后总结 在本文中，private表面上看上去失效了，但实际上是没有的，而是在调用时通过间接的方法来获取私有的属性。 Java的内部类构造时持有对外部类的应用，C++不会，这一点和C++不一样。

来源：技术小黑屋

收藏 邀请
上一篇：Java多线程发展简史下一篇：优化Java中的多态代码

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-10-31 08:35

Copyright 2015-2025 djqfx

返回顶部