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();    

     }
 }

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