【Java0001】Java之内部类与final关键字详解

来源：互联网发布：网络直播招聘骗局编辑：程序博客网时间：2024/05/20 23:58

内部类分类介绍：

1、成员内部类

[java] view plaincopy
class Outer{  
        private int i = 1;  
        class Inner{  
            public void fun() {System.out.println("Outer I=" + i)}  
        }  
    }  

2、方法内部类

[java] view plaincopy
class Outer{  
        public void fun() {  
            final int i = 1; // 被方法内部类访问的局部变量必须被final修饰  
            class Inner{ // 方法内部类 不能有访问修饰符，比如public   
                public void print() {System.out.println("Method I=" + i)}  
            }  
        }  
    }  

3、匿名内部类

[java] view plaincopy
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、静态内部类

[java] view plaincopy
class Outer{  
        private int i = 1;  
        static class Inner{ // 不能访问外部类的非静态成员  
            public void fun() {}  
        }  
    }  

5、接口内部类

[java] view plaincopy
interface USB {  
        class Inner { // 默认是public static，即可以直接new USB.Inner();  
        }  
    }  

什么是内部类？

乍一看，好些创建方式，挺复杂的吧？首先内部类是个啥东西？
定义：创建在一个类内部的类型。根据创建位置的不同，分为成员的、方法的、匿名的。接口中的内部类叫做接口内部类。
理解：在类的内部创建，那就是类的一部分，跟属性、方法同级。这也就解释了为何能访问外部私有成员，我是你的一部分，我当然可以访问了。

问题的引出<理解内部类>：

那问题来了，我是你的一部分，别人继承了外部类，会不会也把内部类也继承过去呢？这得从内部类设计的初衷与面向对象来探讨了。
比如我们用Body类来描述人体。如果是描述人类的话，会去描述人类具有的属性跟功能。
那现在我们描述人体，人体内部有心肝脾胃肾，这些再用属性来描述就不合适了吧？那怎么办呢？我们可以用内部类去描述。
所以，无论内部类是公开的还是私有的，都不会被继承，因为他不是属性，也不是方法。而是一个内部事务的描述，我们称之为内部类。
内部类可以更好地对内部事务进行封装，看例子：

身体类中，有属于身体的各个器官，各个器官有自己的功能与属性，于是我们把它封装成一个内部类去单独描述。
用来描述器官的内部类是身体的一部分，所以可以去自由的访问身体的资源(属性与功能)，各个器官与身体相互协调完成运作。

[java] view plaincopy
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修饰的成员变量。这样我就能访问了。但问题又来了，比如：

[java] view plaincopy
public void fun() {  
    int i = 1;  
    class Inner{  
        // int i = 1; 由编译器生成  
        public void print() { i++ }  
    }  
    System.out.println("i=" + i);   
    // 还是会输出i=1，我们明明在内部类方法中对此变量进行++了啊。抱歉，您++的是被复制的另一份。  
}  

[java] view plaincopy
public void fun() {  
    int i = 1;  
    class Inner{  
        // int i = 1; 由编译器生成  
        public void print() { i++ }  
    }  
    System.out.println("i=" + i);   
    // 还是会输出i=1，我们明明在内部类方法中对此变量进行++了啊。抱歉，您++的是被复制的另一份。  
}  

问题的引出<保持两个不同变量的一致性>：

好，问题就这么无情的出现了，怎么解决？Java又说了，要不然给局部变量加上final吧，这样就会保持值得一致性了。
ok，问题解决，这就是为什么方法内部类访问的局部变量必须被final修饰的终极原因（为了约束两个不同变量的一致性）。设计问题，挺无奈的解决方案。

来看看另一种说法：
在Java中，方法的局部变量位于栈上，对象位于堆上。
因为局部变量的范围被限制在该方法内，当一个方法结束时，栈结构被删除，该变量消失。
但是，定义在这个类中的内部类对象仍然存活在堆上，所以内部类对象不能使用局部变量。除非这些局部变量被标识为最终的。

这种说法是片面的，因为根本原因是内部类对象无法访问局部变量，才会去复制一份。
为了保证两个变量的一致性，才去使用final关键字修饰局部变量。而不是因为栈生命周期与堆生命周期不一致的问题。

最后来说说final关键字：
用final关键字修饰对象变量，只是不允许这个对象引用再指向其他的对象，但是这个引用所指向的对象的内容是可以改变的
比如一个经典的例子：

[java] view plaincopy
final StringBuffer sb = new StringBuffer("HelloWorld");  
sb = new StringBuffer("Hello"); // 编译失败，不能修改sb引用的指向  
sb.append("China"); // sb指向的对象可以被修改。  

[java] view plaincopy
final StringBuffer sb = new StringBuffer("HelloWorld");  
sb = new StringBuffer("Hello"); // 编译失败，不能修改sb引用的指向  
sb.append("China"); // sb指向的对象可以被修改。  

其实从final的位置就看出来了，他是在修饰引用类型变量sb，而不是在修饰堆中的实例对象（new StringBuffer("HelloWorld");）

0 0