java 中的内部类-CSDN博客

本文链接：https://blog.csdn.net/comkingfly/article/details/7306562

内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。

*内部类可以是静态static的，也可用public，default，protected和private修饰。（而外部顶级类即类名和文件名相同的只能使用public和default）。

注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。所以内部类的成员变量/方法名可以和外部类的相同。

在JAVA中，常常也要用到内部类。之所以要用内部类，其主要目的就是为了弥补在C++中可以有多重继承，而JAVA不存在多重继承这一问题，使用多重继承是有许多优点的，这点众所周知。当然，使用了内部类之后，程序逻辑将变得相对复杂一些，不易读懂。另外，JAVA也可以使用匿名类，匿名类指的是调用类的构造函数来创建的实例对象,不再直接赋给其对应的变量，而是直接加以引用。这种方式有一定的优势，可以节省额外分配变量的空间，但正因为只生成一次，用完后就消失，这往往也成为它的劣势。比如，它只能生成个对象，该对象由于相应的变量贮存它，以致它调用成员函数时会不能持久。匿名类一般适合类的短暂调用时的应用场景。

内部类的分类

1，成员内部类、

2，局部内部类、

3，静态内部类、

4，匿名内部类

内部类有两种情况：

(1) 在类中定义一个类(私有内部类，静态内部类)

(2) 在方法中定义一个类(局部内部类，匿名内部类)

1、私有内部类 —— 在方法之间定义的内部类，非静态

我们首先看看类中内部类的两个特点：

(1) 在外部类的作用范围内可以任意创建内部类对象，即使内部类是私有的(私有内部类)。即内部类对包围它的外部类可见。

例如 (实际上，内部类是可以设置为public公开的，但一般我是当做成员变量设置为private)

//代码1：内部类对外部类可见 
class Outer{ 
    //创建私有内部类对象 
    public Inner in=new Inner(); 
 
    //私有内部类 
    private class Inner{ 
         ... 
    } 
}

(2) 在内部类中可以访问其外部类的所有域，即使是私有域。即外部类对内部类可见。

例如

//代码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作为一种常规类来处理的。

但问题来了，即然是两个常规类，为什么他们之间可以互相访问私有域那(最开始提到的两个内部类特点)？这就要问问编译器到底把这两个类编译成什么东西了。

我们利用reflect反射机制来探查了一下内部类编译后的情况（关于探查类内部机制的代码提供在下面的附件里Reflect.java）。

(1)、编译代码1生成 Outer$Inner.class 文件后使用 ReflectUtil.reflect("Outer$Inner") 对内部类Inner进行反射。运行结果发现了三个隐含的成分：

//反编译代码
class Outer$Inner
{
    Outer$Inner(Outer,Outer$Inner);  //包可见构造器
    private Outer$Inner(Outer);   //私有构造器将设置this$0域
    final Outer this$0;   //外部类实例域this$0
}

好了，现在我们可以解释上面的第一个内部类特点了：为什么外部类可以创建内部类的对象？并且内部类能够方便的引用到外部类对象?

首先编译器将外、内部类编译后放在同一个包中。在内部类中附加一个包可见构造器。这样，虚拟机运行Outer类中Inner in=new Inner(); 实际上调用的是包可见构造： new Outer$Inner(this,null)。因此即使是private内部类，也会通过隐含的包可见构造器成功的获得私有内部类的构造权限。

再者，Outer$Inner类中有一个指向外部类Outer的引用this$0，那么通过这个引用就可以方便的得到外部类对象中可见成员。但是Outer类中的private成员是如何访问到的呢？这就要看看下面Outer.class文件中的秘密了。

(2)、编译代码2生成 Outer.class文件，然后使用 ReflectUtil.reflect("Outer") 对外部类Outer进行反射。运行结果发现一个隐含成分如下：

//反编译代码 
class Outer 
{ 
    static int access$0(Outer);  //静态方法，返回值是外部类私有域 data 的值 
}

现在可以解释第二个特点了：为什么内部类可以引用外部类的私有域？

原因的关键就在编译器在外围类中添加了静态方法access$0。它将返回值作为参数传递给他的对象域data。这样内部类Inner中的打印语句：

System.out.println(data);

实际上运行的时候调用的是：

System.out.println(this$0.access$0(Outer));

总结一下编译器对类中内部类做的手脚吧：

(1) 在内部类中偷偷摸摸的创建了包可见构造器，从而使外部类获得了创建权限。

(2) 在外部类中偷偷摸摸的创建了访问私有变量的静态方法，从而使内部类获得了访问权限。

这样，类中定义的内部类无论私有，公有，静态都可以被包围它的外部类所访问。

2、静态内部类 —— 在方法间定义的内部类，静态

内部类也有静态的区别，这就是静态内部类，我们来看看代码：

package hr.test; 
//代码3：静态内部类对外部变量的引用 
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不是静态变量，这里将无法通过编译 
        } 
    }  
}

静态内部类和私有内部类最大的区别在于，静态内部类中无法引用到其外围类的非静态成员。这是为什么？我们还是来看看静态内部类Outer$Inner中发生了什么吧？

//反编译代码 
class Outer$Inner 
{ 
    private Outer$Inner(); 
    Outer$Inner(hr.test.Outer$Inner); 
}

与上面私有内部类反编译1比较发现，少了一个指向外围类对象的引用final Outer this$0; 也就是说静态内部类无法得到其外围类对象的引用，那么自然也就无法访问外围类的非静态成员了。因此，静态内部类只能访问其外围类的静态成员，除此之外与非静态内部类没有任何区别。

3、局部内部类 —— 在方法中定义的内部类

方法内部类也有两个特点

(1) 方法中的内部类没有访问修饰符，即方法内部类对包围它的方法之外的任何东西都不可见。

(2) 方法内部类只能够访问该方法中的局部变量，所以也叫局部内部类。而且这些局部变量一定要是final修饰的常量。

例如

class Outter{ 
    public void outMethod(){ 
        final int beep=0; 
        class Inner{ 
            //使用beep 
        } 
 
        Inner in=new Inner(); 
    } 
}

这又是为什么呢？

(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变量无时无刻的变化。为了保持局部变量与局部内部类中备份域保持一致。编译器不得不规定死这些局部域必须是常量，一旦赋值不能再发生变化了。

所以为什么局部内部类应用外部方法的域必须是常量域的原因所在了。

内部类的特点总结

(1) 在方法间定义的非静态内部类：

● 外围类和内部类可互相访问自己的私有成员。

● 内部类中不能定义静态成员变量。

(2) 在方法间定义的静态内部类：

● 只能访问外部类的静态成员。

(3) 在方法中定义的局部内部类：

● 该内部类没有任何的访问控制权限

● 外围类看不见方法中的局部内部类的，但是局部内部类可以访问外围类的任何成员。

● 方法体中可以访问局部内部类，但是访问语句必须在定义局部内部类之后。

● 局部内部类只能访问方法体中的常量，即用final修饰的成员。

(4) 在方法中定义的匿名内部类：

● 没有构造器，取而代之的是将构造器参数传递给超类构造器。

成员内部类

四个访问权限修饰符都可以修饰成员内部类。
内部类和外部类在编译时时不同的两个类，内部类对外部类没有任何依赖。
内部类是一种编译时语法，在编译时生成的各自的字节码文件，内部类和外部类没有关系。
内部类中可以访问外部类的私有成员。
作为外部类的一个成员存在，与外部类的属性、方法并列。
内部类和外部类的实例变量可以共存。
在内部类中访问实例变量：this.属性
在内部类访问外部类的实例变量：外部类名，this.属性。

在外部类的外部访问内部类，使用out.inner。

//OutClass.java
public class OutClass {
    public int a;
    protected int b;
    int c;
    private int d;
    
    public class InnerClass {
        public int e;
        InnerClass() {
            this.e = OutClass.this.a;
            this.e = d;
        }
    }
}
//Test3.java
public class Test3  {
    OutClass oc = new OutClass();
    OutClass.InnerClass ic = oc.new InnerClass();
}

成员内部类的特点：
1.内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为private，但是对于处于其内部的内部类还是可见的。）
2.用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。

注意：内部类是个编译时的概念，一旦编译成功，就会成为完全不同的两类。
　　　对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译
　　　完成后出现outer.class和outer$inner.class两类。
3.成员内部类不能含有静态成员。

建立内部类对象时应注意：
在外部类的内部可以直接使用inner s=new inner()；（因为外部类知道inner是哪个类，所以可以生成对象。）
而在外部类的外部，要生成（new）一个内部类对象，需要首先建立一个外部类对象（外部类可用），然后在生成一个内部类对象，内部类的类名是外部类类名.内部类类名。

Outer o=new Outer()；
Outer.Inner in=o.new.Inner()

静态内部类

（注意：前三种内部类与变量类似，所以可以对照参考变量）
静态内部类定义在类中，任何方法外，用static class定义。
静态内部类只能访问外部类的静态成员。
生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。
静态内部类的对象可以直接生成：
Outer.Inner in=new Outer.Inner()；
而不需要通过生成外部类对象来生成，这样实际上使静态内部类成为了一个顶级类。静态内部类不可用private来进行定义。

注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须
　　　使用内部类来实现。用接口不能完全地实现多继承，用接口配合内部类
　　　才能实现真正的多继承。

例子：
对于两个类，拥有相同的方法：

class People
{
  run()；
}
interface Machine
{
   run()；
}
有一个robot类：class Robot extends People implement Machine，run()不可直接实现。
interface Machine {
    void run();
}

class Person {
    void run() {
        System.out.println("run");
    }
}

class Robot extends Person {
    private class MachineHeart implements Machine {
        public void run() {
            System.out.println("heart run");
        }
    }

    public void run() {
        System.out.println("Robot run");
    }

    Machine getMachine() {
        return new MachineHeart();
    }
}

class Test {
    public static void main(String[] args) {
        Robot robot = new Robot();
        Machine m = robot.getMachine();
        m.run();
        robot.run();
    }
}

局部内部类
在方法中定义的内部类称为局部内部类。
与局部变量类似，在局部内部类前不加修饰符public和private，其范围为定义它的代码块。

注意：局部内部类不仅可以访问外部类私有实例变量，但可以访问外部类的局
　　　部常量（也就是局部变量必须为final的）。
在类外不可直接访问局部内部类（保证局部内部类对外是不可见的）。
在方法中才能调用其局部内部类。
通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。

局部内部类写法

public class TestLocalInnerClass {
    public static void main(String[] args) {
        Outer o = new Outer();
        final int a = 9;
        o.print(a);
    }
}

class Outer {
    private int index = 100;

    public void print(final int a) {
        final int b = 10;
        System.out.println(a);
        class Inner {
            public void print() {
                System.out.println(index);
                System.out.println(a);
                System.out.println(b);
            }
        }
        Inner i = new Inner();
        i.print();
    }
}

匿名内部类
匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口。

匿名内部类的特点：
1，一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。
2，只是为了获得一个对象实例，不许要知道其实际类型。
3，类名没有意义，也就是不需要使用到。
注意：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一
　　　个类，没有类名，根据多态，我们使用其父类名。
因其为局部内部类，那么局部内部类的所有限制都对其生效。
匿名内部类是唯一一种无构造方法类。
大部分匿名内部类是用于接口回调用的。
匿名内部类在编译的时候由系统自动起名Out$1.class。
如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。
因匿名内部类无构造方法，所以其使用范围非常的有限。
当需要多个对象时使用局部内部类，因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。

匿名内部类的写法：

interface A {
    void ia();
}

class B {
    public A bc(){
        return new A(){
            public void ia(){}
        };
   }
}
使用匿名内部类：
B b=new B()；
A a=b.bc()；
a.ia()；