Java内部类与final关键字详解

内部类的几种创建方法：

1、成员内部类

[java] view plaincopy

1. class Outer{  
2.         private int i = 1;  
3.         class Inner{  
4.             public void fun() {System.out.println("Outer I=" + i)}  
5.         }  
6.     }  

[java] view plaincopy

1. class Outer{  
2.         private int i = 1;  
3.         class Inner{  
4.             public void fun() {System.out.println("Outer I=" + i)}  
5.         }  
6.     }  

2、方法内部类

[java] view plaincopy

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

[java] view plaincopy

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

3、匿名内部类

[java] view plaincopy

1. interface USB {  
2.         public abstract void start()  
3.     }  
4.     class Outer{  
5.         public void fun() {  
6.             final int i = 1; // 被匿名内部类访问的局部变量必须被final修饰  
7.             new USB(){  
8.                 @Override  
9.                 public void start(){  
10.                     System.out.println("local_var_i=" + i);  
11.                 }  
12.             }.start();  
13.         }  
14.     }  

[java] view plaincopy

1. interface USB {  
2.         public abstract void start()  
3.     }  
4.     class Outer{  
5.         public void fun() {  
6.             final int i = 1; // 被匿名内部类访问的局部变量必须被final修饰  
7.             new USB(){  
8.                 @Override  
9.                 public void start(){  
10.                     System.out.println("local_var_i=" + i);  
11.                 }  
12.             }.start();  
13.         }  
14.     }  

4、静态内部类

[java] view plaincopy

1. class Outer{  
2.         private int i = 1;  
3.         static class Inner{ // 不能访问外部类的非静态成员  
4.             public void fun() {}  
5.         }  
6.     }  

[java] view plaincopy

1. class Outer{  
2.         private int i = 1;  
3.         static class Inner{ // 不能访问外部类的非静态成员  
4.             public void fun() {}  
5.         }  
6.     }  

5、接口内部类

[java] view plaincopy

1. interface USB {  
2.         class Inner { // 默认是public static，即可以直接new USB.Inner();  
3.         }  
4.     }  

[java] view plaincopy

1. interface USB {  
2.         class Inner { // 默认是public static，即可以直接new USB.Inner();  
3.         }  
4.     }  

神马是内部类？

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

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

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

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

[java] view plaincopy

1. public class Body {  
2.     private class Heart { // 心脏  
3.         public void bloodSupply() {  
4.             // 供血...  
5.         }  
6.     }  
7.     private class Hepar { // 肝脏  
8.         public void Metabolism() {  
9.             // 代谢...  
10.         }  
11.     }  
12.     private class Spleen { // 脾脏  
13.         public void storageBlood() {  
14.             // 储血...  
15.         }  
16.     }  
17.     private class Stomach { //胃部  
18.         public void digest() {  
19.             // 消化...  
20.         }  
21.     }  
22.     private class Kidney { // 肾脏  
23.         public void dischargePoison() {  
24.             // 排毒...  
25.         }  
26.     }  
27. }  

[java] view plaincopy

1. public class Body {  
2.     private class Heart { // 心脏  
3.         public void bloodSupply() {  
4.             // 供血...  
5.         }  
6.     }  
7.     private class Hepar { // 肝脏  
8.         public void Metabolism() {  
9.             // 代谢...  
10.         }  
11.     }  
12.     private class Spleen { // 脾脏  
13.         public void storageBlood() {  
14.             // 储血...  
15.         }  
16.     }  
17.     private class Stomach { //胃部  
18.         public void digest() {  
19.             // 消化...  
20.         }  
21.     }  
22.     private class Kidney { // 肾脏  
23.         public void dischargePoison() {  
24.             // 排毒...  
25.         }  
26.     }  
27. }  

问题的引出<内部类访问外部类成员方式>：

因为可以访问外部私有成员，那问题也就诞生了，他是怎么访问的呢？

1：对于成员内部类来说，他会持有一份外部类当前对象的引用，Outer.this。
这样就可以调用外部类可见的方法跟成员变量，调用方法是通过持有的外部类引用去调用的。Outer.this.fun();
那对于private成员是如何去访问的呢？是通过编译器在外部类中生成的静态的access$0()方法来访问的。Outer.this.access$0(Outer);

2：对于方法内部类（匿名内部类）来说，因为内部类要访问所在方法中的局部变量，这时候用持有的外部类当前对象引用还能调用的到吗？
调不到了，那Java语言的设计者是这么来解决这个问题的：将局部变量复制一份给内部类使用，怎么复制的？在内部类初始化的时候通过构造方法传值的方式。
这样，内部类中会有一份复制的private修饰的成员变量。这样我就能访问了。但问题又来了，比如：

[java] view plaincopy

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

[java] view plaincopy

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

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

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


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


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


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

[java] view plaincopy

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

[java] view plaincopy

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

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

 

java中内部类的访问调用

分类： java2012-12-20 16:59 2079人阅读 评论(0) 收藏 举报

从Java1.1开始引入了内部类以来，它就引起了人们的激烈争论。其实任何优秀的语言特性用得不好就是滥用，内部类用得不好就会导致代码像迷宫一样，导致出现毫无重用的综合征。

1、内部类分为成员内部类、静态嵌套类、方法内部类、匿名内部类。
几种内部类的共性：
A、内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类命和$符号。
B、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。

2、成员内部类：形式如下
    class Outer {
        class Inner{}
    }       
编译上述代码会产生两个文件：Outer.class和Outer$Inner.class。
成员内部类内不允许有任何静态声明！下面代码不能通过编译。
    class Inner{
        static int a = 10;
    } 
能够访问成员内部类的唯一途径就是通过外部类的对象！

A、从外部类的非静态方法中实例化内部类对象。

    class Outer {
        private int i = 10;
        public void makeInner(){
            Inner in = new Inner();
            in.seeOuter();
        }
        class Inner{
            public void seeOuter(){
                System.out.print(i);
            }
        }
    }

表面上，我们并没有创建外部类的对象就实例化了内部类对象，和上面的话矛盾。事实上，如果不创建外部类对象也就不可能调用makeInner()方法，所以到头来还是要创建外部类对象的。
你可能试图把makeInner()方法修饰为静态方法，即static public void makeInner()。这样不创建外部类就可以实例化外部类了！但是在一个静态方法里能访问非静态成员和方法吗？显然不能。它没有this引用。没能跳出那条规则！但是如果在这个静态方法中实例化一个外部类对象，再用这个对象实例化外部类呢？完全可以！也就是下一条的内容。

B、从外部类的静态方法中实例化内部类对象。
    class Outer {
        private int i = 10;
        class Inner{
            public void seeOuter(){
                System.out.print(i);
            }
        }    
        public static void main(String[] args) {
            Outer out = new Outer();
            Outer.Inner in = out.new Inner();
            //Outer.Inner in = new Outer().new Inner();
            in.seeOuter();
        }
    }

被注释掉的那行是它上面两行的合并形式，一条简洁的语句。
对比一下：在外部类的非静态方法中实例化内部类对象是普通的new方式：Inner in = new Inner();
在外部类的静态方法中实例化内部类对象，必须先创建外部类对象：Outer.Inner in = new Outer().new Inner();

C、内部类的this引用。
普通的类可以用this引用当前的对象，内部类也是如此。但是假若内部类想引用外部类当前的对象呢？用“外部类名”.this；的形式,如下例的Outer.this。
    class Outer {
        class Inner{
            public void seeOuter(){
                System.out.println(this);
                System.out.println(Outer.this);
            }
        }
    }

D、成员内部类的修饰符。
对于普通的类，可用的修饰符有final、abstract、strictfp、public和默认的包访问。
但是成员内部类更像一个成员变量和方法。
可用的修饰符有：final、abstract、public、private、protected、strictfp和static。
一旦用static修饰内部类，它就变成静态内部类了。


3、方法内部类。
顾名思义，把类放在方法内。
    class Outer {
        public void doSomething(){
            class Inner{
                public void seeOuter(){
                }
            }    
        }
    }
A、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

B、方法内部类对象不能使用该内部类所在方法的非final局部变量。
因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。
下面是完整的例子：
    class Outer {
        public void doSomething(){
            final int a =10;
            class Inner{
                public void seeOuter(){
                    System.out.println(a);
                }
            }   
            Inner in = new Inner();
            in.seeOuter(); 
        }
        public static void main(String[] args) {
            Outer out = new Outer();
            out.doSomething();
        }
     }

C、方法内部类的修饰符。
与成员内部类不同，方法内部类更像一个局部变量。
可以用于修饰方法内部类的只有final和abstract。

D、静态方法内的方法内部类。
静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，即：只能访问外部类的静态成员。


4、匿名内部类。
顾名思义，没有名字的内部类。表面上看起来它们似乎有名字，实际那不是它们的名字。

A、继承式的匿名内部类。
    class Car {
        public void drive(){
            System.out.println("Driving a car!");
        }
    }
    
    class Test{
        public static void main(String[] args) {
            Car car = new Car(){
                public void drive(){
                    System.out.println("Driving another car!");
                }
            };
            car.drive();
        }
    }
结果输出了：Driving another car! Car引用变量不是引用Car对象，而是Car匿名子类的对象。
建立匿名内部类的关键点是重写父类的一个或多个方法。再强调一下，是重写父类的方法，而不是创建新的方法。因为用父类的引用不可能调用父类本身没有的方法！创建新的方法是多余的。简言之，参考多态。

B、接口式的匿名内部类。
    interface  Vehicle {
        public void drive();
    }
    
    class Test{
        public static void main(String[] args) {
            Vehicle v = new Vehicle(){
                public void drive(){
                    System.out.println("Driving a car!");
                }
            };
            v.drive();
        }
    }
上面的代码很怪，好像是在实例化一个接口。事实并非如此，接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。

C、参数式的匿名内部类。
class Bar{
    void doStuff(Foo f){}
}

interface Foo{
    void foo();
}

class Test{
    static void go(){
        Bar b = new Bar();
        b.doStuff(new Foo(){
            public void foo(){
                System.out.println("foofy");
            }
        });
    }
}


5、静态嵌套类。
从技术上讲，静态嵌套类不属于内部类。因为内部类与外部类共享一种特殊关系，更确切地说是对实例的共享关系。而静态嵌套类则没有上述关系。它只是位置在另一个类的内部，因此也被称为顶级嵌套类。
静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它。静态嵌套类不能访问外部类的成员和方法。
    class Outer{
        static class Inner{}
    }
    class Test {
        public static void main(String[] args){
            Outer.Inner n = new Outer.Inner();
        }
    }