java内部类详解

其他外访问：外.内 对象 = new 外().内();
内static，方法不是：外.内().方法;
都是static：new 外.内.方法;
声明：static、非static、private、protected、public及默认。
[java]
<pre style="BACKGROUND-COLOR: rgb(240,240,240); MARGIN: 4px 0px" class="java" name="code">class EnclosingClass{
                    ……
             class ANestedClass{                             ……          }
}
编译之后，内部类也可产生单独的.class文件，文件名为：外部类名$内部类名.class
内部类实例
[html]
public class OuterClass {
          private int x=10;
          class InnerClass{
                   int y=20;
         }
          public static void main (String[] args){
                  OuterClass oc=new OuterClass();
                  OuterClass.InnerClass ic=oc.new InnerClass();//<span style="color:black;">内部类是外部类的一个成员，内部类对象不能单独存在，它必许依赖一个外部类对象</span>
                  System.out.println("Outer:x="+oc.x);
                  System.out.println("InnerClass:y="+ic.y);  
          }
}
Outer：x = 10;
Inner：y = 20;
同一个包中，内部类可以隐藏起来（private）
局部内部类，通过OuterClass.this外部类实例，只能使用final常量
内部类可被定义为抽象类或接口，但必须被其他的内部类继承或实现
[java]
class Outer
{
    int y = 10;
    static class Inner
    {
        static int y = 5;
        //int y = 5;
        static public void fun(){
            int y = 3;
            System.out.println(y);        //3
        }
        /*public void fun(){
            int y = 3;
            System.out.println(y);//
            System.out.println(this.y);
            System.out.println(Outer.this.y);
        }*/
    }
    public void method(){
        Inner i = new Inner();
        i.fun();
        final int a = 7;
        class B
        {
            B(){
                System.out.println(a);
            }
        }
    }
}
class InnerTest  
{
    public static void main(String[] args)  
    {
        //Outer.Inner in = new Outer().new Inner();//普通
        //in.fun();
        //Outer o = new Outer();
        //o.method();

        //new Outer.Inner().fun();//静态类，成员访问方法
        Outer.Inner.fun();//静态类，方法，成员访问方法
    }
}
静态内部类
静态内部类没有父类，不能外部类实例成员或其他内部成员
权限修饰符：public、private、defaul
不能与外部类重名
局部静态类：声明中去掉static，将其定义植入其外部类的静态方法或静态初始化代码中
[java]
public class StaticInnerClass{
          private static class Student{
        int studID;
        String name;
        static int count;
        public Student(int id,String na){
            studID = id;
            name = na;
            count++;
        }
        public void printStuDetalis(){
            System.out.println("序号："+count+"学号："+studID+"姓名："+name);
        }
    }
    public static void main (String[] args){
        StaticInnerClass.Student stu1 = new StaticInnerClass.Student(1001,"Jones");
        stu1.printStuDetalis();
        StaticInnerClass.Student stu2 = new StaticInnerClass.Student(1002,"Smith");
        stu2.printStuDetalis();
        StaticInnerClass.Student stu3 = new StaticInnerClass.Student(1003,"Nace");
        stu3.printStuDetalis();
    }
}
序号：1 学号：1001姓名：Jones
序号：2 学号：1002姓名：Smith
序号：3 学号：1003姓名：Nace
匿名内部类
只用到类的一个实例
类在定义后马上用到
类非常小（推荐在4行代码以下）
给类命名并不会导致你的代码更容易被理解
前提：必须继承一个父类，或实现一个接口
new 父类构造方法名()|实现的接口名(){};
class 类名 implements ActionListener{
           public void actionPerformed(ActionEvent e){…}
}  
|
new ActionListener(){ public void actionPerformed(ActionEvent e){ … } };
由于匿名内部类没有名称，因此创建匿名内部类对象时，new运算符后是超类或接口的名称，其后的{}内部为匿名类的定义（匿名类对象的创建和匿名类的声明是在一起的）。
匿名类不能是抽象类，因为系统在创建匿名类的时候，会立即创建匿名类的对象。因此不允许将匿名类定义成抽象类。
匿名类不能有构造方法，因为匿名类没有类名，无法定义构造方法，但匿名类可以定义实例初始化块，通过实例初始化块来完成构造方法需要完成的事情
匿名类不能定义任何静态成员、方法和类；
匿名类不能是public、protected、private、static；