/**

  * 测试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();    

     }

 }