首页 > Java教程 > Java继承和多态

Java实例内部类

< 上一页Java内部类简介 Java静态内部类下一页 >
实例内部类是指没有用 static 修饰的内部类，有的地方也称为非静态内部类。示例代码如下： 
  1. public class Outer {
  2.     class Inner {
  3.         // 实例内部类
  4.     }
  5. }
上述示例中的 Inner 类就是实例内部类。实例内部类有如下特点。

1）在外部类的静态方法和外部类以外的其他类中，必须通过外部类的实例创建内部类的实例。 
  1. public class Outer {
  2.     class Inner1 {
  3.     }
  4.  
  5.     Inner1 i = new Inner1(); // 不需要创建外部类实例
  6.  
  7.     public void method1() {
  8.         Inner1 i = new Inner1(); // 不需要创建外部类实例
  9.     }
  10.  
  11.     public static void method2() {
  12.         Inner1 i = new Outer().new inner1(); // 需要创建外部类实例
  13.     }
  14.  
  15.     class Inner2 {
  16.         Inner1 i = new Inner1(); // 不需要创建外部类实例
  17.     }
  18. }
  19.  
  20. class OtherClass {
  21.     Outer.Inner i = new Outer().new Inner(); // 需要创建外部类实例
  22. }
2）在实例内部类中，可以访问外部类的所有成员。 
  1. public class Outer {
  2.     public int a = 100;
  3.     static int b = 100;
  4.     final int c = 100;
  5.     private int d = 100;
  6.  
  7.     public String method1() {
  8.         return "实例方法1";
  9.     }
  10.  
  11.     public static String method2() {
  12.         return "静态方法2";
  13.     }
  14.  
  15.     class Inner {
  16.         int a2 = a + 1; // 访问public的a
  17.         int b2 = b + 1; // 访问static的b
  18.         int c2 = c + 1; // 访问final的c
  19.         int d2 = d + 1; // 访问private的d
  20.         String str1 = method1(); // 访问实例方法method1
  21.         String str2 = method2(); // 访问静态方法method2
  22.     }
  23.  
  24.     public static void main(String[] args) {
  25.         Inner i = new Outer().new Inner(); // 创建内部类实例
  26.         System.out.println(i.a2); // 输出101
  27.         System.out.println(i.b2); // 输出101
  28.         System.out.println(i.c2); // 输出101
  29.         System.out.println(i.d2); // 输出101
  30.         System.out.println(i.str1); // 输出实例方法1
  31.         System.out.println(i.str2); // 输出静态方法2
  32.     }
  33. }
提示：如果有多层嵌套，则内部类可以访问所有外部类的成员。

3）在外部类中不能直接访问内部类的成员，而必须通过内部类的实例去访问。如果类 A 包含内部类 B，类 B 中包含内部类 C，则在类 A 中不能直接访问类 C，而应该通过类 B 的实例去访问类 C。

4）外部类实例与内部类实例是一对多的关系，也就是说一个内部类实例只对应一个外部类实例，而一个外部类实例则可以对应多个内部类实例。

如果实例内部类 B 与外部类 A 包含有同名的成员 t，则在类 B 中 t 和 this.t 都表示 B 中的成员 t，而 A.this.t 表示 A 中的成员 t。 
  1. public class Outer {
  2.     int a = 10;
  3.  
  4.     class Inner {
  5.         int a = 20;
  6.         int b1 = a;
  7.         int b2 = this.a;
  8.         int b3 = Outer.this.a;
  9.     }
  10.  
  11.     public static void main(String[] args) {
  12.         Inner i = new Outer().new Inner();
  13.         System.out.println(i.b1); // 输出20
  14.         System.out.println(i.b2); // 输出20
  15.         System.out.println(i.b3); // 输出10
  16.     }
  17. }
5）在实例内部类中不能定义 static 成员，除非同时使用 final 和 static 修饰。
< 上一页Java内部类简介 Java静态内部类下一页 >