Java内部类浅析

内部类就是在一个已经定义好的类内部再用class关键字定义的类
内部类包括：静态内部类、非静态内部类（普通内部类）；局部内部类、匿名内部类

普通内部类与静态内部类

最明显的特征就是是否用static修饰

public class OutterClass {
    //普通内部类
    class InnerClass{   
    }
    //静态内部类
    static class InnerClass2{   
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
    }
}

注意：静态内部类前是用static修饰的。
普通内部类可直接访问外部类的所有成员，静态内部类不能直接访问非static属性的成员，需要用外部对象的引用才能访问。

下面分别是普通内部类和静态内部类的实例化：
普通内部类需要用外部类的实例再进行相应内部类的实例化
静态内部类则可以直接进行实例化

public class OutterClass {
    private int a = 10;
    private static int b = 11;
    
    //普通内部类
    class InnerClass{
        void print(){
            //访问外部private成员
            System.out.println(a);
        }
    }
    //静态内部类
    static class InnerClass2{
        void print(){
            //直接访问非static变量报错
            //System.out.println(a);
            //通过外部对象的引用来访问非static变量
            OutterClass out = new OutterClass();
            System.out.println(out.a);
            //直接访问外部static变量
            System.out.println(b);
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //实例化静态类InnerClass2
        InnerClass2 in2 = new InnerClass2();
        in2.print();
        //实例化普通内部类
        InnerClass in = new OutterClass().new InnerClass();
        in.print();
    }
}

局部内部类和匿名内部类

局部内部类就是定义在某个方法中的类
局部内部类可以访问外部类的所有成员、方法的局部变量、方法的形参，不一定需要final修饰（Java SE8），但要保证局部变量不被二次赋值。
局部内部类和普通内部类是相似的因为他们都不能被定义或声明静态成员，如果局部内部类在静态方法内被定义那么这个局部内部类就只能访问方法的静态成员。不能在局部内部类中声明接口，因为接口本身就是静态的（inherently static）。局部内部类不能包含静态成员除非这个静态成员是常量（被final修饰）

public void InnerClassFun(int k){
        int min = 70;
        class InnerClass3{
            //局部类中的静态变量必须是final型的
            final static int c = 12;
            void print(){
                //访问外部类的static和非static成员
                System.out.println(a);
                System.out.println(b);
                //访问方法的形参和局部变量
                System.out.println(min);
                System.out.println(k);
                System.out.println(c);
            }
        }
    }

匿名内部类就是没有名字的内部类，通常是用来作为抽象类或者接口等不能实例化的类的扩展，最常见的例子便是点击事件以及线程的开启：

((Button) findViewById(R.id.start)).setOnClickListener(new Button.OnClickListener() { 
    @Override 
    public void onClick(View v) { 
        new Thread() { 
 
            @Override 
            public void run() { 
                // TODO Auto-generated method stub 
            } 
 
        }.start(); 
    } 
}); 

匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的：

public class OutterClass {
        public static void main(String[] args) {
        Inner in = new OutterClass().getInner("Beijing");
        System.out.println(in.getName());
      }
    public Inner getInner(final String name){
        return new Inner(){
            private String nameStr = name;
            public String getName(){
                return nameStr;
            }   
        };
    }
    interface Inner{
        String getName();
    }
}

所在的方法的形参需要被内部类里面使用时，该形参必须为final
1.匿名内部类不能有构造方法。 　　
2.匿名内部类不能定义任何静态成员、方法和类。 　　
3.匿名内部类不能是public,protected,private,static。
4.只能创建匿名内部类的一个实例。
5.一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。 　
6.因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

参考来自：
http://www.jianshu.com/p/1faacbd5794f
http://android.blog.51cto.com/268543/384844/