java内部类详细说明

内部类对android开发使用较多，对javaEE开发则不是很常用，首先申明我是从事javaEE开发的，有什么不足的地方大家指教。

         1. 内部类的介绍：

1）内部类（Nested Class）分为两大类：静态内部类和非静态内部类，非静态内部类又分为：普通内部类（成员内部类）、方法内部类（局部内部 类）和匿名内部类。

2）内部类仍然是个独立的类，在编译之后会编译成独立的class文件，但是前面会加上外部类的类名和$符号。

3）内部类可以使用修饰符：public private protected,default

4）实例

• public class Nested {

      /*

       * 静态内部类

       */

      private staticclass StaticNested {

      }

  
  

      /*

       * 普通内部类（成员内部类）

       */

      private classFieldNested {

      }

  
  

      public void test() {

          /*

           * 方法内部类

           */

          class MethodNested {

          }

      }

  
  

      /*

       * 匿名内部类

       */

      Runnable runtime = new Runnable() {

          public void run() {

  
  

          }

      };

  }

  
  

  2.静态内部类

  1）静态内部类可以包含静态成员、非静态成员。

  2）静态内部类可以直接调用外部类的静态属性、静态方法，但不能调用外部类的成员属性、成员方法。

  3）在别的类中可以直接创建静态内部类的对象。

  4）静态内部类实际上和外部类联系很少，也就是命名空间上的联系。

  5）实例

  public class Nested {

      private inta = 1;

      private static int b = 2;

  
  

      /*

       * 静态内部类

       */

      public staticclass StaticNested {

          // 静态内部类可以包含静态成员、非静态成员

          int c = 3;

          static intd = 4;

  
  

          public void test() {

              // 静态内部类可以直接调用外部类的静态属性、静态方法，但不能调用外部类的成员属性、成员方法

              // System.out.println(a);//Cannot make a static reference to the non-static field

              System.out.println(b);// OK

          }

      }

  }

  
  

  class Nested02 {

      public staticvoid main(String[] args) {

          // 在别的类中可以直接创建静态内部类的对象。

          // 其他类调用静态内部类的方法

          Nested.StaticNested staticNested =new Nested.StaticNested();

      }

  }

  
  

  3.普通内部类

  1）成员内部类就像一个成员变量一样存在于外部类中

  2）成员内部类可以访问外部类的所有成员，包含private

  3）成员内部类的this指向内部类对象本身。要拿到外部类对象可以使用：外部类 + .this

  成员内部类的对象是一定要绑定到外部类的对象上的。因此，创建成员内部类对象时需要持有外部类对象的作用。因此，要先有外部类对象， 后有成员内部类对象。

  4）成员内部类不能有静态成员。

  5）定义内部类其实是为了更加方便的调用外部类成员；内部类一般情况下仅限外部类使用。（如果内部类的功能是为多人服务，得定义成普通类）

  6）实例

  public class Nested {

      private inta = 1;

      private static int b = 2;

  
  

      /*

       * 普通内部类（成员内部类）

       */

      public class FieldNested {

          // 成员内部类不能有静态成员,除非声明为final，并且只能是编译器可以确定值的常量表达式

          // static int c = 3;//The field c cannot be declared static in a non-static inner type, unless initialized with

          // a constant expression

          final staticint d = 4;// OK

  
  

          public void test() {

              // 成员内部类可以访问外部类的所有成员，包含private

              System.out.println(a);

              // 成员内部类的this指向内部类对象本身

              System.out.println("内部类本身" +this);

          }

      }

  }

  
  

  class Nested02 {

      public staticvoid main(String[] args) {

          // 成员内部类的对象是一定要绑定到外部类的对象上的。

          // 因此，创建成员内部类对象时需要持有外部类对象的作用。因此，要先有外部类对象，后有成员内部类对象。

          Nested nested = new Nested();

          Nested.FieldNested fieldNested = nested.new FieldNested();

          fieldNested.test();

      }

  }

  
  

  4.方法内部类（局部内部类）
  

  1）方法内部类的地位和方法内的局部变量的位置相似，因此不能修饰局部变量的修饰符也不能修饰局部内部类，例如public、private、protected、static、transien等。

  2）方法内部类只能在声明的方法内是可见的，因此定义局部内部类之后，想用的话就要在此方法内直接实例化，记住这里的顺序不能反了，一定要先声明后使用，否则编译器会说找不到。

  3）方法内部类不能访问定义它的方法内的局部变量，除非这个变量被定义为final，本质原因：局部变量和方法内部类生命周期不一致所致。

  4）方法内部类只能包含非静态成员。

  5）实例

  public class Nested {

      private int a = 1;

      private static int b = 2;

  
  

      public void test() {

          int c = 3;

          /*

           * 方法内部类

           */

          // 不能修饰局部变量的修饰符也不能修饰局部内部类

          class MethodNested {

              int d = 4;

  
  

              // static int e = 5;//方法内部类只能包含非静态成员

              void testMethod() {

                  System.out.println(d);

                  // 方法内部类中不能引用所在方法的普通局部变量，除非是常量，

                  // 原因：方法的生命周期和方法内部类对象的生命周期不一致！方法执行完，内部类对象可能仍然存在。

                  // System.out.println(c);

              }

          }

      }

  }

  
  

  5.匿名内部类
  

  1）匿名内部类的实例化方式：new Runnable(){};意思是创造一个实现（继承）了Runnable的类的对象。

  2）根据声明的位置判断匿名内部类是成员内部类还是方法内部类。一般是方法内部类，这里就继承方法内部类的特性。

  3）三种使用方式：继承式、接口式、参数式。

  4）实例

  public class Nested {

  
  

      public static void main(String[] args) {

          Nested nested = new Nested();

          nested.test();

      }

  
  

      public void test() {

          /*

           * 匿名内部类-接口式

           */

          Runnable runtime = new Runnable() {

              @Override

              public void run() {

                  System.out.println("接口式");

              }

          };

          runtime.run();

  
  

          /*

           * 匿名内部类-继承式

           */

          Car car = new Car() {

              @Override

              public void test() {

                  System.out.println("继承式");

              }

          };

          car.test();

  
  

          /*

           * 匿名内部类-参数式

           */

          test02(new Car() {

              @Override

              public void test() {

                  System.out.println("参数式");

              }

          });

      }

  
  

      public void test02(Car car) {

          car.test();

      }

  }

  
  

  class Car {

      public void test() {

          System.out.println("继承式内部类测试");

      }

  }