Java内部类详解

简介：

　　内部类（nested classes），面向对象程序设计中，可以在一个类的内部定义另一个类。嵌套类分为两种，即静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。

定义：

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

表现形式：

1. 静态内部类
2. 成员内部类
3. 局部内部类
4. 匿名内部类

优点：

1. 内部类对象可以访问创建它的对象的实现，包括私有数据；
2. 内部类不为同一包的其他类所见，具有很好的封装性；
3. 使用内部类可以很方便的编写事件驱动程序；
4. 匿名内部类可以方便的定义运行时回调；
5. 内部类可以方便的定义

关于内部类的一些知识点：

1.静态修饰符。

　　如果内部类被静态修饰，相当于外部类，会出现访问局限性，只能访问外部类中的静态成员。
注意；如果内部类中定义了静态成员，那么该内部类必须是静态的。
内部类编译后的文件名为：“外部类名$内部类名.java”；

2.为什么内部类可以直接访问外部类中的成员呢？

　　那是因为内部中都持有一个外部类的引用。这个是引用是 外部类名.this
内部类可以定义在外部类中的成员位置上，也可以定义在外部类中的局部位置上。
​

3.当内部类被定义在局部位置上，只能访问局部中被final修饰的局部变量。为什么？

　　因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用

4.关于内部类对象的创建。

　　如何在包含内部类的外部类中创建直接new就可以了，如果是在其他外部类中，创建看下面例子，当然内部类作为外部类的成员变量如果被private修饰，外部类是没有访问该内部类的权限的，也因此内部类具有很好的隐蔽性。

　　非静态成员内部类创建，成员内部类就相当于是个普通的成员变量，要想使用这个成员变量，必要要依附在外部类对象的基础上，所以需要先把外部类new出来，才能接着new出内部类。

public class OuterClass {

    public class Inter{

    }
}

class Another{
    public static void main(String args[]) {
//        OuterClass.Inter inter = new OuterClass.Inter();  //错误
        OuterClass.Inter inter2 = new OuterClass().new  Inter(); //正确
    }
}

　　静态 内部类对象的创建，还是和 上面的是一个道理，因为是静态的所以直接外部对象+”.”就可以直接引用了，但是内部类还是需要new的，所以新建对象就像下面这样。

public class OuterClass {

    public static class Inter{

    }
}

class Another{
    public  static void main(String args[]) {
        OuterClass.Inter inter = new OuterClass.Inter();
    }
}

5.外部类的静态方法不能创建非静态内部类的对象

　　因为静态方法随类的加载而加载，这时非静态内部类还没有加载。

public class OuterClass {

    public static Inter getInter(){
        return new Inter(); // 这一句会报错
    };

    class Inter{

    }
}

6.内部类向上转型为接口

　　如果将一个权限修饰符为private的内部向上转型为其父类对象，或者直接向上转型为一个接口。在程序中舅舅可以完隐藏内部的具体实现过程。可以在外部提供一个接口，在接口中声明一个方法，如果在实现该接口的内部类中实现该接口的方法，就可以定义多个内部类以不同的方式实现接口中的同一个方法，而在一般的类中是不能多次实现接口中的同一个方法。

interface OutInterface { // 定义一个接口
    public void f();
}

public class InterfaceInner {
    public static void main(String args[]) {
        OuterClass2 out = new OuterClass2(); // 实例化一个OuterClass2对象
        // 调用doit()方法，返回一个OutInterface接口
        OutInterface outinter = out.doit();
        outinter.f(); // 调用f()方法
    }
}


class OuterClass2 {
    // 定义一个内部类实现OutInterface接口
    private class InnerClass implements OutInterface {
        InnerClass(String s) { // 内部类构造方法
            System.out.println(s);
        }

        public void f() { // 实现接口中的f()方法
            System.out.println("访问内部类中的f()方法");
        }
    }

    public OutInterface doit() { // 定义一个方法，返回值类型为OutInterface接口
        return new InnerClass("访问内部类构造方法");
    }
}

除了OuterClass2类可以访问这个内部类以外，其他类都不能访问该类，但是却可以访问他的doit方法，doit方法返回值类型又是外部接口类型，这样很好的对继承该类的子类隐藏了实现细节，仅为编写子类的人留下一个接口和一个外部类，同时也可以调用f()方法，但是f()方法的具体实现却得到了很好的隐藏，这就是内部类最基本的用途。
非内部类不能被声明为private或者protected访问类型。

7.使用this关键字获取内部类与外部类的引用

public class TheSameName {
    private int x;

    private class Inner {
        private int x = 9;
        public void doit(int x) {
            x++; // 调用的是形参x
            this.x++; // 调用内部类的变量x
            TheSameName.this.x++; // 调用外部类的变量x
        }
    }
}

8.内部类的继承

class WithInner {  
    class Inner {}  
}  


public class InheritInner extends WithInner.Inner {  
    public InheritInner(WithInner wi) {  
        wi.super();  
    }  
    public static void main(String[] args) {  
        WithInner wi = new WithInner();  
        InheritInner ii = new InheritInner(wi);  
    }  
}  

  要理解这个问题就得先理解内部类，Inner是WithInner的内部类，那么一般的用法
WithInner.Inner inner = new WithInner(). new Inner() ;
我们可以看出要想创建Inner的对象必须先创建WithInner的对象之后才能创建Inner对象，那么现在你要用一个类InheritInner继承Inner类，在继承过程中构造方法会被调用，即使你不写也会调用默认构造方法，但问题出现了，在调用父类Inner构造方法时找不到WithInner的对象，所以就必须给InheritInner类的构造方法传入WithInner对象再通过wi.super();方法调用Inner的默认构造方法，因为这是创建对象的基本流程，所以这句话wi.super();是必须的。

9.局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?

       因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以 。