标签:限制 类方法 bst com 阅读 必须 table 引用类型 栈结构
1、成员内部类
1
2
3
4
5
6
|
class Outer{ private int i = 1 ; class Inner{ public void fun() {System.out.println( "Outer I=" + i)} } } |
2、方法内部类
1
2
3
4
5
6
7
8
|
class Outer{ public void fun() { final int i = 1 ; // 被方法内部类访问的局部变量必须被final修饰 class Inner{ // 方法内部类 不能有访问修饰符,比如public public void print() {System.out.println( "Method I=" + i)} } } } |
3、匿名内部类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
interface USB { public abstract void start() } class Outer{ public void fun() { final int i = 1 ; // 被匿名内部类访问的局部变量必须被final修饰 new USB(){ @Override public void start(){ System.out.println( "local_var_i=" + i); } }.start(); } } |
4、静态内部类
1
2
3
4
5
6
|
class Outer{ private int i = 1 ; static class Inner{ // 不能访问外部类的非静态成员 public void fun() { } } } |
5、接口内部类
1
2
3
4
|
interface USB { class Inner { // 默认是public static,即可以直接new USB.Inner(); } } |
乍一看,好些创建方式,挺复杂的吧?首先内部类是个啥东西?
定义:创建在一个类内部的类型。根据创建位置的不同,分为成员的、方法的、匿名的。接口中的内部类叫做接口内部类。
理解:在类的内部创建,那就是类的一部分,跟属性、方法同级。这也就解释了为何能访问外部私有成员,我是你的一部分,我当然可以访问了。
那问题来了,我是你的一部分,别人继承了外部类,会不会也把内部类也继承过去呢?这得从内部类设计的初衷与面向对象来探讨了。
比如我们用Body类来描述人体。如果是描述人类的话,会去描述人类具有的属性跟功能。
那现在我们描述人体,人体内部有心肝脾胃肾,这些再用属性来描述就不合适了吧?那怎么办呢?我们可以用内部类去描述。
所以,无论内部类是公开的还是私有的,都不会被继承,因为他不是属性,也不是方法。而是一个内部事务的描述,我们称之为内部类。
内部类可以更好地对内部事务进行封装,看例子:
身体类中,有属于身体的各个器官,各个器官有自己的功能与属性,于是我们把它封装成一个内部类去单独描述。
用来描述器官的内部类是身体的一部分,所以可以去自由的访问身体的资源(属性与功能),各个器官与身体相互协调完成运作。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
public class Body { private class Heart { // 心脏 public void bloodSupply() { // 供血... } } private class Hepar { // 肝脏 public void Metabolism() { // 代谢... } } private class Spleen { // 脾脏 public void storageBlood() { // 储血... } } private class Stomach { //胃部 public void digest() { // 消化... } } private class Kidney { // 肾脏 public void dischargePoison() { // 排毒... } } } |
因为可以访问外部私有成员,那问题也就诞生了,他是怎么访问的呢?
1:对于成员内部类来说,他会持有一份外部类当前对象的引用,Outer.this。
这样就可以调用外部类可见的方法跟成员变量,调用方法是通过持有的外部类引用去调用的。Outer.this.fun();
那对于private成员是如何去访问的呢?是通过编译器在外部类中生成的静态的access$0()方法来访问的。Outer.this.access$0(Outer);
2:对于方法内部类(匿名内部类)来说,因为内部类要访问所在方法中的局部变量,这时候用持有的外部类当前对象引用还能调用的到吗?
调不到了,那Java语言的设计者是这么来解决这个问题的:将局部变量复制一份给内部类使用,怎么复制的?在内部类初始化的时候通过构造方法传值的方式。
这样,内部类中会有一份复制的private修饰的成员变量。这样我就能访问了。但问题又来了,比如:
1
2
3
4
5
6
7
8
9
|
public void fun() { int i = 1 ; class Inner{ // int i = 1; 由编译器生成 publicvoid print() { i++ } } System.out.println( "i=" + i); // 还是会输出i=1,我们明明在内部类方法中对此变量进行++了啊。抱歉,您++的是被复制的另一份。 } |
好,问题就这么无情的出现了,怎么解决?Java又说了,要不然给局部变量加上final吧,这样就会保持值得一致性了。
ok,问题解决,这就是为什么方法内部类访问的局部变量必须被final修饰的终极原因(为了约束两个不同变量的一致性)。设计问题,挺无奈的解决方案。
来看看另一种说法:
在Java中,方法的局部变量位于栈上,对象位于堆上。
因为局部变量的范围被限制在该方法内,当一个方法结束时,栈结构被删除,该变量消失。
但是,定义在这个类中的内部类对象仍然存活在堆上,所以内部类对象不能使用局部变量。除非这些局部变量被标识为最终的。
这种说法是片面的,因为根本原因是内部类对象无法访问局部变量,才会去复制一份。
为了保证两个变量的一致性,才去使用final关键字修饰局部变量。而不是因为栈生命周期与堆生命周期不一致的问题。
用final关键字修饰对象变量,只是不允许这个对象引用再指向其他的对象,但是这个引用所指向的对象的内容是可以改变的
比如一个经典的例子:
1
2
3
|
final StringBuffer sb = new StringBuffer( "HelloWorld" ); sb = new StringBuffer( "Hello" ); // 编译失败,不能修改sb引用的指向 sb.append( "China" ); // sb指向的对象可以被修改。 |
其实从final的位置就看出来了,他是在修饰引用类型变量sb,而不是在修饰堆中的实例对象(new StringBuffer("HelloWorld");)
标签:限制 类方法 bst com 阅读 必须 table 引用类型 栈结构
原文地址:https://www.cnblogs.com/ldq2016/p/9650932.html