在java编程中,使用private关键字修饰了某个成员,只有这个成员所在的类和这个类的方法可以使用,其他的类都无法访问到这个private成员。
上面描述了private修饰符的基本职能,今天来研究一下private功能失效的情况。
java内部类
在java中相信很多人都用过内部类,java允许在一个类里面定义另一个类,类里面的类就是内部类,也叫做嵌套类。一个简单的内部类实现可以如下
第一次失效?
一个我们在编程中经常用到的场景,就是在一个内部类里面访问外部类的private成员变量或者方法,这是可以的。如下面的代码实现。
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();
}
}
编译器在捣鬼?
我们使用javap命令查看一下生成的两个class文件
outerclass的反编译结果
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
}
outerclass$innerclass的反编译结果
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
}
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等)来获取这些属性值。这一切都是编译器的特殊处理。
这次也失效?
如果说上面的写法很常用,那么这样的写法是不是很少接触,但是却可以运行。
class innerclass {
private int x = 10;
}
}
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
}
anotherouterclass.class的反编译结果
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
}
其中java官方文档 有这样一句话
如何让内部类私有成员不被外部访问
相信看完上面两部分,你会觉得,内部类的私有成员想不被外部类访问都很困难吧,谁让编译器“爱管闲事”呢,其实也是可以做到的。那就是使用匿名内部类。
由于mrunnable对象的类型为runnable,而不是匿名内部类的类型(我们无法正常拿到),而runanble中没有x这个属性,所以mrunnable.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++不一样。
如对本文有疑问, 点击进行留言回复!!
Springboot项目因为kackson版本问题启动报错解决方案
Java多线程下的其他组件之CyclicBarrier、Callable、Future和FutureTask详解
网友评论