Java内部类小程序（成员内部类，静态内部类，匿名内部类）

/**
 * 测试java内部类(成员内部类，静态内部类，匿名内部类)
 * 局部内部类不常用，就不写了。
 * @package :java05
 * @author shaobn
 * @Describe :
 * @Time: 2015-9-6 下午8:32:38
 */
public class TestInner {

    /**
     * @author shaobn
     * @Describe :
     * @param args
     * @Time : 2015-9-6 下午8:32:09
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        testInner_1();
        testInner_2();
        testInner_3();
        
    }
    public static void testInner_1(){
        //成员内部类生成内部类对象方式一
        Outer_1.Inner_1 oi_1 = new Outer_1().new Inner_1();
        System.out.println("成员内部类生成内部类对象方式一");
        oi_1.testIn_1();
        //成员内部类生成内部类对象方式二
        Outer_1 o_1 = new Outer_1();
        System.out.println("成员内部类生成内部类对象方式二");
        o_1.getInner_1().testIn_1();
        //成员内部类生成内部类对象方式三
        Outer_1 o_11 = new Outer_1();
        System.out.println("外部类访问内部类对象的成员");
        o_11.visitInner_1();
    }
    public static void testInner_2(){
        //测试静态内部类
        Outer_2 o_2 = new Outer_2();
        o_2.visitInner_2();
        Outer_2.Inner_2.testIn_2();
    }
    public static void testInner_3(){
        Outer_3 o_3 = new Outer_3();
        System.out.println("访问匿名内部类方法方式一");
        //访问匿名内部类方法方式一
        o_3._testInner_3(50).show();
        System.out.println("访问匿名内部类方法方式二");
        //访问匿名内部类方法方式二
        o_3.testInner_3(50);
        
    }

}
//测试成员内部类
class Outer_1{
    private int age = 10;
    //测试成员内部类
    public class Inner_1{
        public int age = 100;
        public void testIn_1(){
            int age = 1000;
            //访问外部类中成员变量
            System.out.println(Outer_1.this.age);
            //访问内部类中的成员变量
            System.out.println(this.age);
            //访问内部类中的局部变量
            System.out.println(age);
        }
    }
    //获取内部类对象（推荐）
    public Inner_1 getInner_1(){
        return new Inner_1();
    }
    //外部类访问内部类成员
    public void visitInner_1(){
        System.out.println(getInner_1().age);
        getInner_1().testIn_1();
    }
    
}
//测试静态内部类
class Outer_2{
    private int age = 20;
    private static int length = 40;
    public static class Inner_2{
        private String name = "静态内部类";
        private static float weight = 'A';
        public static void testIn_2(){
            //System.out.println(name);静态内部类中的静态方法必须要访问方法外部的静态成员变量，否则访问不允许。
            System.out.println(Outer_2.length);
        }
        
    }
    public Inner_2 getInner_2(){
        return new Outer_2.Inner_2();
    }
    public Class<?> _getInner_2(){
        return Outer_2.Inner_2.class;
        
    }
    public void visitInner_2(){
        System.out.println(getInner_2().name);
        System.out.println(Outer_2.Inner_2.weight);
    }
    
}
//内部类实现接口
interface SuperIner_3{
    void show();
}
//测试匿名内部类
class Outer_3{
    private int age = 30;
    //方式一
    public SuperIner_3 _testInner_3(final int height){
        final int weight = 40;
        SuperIner_3 si_3 = new SuperIner_3() {
            
            @Override
            public void show() {
                // TODO Auto-generated method stub
                System.out.println(Outer_3.this.age);
                System.out.println(weight);//匿名内部类只能访问final类型局部变量
                System.out.println(height);
            }
        };
        return si_3;
        
    }
    //方式二
    public void testInner_3(final int height){
        final int weiht = 40;
        new SuperIner_3() {
            @Override
            public void show() {
                // TODO Auto-generated method stub
                System.out.println(Outer_3.this.age);
                System.out.println(weiht);//匿名内部类只能访问final类型局部变量
                System.out.println(height);
                
            }
        }.show();    
        
    }
}

局部内部类不经常用就不写了，如有错误，望大家纠正。