手册   游戏   WEB   字典   单词   在线工具  

一篇文章让你彻底了解 Java 内部类

对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类. 编译完成后出现 outer.class 和 outer$inner.class 两类.

B: 局部内部类

在方法中定义的内部类称为局部内部类. 与局部变量类似, 局部内部类不能有访问说明符, 因为它不是外围类的一部分, 但是它可以访问当前代码块内的常量, 和此外围类所有的成员.

  1. public class Outer {
  2.     private int s = 100;
  3.     private int outI = 1;
  4.     public static void main(String[] args) {
  5.         // 访问局部内部类必须先有外部类对象
  6.         Outer out = new Outer();
  7.         out.f(3);
  8.     }
  9.     public void f(final int k) {
  10.         final int s = 200;
  11.         int i = 1;
  12.         final int j = 10;
  13.         /**
  14.          * 定义在方法内部
  15.          */
  16.         class Inner {
  17.             // 可以定义与外部类同名的变量
  18.             int s = 300;
  19.             int innerI = 100;
  20.             // static int m = 20; 不可以定义静态变量
  21.             Inner(int k) {
  22.                 innerF(k);
  23.             }
  24.             void innerF(int k) {
  25.                 // java 如果内部类没有与外部类同名的变量, 在内部类中可以直接访问外部类的实例变量
  26.                 System.out.println(outI);
  27.                 // 可以访问外部类的局部变量 (即方法内的变量), 但是变量必须是 final 的
  28.                 System.out.println(j);
  29.                 //System.out.println(i);
  30.                 // 如果内部类中有与外部类同名的变量, 直接用变量名访问的是内部类的变量
  31.                 System.out.println(s);
  32.                 // 用 this. 变量名访问的也是内部类变量
  33.                 System.out.println(this.s);
  34.                 // 用外部类名. this. 内部类变量名访问的是外部类变量
  35.                 System.out.println(Outer.this.s);
  36.             }
  37.         }
  38.         new Inner(k);
  39.     }
  40. }

复制代码

C: 静态内部类 (嵌套类):

注意: 前两种内部类与变量类似, 所以可以对照参考变量

如果你不需要内部类对象与其外围类对象之间有联系, 那你可以将内部类声明为 static. 这通常称为嵌套类 (nested class). 想要理解 static 应用于内部类时的含义, 你就必须记住, 普通的内部类对象隐含地保存了一个引用, 指向创建它的外围类对象. 然而, 当内部类是 static 的时, 就不是这样了. 嵌套类意味着:

要创建嵌套类的对象, 并不需要其外围类的对象.

不能从嵌套类的对象中访问非静态的外围类对象.

  1. public class Outer {
  2.     private static int i = 1;
  3.     private int j = 10;
  4.     public static void outerF1() {
  5.     }
  6.     public static void main(String[] args) {
  7.         new Outer().outerF3();
  8.     }
  9.     public void outerF2() {
  10.     }
  11.     public void outerF3() {
  12.         // 外部类访问内部类的静态成员: 内部类. 静态成员
  13.         System.out.println(Inner.inner_i);
  14.         Inner.innerF1();
  15.         // 外部类访问内部类的非静态成员: 实例化内部类即可
  16.         Inner inner = new Inner();
  17.         inner.innerF2();
  18.     }
  19.     /**
  20.      * 静态内部类可以用 public,protected,private 修饰
  21.      * 静态内部类中可以定义静态或者非静态的成员
  22.      */
  23.     static class Inner {
  24.         static int inner_i = 100;
  25.         int innerJ = 200;
  26.         static void innerF1() {
  27.             // 静态内部类只能访问外部类的静态成员 (包括静态变量和静态方法)
  28.             System.out.println("Outer.i" + i);
  29.             outerF1();
  30.         }
  31.         void innerF2() {
  32.             // 静态内部类不能访问外部类的非静态成员 (包括非静态变量和非静态方法)
  33.             // System.out.println("Outer.i"+j);
  34.             // outerF2();
  35.         }
  36.     }
  37. }

复制代码

静态内部类和成员内部类的区别

生成一个静态内部类不需要外部类成员 静态内部类的对象可以直接生成:

Outer.Inner in = new Outer.Inner();

而不需要通过生成外部类对象来生成. 这样实际上使静态内部类成为了一个顶级类 (正常情况下, 你不能在接口内部放置任何代码, 但嵌套类可以作为接口的一部分, 因为它是 static 的. 只是将嵌套类置于接口的命名空间内, 这并不违反接口的规则)

D: 匿名内部类 (from thinking in java 3th)

匿名内部类就是没有名字的内部类.

什么情况下需要使用匿名内部类?

如果满足下面的一些条件, 使用匿名内部类是比较合适的:

只用到类的一个实例.

类在定义后马上用到.

类非常小 (SUN 推荐是在 4 行代码以下)

给类命名并不会导致你的代码更容易被理解.

在使用匿名内部类时, 要记住以下几个原则:

匿名内部类不能有构造方法.

匿名内部类不能定义任何静态成员, 方法和类.

匿名内部类不能是 public,protected,private,static.

只能创建匿名内部类的一个实例.

一个匿名内部类一定是在 new 的后面, 用其隐含实现一个接口或实现一个类.

因匿名内部类为局部内部类, 所以局部内部类的所有限制都对其生效.

下面的例子看起来有点奇怪:

  1. // 在方法中返回一个匿名内部类
  2. public class Parcel6 {
  3.     public static void main(String[] args) {
  4.         Parcel6 p = new Parcel6();
  5.         Contents c = p.cont();
  6.     }
  7.     public Contents cont() {
  8.         return new Contents() {
  9.             private int i = 11;
  10.             public int value() {
  11.                 return i;
  12.             }
  13.         }; // 在这里需要一个分号
  14.     }
  15. }

复制代码

cont() 方法将下面两个动作合并在一起: 返回值的生成, 与表示这个返回值的类的定义! 进一步说, 这个类是匿名的, 它没有名字. 更糟的是, 看起来是你正要创建一个 Contents 对象:

return new Contents()

复制代码

但是, 在到达语句结束的分号之前, 你却说:"等一等, 我想在这里插入一个类的定义":

  1. return new Contents() {
  2.     private int i = 11;
  3.     public int value() {
  4.         return i;
  5.     }
  6. };

复制代码

这种奇怪的语法指的是:"创建一个继承自 Contents 的匿名类的对象." 通过 new 表达式返回的引用被自动向上转型为对 Contents 的引用. 匿名内部类的语法是下面例子的简略形式:

  1. class MyContents implements Contents {
  2.     private int i = 11;
  3.     public int value() {
  4.         return i;
  5.     }
  6. }
  7. return new MyContents();

复制代码

在这个匿名内部类中, 使用了缺省的构造器来生成 Contents. 下面的代码展示的是, 如果你的基类需要一个有参数的构造器, 应该怎么办:

  1. public class Parcel7 {
  2.     public static void main(String[] args) {
  3.         Parcel7 p = new Parcel7();
  4.         Wrapping w = p.wrap(10);
  5.     }
  6.     public Wrapping wrap(int x) {
  7.         // Base constructor call:
  8.         // Pass constructor argument.
  9.         return new Wrapping(x) {
  10.             public int value() {
  11.                 return super.value() * 47;
  12.             }
  13.         }; // Semicolon required
  14.     }
  15. }

复制代码

只需简单地传递合适的参数给基类的构造器即可, 这里是将 x 传进 new Wrapping(x). 在匿名内部类末尾的分号, 并不是用来标记此内部类结束 (C++ 中是那样). 实际上, 它标记的是表达式的结束, 只不过这个表达式正巧包含了内部类罢了. 因此, 这与别的地方使用的分号是一致的.

如果在匿名类中定义成员变量, 你同样能够对其执行初始化操作:

  1. public class Parcel8 {
  2.     public static void main(String[] args) {
  3.         Parcel8 p = new Parcel8();
  4.         Destination d = p.dest("Tanzania");
  5.     }
  6.     // Argument must be final to use inside
  7.     // anonymous inner class:
  8.     public Destination dest(final String dest) {
  9.         return new Destination() {
  10.             private String label = dest;
  11.             public String readLabel() {
  12.                 return label;
  13.             }
  14.         };
  15.     }
  16. }

复制代码

如果你有一个匿名内部类, 它要使用一个在它的外部定义的对象, 编译器会要求其参数引用是 final 型的, 就像 dest() 中的参数. 如果你忘记了, 会得到一个编译期错误信息. 如果只是简单地给一个成员变量赋值, 那么此例中的方法就可以了. 但是, 如果你想做一些类似构造器的行为, 该怎么办呢? 在匿名类中不可能有已命名的构造器 (因为它根本没名字!), 但通过实例初始化, 你就能够达到为匿名内部类 "制作" 一个构造器的效果. 像这样做:

  1. abstract class Base {
  2.     public Base(int i) {
  3.         System.out.println("Base constructor, i =" + i);
  4.     }
  5.     public abstract void f();
  6. }
  7. public class AnonymousConstructor {
  8.     public static Base getBase(int i) {
  9.         return new Base(i) {
  10.             {
  11.                 System.out.println("Inside instance initializer");
  12.             }
  13.             public void f() {
  14.                 System.out.println("In anonymous f()");
  15.             }
  16.         };
  17.     }
  18.     public static void main(String[] args) {
  19.         Base base = getBase(47);
  20.         base.f();
  21.     }
  22. }

复制代码

在此例中, 不要求变量 i 一定是 final 的. 因为 i 被传递给匿名类的基类的构造器, 它并不会在匿名类内部被直接使用. 下例是带实例初始化的 "parcel" 形式. 注意 dest() 的参数必须是 final, 因为它们是在匿名类内被使用的.

  1. public class Parcel9 {
  2.     public Destinationdest(final String dest, final float price) {
  3.         return new Destination() {
  4.             private int cost;
  5.             private String label = dest;
  6.             // Instance initialization for each object:
  7.             {
  8.                 cost = Math.round(price);
  9.                 if (cost> 100)
  10.                     System.out.println("Over budget!");
  11.             }
  12.             public String readLabel() {
  13.                 return label;
  14.             }
  15.         };
  16.     }
  17.     public static void main(String[] args) {
  18.         Parcel9 p = new Parcel9();
  19.         Destination d = p.dest("Tanzania", 101.395F);
  20.     }
  21. }

复制代码

在实例初始化的部分, 你可以看到有一段代码, 那原本是不能作为成员变量初始化的一部分而执行的 (就是 if 语句). 所以对于匿名类而言, 实例初始化的实际效果就是构造器. 当然它受到了限制: 你不能重载实例初始化, 所以你只能有一个构造器.

从多层嵌套类中访问外部

一个内部类被嵌套多少层并不重要, 它能透明地访问所有它所嵌入的外围类的所有成员, 如下所示:

  1. class MNA {
  2.     private void f() {
  3.     }
  4.     class A {
  5.         private void g() {
  6.         }
  7.         public class B {
  8.             void h() {
  9.                 g();
  10.                 f();
  11.             }
  12.         }
  13.     }
  14. }
  15. public class MultiNestingAccess {
  16.     public static void main(String[] args) {
  17.         MNA mna = new MNA();
  18.         MNA.A mnaa = mna.new A();
  19.         MNA.A.B mnaab = mnaa.new B();
  20.         mnaab.h();
  21.     }
  22. }

复制代码

可以看到在 MNA.A.B 中, 调用方法 g() 和 f() 不需要任何条件 (即使它们被定义为 private). 这个例子同时展示了如何从不同的类里面创建多层嵌套的内部类对象的基本语法.".new" 语法能产生正确的作用域, 所以你不必在调用构造器时限定类名.

内部类的重载问题

如果你创建了一个内部类, 然后继承其外围类并重新定义此内部类时, 会发生什么呢? 也就是说, 内部类可以被重载吗? 这看起来似乎是个很有用的点子, 但是 "重载" 内部类就好像它是外围类的一个方法, 其实并不起什么作用:

  1. class Egg {
  2.     private Yolk y;
  3.     public Egg() {
  4.         System.out.println("New Egg()");
  5.         y = new Yolk();
  6.     }
  7.     protected class Yolk {
  8.         public Yolk() {
  9.             System.out.println("Egg.Yolk()");
  10.         }
  11.     }
  12. }
  13. public class BigEgg extends Egg {
  14.     public static void main(String[] args) {
  15.         new BigEgg();
  16.     }
  17.     public class Yolk {
  18.         public Yolk() {
  19.             System.out.println("BigEgg.Yolk()");
  20.         }
  21.     }
  22. }

复制代码

输出结果为:

  1. New Egg()
  2. Egg.Yolk()

复制代码

缺省的构造器是编译器自动生成的, 这里是调用基类的缺省构造器. 你可能认为既然创建了 BigEgg 的对象, 那么所使用的应该是被 "重载" 过的 Yolk, 但你可以从输出中看到实际情况并不是这样的.

这个例子说明, 当你继承了某个外围类的时候, 内部类并没有发生什么特别神奇的变化. 这两个内部类是完全独立的两个实体, 各自在自己的命名空间内. 当然, 明确地继承某个内部类也是可以的:

  1. class Egg2 {
  2.     private Yolk y = new Yolk();
  3.     public Egg2() {
  4.         System.out.println("New Egg2()");
  5.     }
  6.     public void insertYolk(Yolk yy) {
  7.         y = yy;
  8.     }
  9.     public void g() {
  10.         y.f();
  11.     }
  12.     protected class Yolk {
  13.         public Yolk() {
  14.             System.out.println("Egg2.Yolk()");
  15.         }
  16.         public void f() {
  17.             System.out.println("Egg2.Yolk.f()");
  18.         }
  19.     }
  20. }
  21. public class BigEgg2 extends Egg2 {
  22.     public BigEgg2() {
  23.         insertYolk(new Yolk());
  24.     }
  25.     public static void main(String[] args) {
  26.         Egg2 e2 = new BigEgg2();
  27.         e2.g();
  28.     }
  29.     public class Yolk extends Egg2.Yolk {
  30.         public Yolk() {
  31.             System.out.println("BigEgg2.Yolk()");
  32.         }
  33.         public void f() {
  34.             System.out.println("BigEgg2.Yolk.f()");
  35.         }
  36.     }
  37. }

复制代码

输出结果为:

  1. Egg2.Yolk()
  2. New Egg2()
  3. Egg2.Yolk()
  4. BigEgg2.Yolk()
  5. BigEgg2.Yolk.f()

复制代码

现在 BigEgg2.Yolk 通过 extends Egg2.Yolk 明确地继承了此内部类, 并且重载了其中的方法. Egg2 的 insertYolk() 方法使得 BigEgg2 将它自己的 Yolk 对象向上转型, 然后传递给引用 y. 所以当 g() 调用 y.f() 时, 重载后的新版的 f() 被执行. 第二次调用 Egg2.Yolk() 是 BigEgg2.Yolk 的构造器调用了其基类的构造器. 可以看到在调用 g() 的时候, 新版的 f() 被调用了.

内部类的继承问题 (thinking in java 3th p294)

因为内部类的构造器要用到其外围类对象的引用, 所以在你继承一个内部类的时候, 事情变得有点复杂. 问题在于, 那个 "秘密的" 外围类对象的引用必须被初始化, 而在被继承的类中并不存在要联接的缺省对象. 要解决这个问题, 需使用专门的语法来明确说清它们之间的关联:

  1. class WithInner {
  2.     class Inner {
  3.         Inner() {
  4.             System.out.println("this is a constructor in WithInner.Inner");
  5.         }
  6.         ;
  7.     }
  8. }
  9. public class InheritInner extends WithInner.Inner {
  10.     // ! InheritInner() {} // Won't compile
  11.     InheritInner(WithInner wi) {
  12.         wi.super();
  13.         System.out.println("this is a constructor in InheritInner");
  14.     }
  15.     public static void main(String[] args) {
  16.         WithInner wi = new WithInner();
  17.         InheritInner ii = new InheritInner(wi);
  18.     }
  19. }

复制代码

输出结果为:

  1. this is a constructor in WithInner.Inner
  2. this is a constructor in InheritInner

复制代码

可以看到, InheritInner 只继承自内部类, 而不是外围类. 但是当要生成一个构造器时, 缺省的构造器并不算好, 而且你不能只是传递一个指向外围类对象的引用. 此外, 你必须在构造器内使用如下语法:

enclosingClassReference.super();

复制代码

这样才提供了必要的引用, 然后程序才能编译通过.

来源: https://juejin.im/post/5b7e4a04e51d4538b063eee3


与本文相关文章

  1. JAVA 内部类详解及实例
  2. 一篇文章让你彻底理解 java 中抽象类和接口
  3. 全面掌握 Java 内部类
  4. Java 内部类与闭包
  5. 别翻了, 这篇文章绝对让你深刻理解 java 类的加载以及 ClassLoader 源码分析 [JVM 篇二]
  6. 【java基础】（6）内部类
  7. Java 基础 - 内部类详解
  8. Java-- 内部类详解
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1