Java内部类

一、内部类概念

为了完善多重继承、方便事件回调实现，线程编写等原因，Java语言引入了内部类，可以在类的内部再定义内部类。其中内部类又分为成员内部类、静态内部类，局部内部类、（局部）匿名内部类。

成员内部类：直接定义在类内，定义中不能存在任何static的变量和方法；private修饰时只能在类内访问，public修饰类外访问时要先实例化外部类对象后再实例化内部类对象。它可以无限制访问外部类所有的属性和方法。一般在生成内部类对象时才加载。

静态内部类：直接定义在类内且通过static修饰，不能访问外部类非静态成员或方法，它的创建不依赖外部类对象。

局部内部类：定义在类的方法内，不能用除了final或abstract之外的关键字修饰，只在方法内部访问。

匿名内部类：定义在类的方法内，是没有名称、构造函数的局部内部类，在写回调事件监听、线程时常用。

使用内部类最大的优点就在于它能够非常好的解决多重继承的问题，但是如果我们不需要解决多重继承问题，那么我们自然可以使用其他的编码方式，但是使用内部类还能够为我们带来如下特性（摘自《Think in java》）：

  1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。

2、在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。

3、创建内部类对象的时刻并不依赖于外围类对象的创建。

4、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。

5、内部类提供了更好的封装，除了该外围类，其他类都不能访问。

内部类是个编译时的概念，一旦编译成功后，它就与外围类属于两个完全不同的类（当然他们之间还是有联系的）。对于一个名为OuterClass的外围类和一个名为InnerClass的内部类，在编译成功后，会出现这样两个class文件：OuterClass.class和OuterClass$InnerClass.class。

http://www.cnblogs.com/chenssy/p/3388487.html

内部类有两种情况：
(1) 在类中定义一个类(私有内部类，静态内部类)
(2) 在方法中定义一个类(局部内部类，匿名内部类)

//(内部类可以访问外部类的所有成员变量和方法) 
class Outer{ 
//外部类私有数据域 
private int data=0; 

//内部类 
class Inner{ 
void print(){ 
//内部类访问外部私有数据域 
System.out.println(data); 
} 
} 
} 

其实，内部类是Java编译器一手操办的。虚拟机并不知道内部类与常规类有什么不同。 编译器是如何瞒住虚拟机的呢？
对内部类进行编译后发现有两个class文件：Outer.class 和Outer$Inner.class 。这说明内部类Inner仍然被编译成一个独立的类(Outer$Inner.class)，而不是Outer类的某一个域。 虚拟机运行的时候，也是把Inner作为一种常规类来处理的。
首先编译器将外、内部类编译后放在同一个包中。在内部类中附加一个包可见构造器。这样， 虚拟机运行Outer类中Inner in=new Inner(); 实际上调用的是包可见构造： new Outer$Inner(this,null)。因此即使是private内部类，也会通过隐含的包可见构造器成功的获得私有内部类的构造权限。
再者，Outer$Inner类中有一个指向外部类Outer的引用this$0，那么通过这个引用就可以方便的得到外部类对象中可见成员。
在外围类中添加了静态方法access$0。 它将返回值作为参数传递给他的对象域data。这样内部类Inner中的打印语句：
System.out.println(data);
实际上运行的时候调用的是：
System.out.println(this$0.access$0(Outer));
总结一下编译器对类中内部类做的手脚吧：
(1) 在内部类中偷偷摸摸的创建了包可见构造器，从而使外部类获得了创建权限。
(2) 在外部类中偷偷摸摸的创建了访问私有变量的静态方法，从而 使 内部类获得了访问权限。
这样，类中定义的内部类无论私有，公有，静态都可以被包围它的外部类所访问。

public class Outer{ 
private static int i=0; 

//创建静态内部类对象 
public Inner in=new Inner(); 

//静态内部类 
private static class Inner{ 
public void print(){ 
System.out.println(i); //如果i不是静态变量，这里将无法通过编译 
} 
} 
} 

与上面私有内部类反编译1比较发现，少了一个指向外围类对象的引用final Outer this$0; 也就是说静态内部类无法得到其外围类对象的引用，那么自然也就无法访问外围类的非静态成员了。因此，静态内部类只能访问其外围类的静态成员，除此之外与非静态内部类没有任何区别。
局部内部类 —— 在方法中定义的内部类
方法内部类也有两个特点
(1) 方法中的内部类没有访问修饰符， 即方法内部类对包围它的方法之外的任何东西都不可见。
(2) 方法内部类只能够访问该方法中的局部变量，所以也叫局部内部类。而且这些局部变量一定要是final修饰的常量。
(1) 我们首先对Outter类进行反射发现，Outter中再也没有返回私有域的隐藏方法了。
(2) 对Inner类的反射发现，Inner类内部多了一个对beep变量的备份隐藏域：final int val$i;

我们可以这样解释Inner类中的这个备份常量域，首先当JVM运行到需要创建Inner对象之后，Outter类已经全部运行完毕，这是垃圾回收机制很有可能释放掉局部变量beep。那么Inner类到哪去找beep变量呢？
编译器又出来帮我们解决了这个问题，他在Inner类中创建了一个beep的备份 ，也就是说即使Ouuter中的beep被回收了，Inner中还有一个备份存在，自然就不怕找不到了。
但是问题又来了。如果Outter中的beep不停的在变化那。那岂不是也要让备份的beep变量无时无刻的变化。为了保持局部变量与局部内部类中备份域保持一致。 编译器不得不规定死这些局部域必须是常量，一旦赋值不能再发生变化了。
所以为什么局部内部类应用外部方法的域必须是常量域的原因所在了。
http://android.blog.51cto.com/268543/384809/

内部类是JAVA语言的主要附加部分。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
　　　　其一、在一个类（外部类）中直接定义的内部类；
　　　　其二、在一个方法（外部类的方法）中定义的内部类;
　　　　其三、匿名内部类。

　　为什么需要内部类？

　　　　⒈ 内部类对象可以访问创建它的对象的实现，包括私有数据；
　　　　⒉ 内部类不为同一包的其他类所见，具有很好的封装性；
　　　　⒊ 使用内部类可以很方便的编写事件驱动程序；
　　　　⒋ 匿名内部类可以方便的定义运行时回调；
　　　　5.内部类可以方便的定义
　　　每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。

在外部类里面创建成员内部类的实例：

　　this.new B()；

　　在外部类之外创建内部类的实例：

　　(new Test1()).new B().go();

　　在内部类里访问外部类的成员：

　　Test1.this.member

http://www.cnblogs.com/lgk1002/p/6069784.html

内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。
局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。
　　匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。
为什么局部内部类和匿名内部类只能访问局部final变量？

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

publicclassTest {     publicstaticvoidmain(String[] args)  {              }          publicvoidtest(finalintb) {         finalinta = 10;         newThread(){             publicvoidrun() {                 System.out.println(a);                 System.out.println(b);             };         }.start();     } }

　　这段代码会被编译成两个class文件：Test.class和Test1.class。默认情况下，编译器会为匿名内部类和局部内部类起名为Outter1.class。默认情况下，编译器会为匿名内部类和局部内部类起名为Outterx.class（x为正整数）。

　　根据上图可知，test方法中的匿名内部类的名字被起为 Test$1。

　　上段代码中，如果把变量a和b前面的任一个final去掉，这段代码都编译不过。我们先考虑这样一个问题：

　　当test方法执行完毕之后，变量a的生命周期就结束了，而此时Thread对象的生命周期很可能还没有结束，那么在Thread的run方法中继续访问变量a就变成不可能了，但是又要实现这样的效果，怎么办呢？Java采用了 复制  的手段来解决这个问题。将这段代码的字节码反编译可以得到下面的内容：

　　我们看到在run方法中有一条指令：

bipush 10

　　这条指令表示将操作数10压栈，表示使用的是一个本地局部变量。这个过程是在编译期间由编译器默认进行，如果这个变量的值在编译期间可以确定，则编译器默认会在匿名内部类（局部内部类）的常量池中添加一个内容相等的字面量或直接将相应的字节码嵌入到执行字节码中。这样一来，匿名内部类使用的变量是另一个局部变量，只不过值和方法中局部变量的值相等，因此和方法中的局部变量完全独立开。

　　下面再看一个例子：

1 2 3 4 5 6 7 8 9 10 11 12 13

publicclassTest {     publicstaticvoidmain(String[] args)  {              }          publicvoidtest(finalinta) {         newThread(){             publicvoidrun() {                 System.out.println(a);             };         }.start();     } }

　　反编译得到：

　　我们看到匿名内部类Test$1的构造器含有两个参数，一个是指向外部类对象的引用，一个是int型变量，很显然，这里是将变量test方法中的形参a以参数的形式传进来对匿名内部类中的拷贝（变量a的拷贝）进行赋值初始化。

　　也就说如果局部变量的值在编译期间就可以确定，则直接在匿名内部里面创建一个拷贝。如果局部变量的值无法在编译期间确定，则通过构造器传参的方式来对拷贝进行初始化赋值。

　　从上面可以看出，在run方法中访问的变量a根本就不是test方法中的局部变量a。这样一来就解决了前面所说的 生命周期不一致的问题。但是新的问题又来了，既然在run方法中访问的变量a和test方法中的变量a不是同一个变量，当在run方法中改变变量a的值的话，会出现什么情况？

　　对，会造成数据不一致性，这样就达不到原本的意图和要求。为了解决这个问题，java编译器就限定必须将变量a限制为final变量，不允许对变量a进行更改（对于引用类型的变量，是不允许指向新的对象），这样数据不一致性的问题就得以解决了。

　　到这里，想必大家应该清楚为何 方法中的局部变量和形参都必须用final进行限定了。

　　3.静态内部类有特殊的地方吗？

　　从前面可以知道，静态内部类是不依赖于外部类的，也就说可以在不创建外部类对象的情况下创建内部类的对象。另外，静态内部类是不持有指向外部类对象的引用的，这个读者可以自己尝试反编译class文件看一下就知道了，是没有Outter this&0引用的。

为什么在Java中需要内部类？总结一下主要有以下四点：

　　1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整，

　　2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。

　　3.方便编写事件驱动程序

　　4.方便编写线程代码

　　个人觉得第一点是最重要的原因之一，内部类的存在使得Java的多继承机制变得更加完善。

http://blog.csdn.net/pangqiandou/article/details/53234908

java 内部类为什么不能用静态方法

非static的内部类，在外部类加载的时候，并不会加载它，所以它里面不能有静态变量或者静态方法。

static类型的属性和方法，在类加载的时候就会存在于内存中。
要使用某个类的static属性或者方法，那么这个类必须要加载到jvm中。
基于以上两点，可以看出，如果一个非static的内部类如果具有static的属性或者方法，那么就会出现一种情况：内部类未加载，但是却试图在内存中创建static的属性和方法，这当然是错误的。原因：类还不存在，但却希望操作它的属性和方法。
“if you’re going to have a static method, the whole inner class has to be static. Without doing that, you couldn’t guarantee that the inner class existed when you attempted to call the static method. ”
如果内部类没有static的话，就需要实例化内部类才能调用，说明非static的内部类不是自动跟随主类加载的，而是被实例化的时候才会加载。

而static的语义，就是主类能直接通过内部类名来访问内部类中的static方法，而非static的内部类又是不会自动加载的，所以这时候内部类也要static，否则会前后冲突。
http://blog.csdn.net/zhaodedong/article/details/52911338

二、匿名内部类与lambda表达式

jdk8引入的lambda表达式可以代替实现接口形式的匿名内部类，使代码更简洁易懂。

Lambda表达式并不能取代所有的匿名内部类，只能用来取代函数接口（Functional Interface）的简写。
这得益于javac的类型推断机制，编译器能够根据上下文信息推断出参数的类型，当然也有推断失败的时候，这时就需要手动指明参数类型了。注意，Java是强类型语言，每个变量和对象都必需有明确的类型。

能够使用Lambda的依据是必须有相应的函数接口（函数接口，是指内部只有一个抽象方法的接口）。这一点跟Java是强类型语言吻合，也就是说你并不能在代码的任何地方任性的写Lambda表达式。实际上Lambda的类型就是对应函数接口的类型。Lambda表达式另一个依据是类型推断机制，在上下文信息足够的情况下，编译器可以推断出参数表的类型，而不需要显式指名。

public class MyLambda {

    public void lambda() {
        Runnable run = () -> System.out.println("Thread run********");

        ActionListener listener = event -> System.out.println("button clicked");
        /**
         * 代码块
         */
        Runnable block = () -> {

            System.out.println("Lambda 代码块******");
            System.out.println("Lambda 代码块******");
        };
        BinaryOperator<Long> add = (Long x, Long y) -> x + y;
        /**
         * 5 类型推断
         */
        BinaryOperator<Long> infer = (x, y) -> x + y;//
    }

    public static void main(String[] args) {
        new MyLambda().lambda();
    }
}

http://www.cnblogs.com/weiguo21/p/5985000.html