广场首页
IT技术
新闻资讯
职场百科
米堆
考试培训
明椿
课程
公考编制资格证专本学历IT互联网研究生副业大学生品质生活课
高手Club
我的课程
登录
免费注册
IT技术JavaJava教程正文

Java教程：“失效”的private修饰符

开课吧开课吧锤锤2021-07-14 14:02

使用private关键字来修饰Java编程中的成员，只有该成员所在的类和该类的方法可以使用，而没有其他的类访问该private成员。前面介绍了private修饰符的基本功能，今天就来看看private功能失效的情况。  

“失效”的private修饰符

Java内部类  

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

class OuterClass {
    class InnerClass{
    }
}

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

第一次失效?  

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

public class OuterClass {
  private String language = "en";
  private String region = "US";
 
  public class InnerClass {
      public void printOuterClassPrivateFields() {
          String fields = "language=" + language + 

";region=" + region;

          System.out.println(fields);
      }
  }
 
  public static void main(String[] args) {
      OuterClass outer = new OuterClass();
      OuterClass.InnerClass inner = 

outer.new InnerClass();

      inner.printOuterClassPrivateFields();
  }
}

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

private真的失效了么？  

编译器在捣鬼？  

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

OuterClass的反编译结果 。 

15:30 $ javap -c  OuterClass
Compiled from "OuterClass.java"
public class OuterClass extends java.lang.Object{
public OuterClass();
  Code:
   0:  aload_0
   1:  invokespecial    #11; 

//Method java/lang/Object."<init>":()V

   4:  aload_0
   5:  ldc  #13; //String en
   7:  putfield #15; 

//Field language:Ljava/lang/String;

   10: aload_0
   11: ldc  #17; //String US
   13: putfield #19; 

//Field region:Ljava/lang/String;

   16: return
 
public static void main(java.lang.String[]);
  Code:
   0:  new  #1; //class OuterClass
   3:  dup
   4:  invokespecial    #27; //Method "<init>":()V
   7:  astore_1
   8:  new  #28; //class OuterClass$InnerClass
   11: dup
   12: aload_1
   13: dup
   14: invokevirtual    #30; //Method java/lang/Object.getClass:()Ljava/lang/Class;
   17: pop
   18: invokespecial    #34; //Method OuterClass$InnerClass."<init>":(LOuterClass;)V
   21: astore_2
   22: aload_2
   23: invokevirtual    #37; //Method OuterClass$InnerClass.printOuterClassPrivateFields:()V
   26: return
 
static java.lang.String access$0(OuterClass);
  Code:
   0:  aload_0
   1:  getfield #15; //Field language:Ljava/lang/String;
   4:  areturn
 
static java.lang.String access$1(OuterClass);
  Code:
   0:  aload_0
   1:  getfield #19; //Field region:Ljava/lang/String;
   4:  areturn
 
}

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

static java.lang.String access$0(OuterClass);
  Code:
   0:  aload_0
   1:  getfield #15; //Field language:Ljava/lang/String;
   4:  areturn
 
static java.lang.String access$1(OuterClass);
  Code:
   0:  aload_0
   1:  getfield #19; //Field region:Ljava/lang/String;
   4:  areturn
 
}

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

OuterClass$InnerClass的反编译结果。  

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

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

13:   invokestatic #27; //Method OuterClass.access$0:(LOuterClass;)L

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

28:   invokestatic #39; //Method OuterClass.access$1:(LOuterClass;)Lj

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

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

final OuterClass this$0;
 
public OuterClass$InnerClass(OuterClass);
  Code:
   0:  aload_0
   1:  aload_1
   2:  putfield #10; //Field this$0:LOuterClass;
   5:  aload_0
   6:  invokespecial    #12; //Method java/lang/Object."<init>":()V
   9:  return

小结  

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

这次也失效？  

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

public class AnotherOuterClass {
  public static void main(String[] args) {
      InnerClass inner = 

new AnotherOuterClass().new InnerClass();

      System.out.println

("InnerClass Filed = " + inner.x);

  }
 
  class InnerClass {
      private int x = 10;
  }
 
}

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

16:03 $ javap -c AnotherOuterClass\$InnerClass
Compiled from "AnotherOuterClass.java"
class AnotherOuterClass$InnerClass extends 

java.lang.Object{

final AnotherOuterClass this$0;
 
AnotherOuterClass$InnerClass(AnotherOuterClass);
  Code:
   0:  aload_0
   1:  aload_1
   2:  putfield #12; //Field this$0:LAnotherOuterClass;
   5:  aload_0
   6:  invokespecial    #14; //Method java/lang/Object."<init>":()V
   9:  aload_0
   10: bipush   10
   12: putfield #17; //Field x:I
   15: return
 
static int access$0(AnotherOuterClass$InnerClass);
  Code:
   0:  aload_0
   1:  getfield #17; //Field x:I
   4:  ireturn
 
}

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

AnotherOuterClass.class的反编译结果。

 

16:08 $ javap -c AnotherOuterClass
Compiled from "AnotherOuterClass.java"
public class AnotherOuterClass extends 

java.lang.Object{

public AnotherOuterClass();
  Code:
   0:  aload_0
   1:  invokespecial    #8; //Method java/lang/Object."<init>":()V
   4:  return
 
public static void main(java.lang.String[]);
  Code:
   0:  new  #16; //class AnotherOuterClass$InnerClass
   3:  dup
   4:  new  #1; //class AnotherOuterClass
   7:  dup
   8:  invokespecial    #18; //Method "<init>":()V
   11: dup
   12: invokevirtual    #19; //Method java/lang/Object.getClass:()Ljava/lang/Class;
   15: pop
   16: invokespecial    #23; //Method AnotherOuterClass$InnerClass."<init>":(LAnotherOuterClass;)V
   19: astore_1
   20: getstatic    #26; //Field java/lang/System.out:Ljava/io/PrintStream;
   23: new  #32; //class java/lang/StringBuilder
   26: dup
   27: ldc  #34; //String InnerClass Filed =
   29: invokespecial    #36; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
   32: aload_1
   33: invokestatic #39; //Method AnotherOuterClass$InnerClass.access$0:(LAnotherOuterClass$InnerClass;)I
   36: invokevirtual    #43; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
   39: invokevirtual    #47; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   42: invokevirtual    #51; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   45: return
 
}

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

33:   invokestatic #39; 

//Method AnotherOuterClass$InnerClass.access$0:(LAnotherOuterClass$I

再来个总结  

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

ifthememberorconstructorisdeclaredprivate,thenaccessispermittedifandonlyifitoccurswithinthebodyofthetoplevelclass(§7.6)thatenclosesthedeclarationofthememberorconstructor.  

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

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

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

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

public class PrivateToOuter {
  Runnable mRunnable = new Runnable(){
      private int x=10;
      @Override
      public void run() {
          System.out.println(x);
      }
  };
 
  public static void main(String[] args){
      PrivateToOuter p = new PrivateToOuter();
      //System.out.println("anonymous class private filed= "+ p.mRunnable.x); //not allowed
      p.mRunnable.run(); // allowed
  }
}

最后总结  

在本文中，private表面上看上去失效了，但实际上是没有的，而是在调用时通过间接的方法来获取私有的属性。  

Java的内部类构造时持有对外部类的应用，C++不会，这一点和C++不一样。  

以上内容由开课吧小编为大家整理发布的“Java教程：“失效”的private修饰符”一文，更多Java教程相关内容尽在开课吧广场Java教程频道。

免责声明：本站所提供的内容均来源于网友提供或网络搜集，由本站编辑整理，仅供个人研究、交流学习使用。如涉及版权问题，请联系本站管理员予以更改或删除。
有用
分享
标签：
Java修饰符Java修饰词修饰符
上一篇
初级Java教程：fianl修饰符
初级Java教程：fianl修饰符
Java入门教程：删除链表中数据
Java入门教程：删除链表中数据
下一篇

相关文章

关于在ReactOS上使用C/C++和C#的OpenGL信息
关于在ReactOS上使用C/C++和C#的OpenGL信息
2021-04-02 17:20
SpringBoot项目中引入支付功能要怎么做呢？（三）
SpringBoot项目中引入支付功能要怎么做呢？（三）
2021-04-07 11:11
使用U++的简单多请求Web爬网程序
使用U++的简单多请求Web爬网程序
2021-04-29 11:26
如何在Servlet中调用RESTfulAPIWeb服务
如何在Servlet中调用RESTfulAPIWeb服务
2021-05-20 16:59
一文解析Java数据类型和变量
一文解析Java数据类型和变量
2021-07-07 18:08
SpringBoot源码解析（三）
SpringBoot源码解析（三）
2021-07-22 15:01
全部评论快来秀出你的观点
登录 后可发表观点…
发表
暂无评论，快来抢沙发！
高并发编程训练营

最新文章

开课吧严正声明
开课吧严正声明
2022-07-05 19:19
6月份你还没有定下来目标院校会影响复习吗？
6月份你还没有定下来目标院校会影响复习吗？
2022-06-23 17:17
职场人怎么提高自己的表达能力？
职场人怎么提高自己的表达能力？
2022-06-23 17:17
职场中如果遇见不顺心怎么去发泄？
职场中如果遇见不顺心怎么去发泄？
2022-06-23 17:17
你知道职场人怎么才能有效地控制自己的情绪吗?
你知道职场人怎么才能有效地控制自己的情绪吗?
2022-06-23 17:17
建议职场新人收藏：面试求职者的流程以及技巧有哪些？
建议职场新人收藏：面试求职者的流程以及技巧有哪些？
2022-06-23 17:17