Java内部类

在类中再定义一个类，这个类被称为内部类。内部类可以称为成员内部类、局部内部类以及匿名类。

成员内部类

成员内部内

在一个类中使用内部类可以在内部类中直接存取其所在类的私有变量。成员内部类的语法如下：

public class OuterClass{//外部类    private class InnerClass{//内部类    }}

内部类中可以随意使用外部类的成员方法以及成员变量，尽管这些类成员被修饰为private。

public class OuterClass {InnerClass inner = new InnerClass();//在外部类实例化内部类对象引用public void outerFuc() {    inner.innerFuc();//在外部内中调用内部类方法}public InnerClass doit() {//外部类方法，返回值为内部类的引用    //innerY = 4;//error,外部类不可以直接访问内部类成员变量    inner.innerY = 4;    return new InnerClass();//返回内部类引用}class InnerClass{    int innerY = 0;//定义内部类成员变量    InnerClass (){//内部类构造方法    }    public void innerFuc() {//内部类成员方法    }}/** * @param args */public static void main(String[] args) {    // TODO Auto-generated method stub    OuterClass out = new OuterClass();    //内部类的对象实例化操作必须在外部类或外部类的非静态方法中实现    OuterClass.InnerClass inner = out.doit();    OuterClass.InnerClass inner2 = out.new InnerClass();//实例化内部类对象}}

内部类向上转型为接口

将一个权限修饰符为private的内部类向上转型为其父类对象，或者直接向上转型为一个接口，就可以完全隐藏内部类的具体实现过程。

public class InterfaceInner {    public static void main(String[] args) {        OuterClass2 out = new OuterClass2();        //调用doit()方法，返回一个OutInterface接口        OutInterface outInterface = out.doit();        outInterface.f();    }}interface OutInterface{//定义一个接口    public void f();}class OuterClass2{    public OutInterface doit() {//定义一个方法，返回值为OutInterface接口        return new InnerClass("访问内部类构造方法");    }    private class InnerClass implements OutInterface{//定义一个内部类实现OutInterface接口        InnerClass (String s){//内部类构造方法            System.out.println(s);        }        @Override        public void f() {//实现接口中的()方法            System.out.println("访问内部类中的f()方法");        }    }}

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

如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用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        }    }}

局部内部类

也可在类的方法中或任意的作用域中定义内部类。

interface OutInterface2{//定义一个接口}public class OuterClass3 {    public OutInterface2 doit(final String xString) {//doit()方法参数为final类型        //在doit()方法中定义一个内部类        class InnerClass3 implements OutInterface2{            public InnerClass3(String s) {                s = xString;                System.out.println(s);            }        }        return new InnerClass3("doit");    }}

匿名类

匿名类的语法如下：

return new A(){    //内部类体};

A表示类名。
例子：

class OuterClass4{    public OutInterface2 doit() {//定义doit()方法        return new OutInterface2(){//声明匿名内部类            private int i = 0;            public int getValue(){                return i;            }        };    }}

静态内部类

在内部类前添加修饰符static，这个内部类就变为静态内部类。一个静态内部类中可以声明static成员，但是在非静态内部类中不可以声明静态成员。静态内部类有一个最大的特点，就是不可以使用非静态成员。

public class StaticInnerClass {    int x = 100;    static class Inner{        void doitInner(){            //System.out.println("外部类"+x);//Error        }    }}

内部类继承

public class OutputInnerClass extends ClassA.ClassB {//继承内部类b    public OutputInnerClass(ClassA a){        a.super();    }}class ClassA{    class ClassB{    }}

在某个类继承内部类时，必须硬性给予这个类一个带参数的构造方法，并且该构造方法的参数为需要继承内部类的外部类引用，同时在构造方法中使用a.super()语句，这样才为继承提供了必要的对象引用。