[关闭]
@nextleaf 2018-08-07T19:36:02.000000Z 字数 6671 阅读 717

Java内部类

Java 内部类 面向对象


1.了解内部类

将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类
一般来说包括四种:成员内部类、局部内部类、匿名内部类和静态内部类。

1.1成员内部类

成员内部类位于另一个类的内部,形如:

  1. class Circle {
  2. double radius = 0;
  3. public Circle(double radius) {
  4. this.radius = radius;
  5. }
  6. class Draw { //内部类
  7. public void drawSahpe() {
  8. System.out.println("drawshape");
  9. }
  10. }
  11. }

成员内部类可以无条件访问外部类的所有成员属性和成员方法(包括private成员和静态成员)

当成员内部类拥有和外部类同名的成员变量或者方法时,会发生隐藏现象,即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员,需要以下面的形式进行访问:

外部类.this.成员变量
外部类.this.成员方法

在外部类中,如果要访问成员内部类的成员,必须先创建一个成员内部类的对象,再通过指向这个对象的引用来访问:

  1. class Circle {
  2. private double radius = 0;
  3. public Circle(double radius) {
  4. this.radius = radius;
  5. getDrawInstance().drawSahpe(); //必须先创建成员内部类的对象,再进行访问
  6. }
  7. private Draw getDrawInstance() {
  8. return new Draw();
  9. }
  10. class Draw { //内部类
  11. public void drawSahpe() {
  12. System.out.println(radius); //外部类的private成员
  13. }
  14. }
  15. }

成员内部类是依附外部类而存在的,也就是说,如果要创建成员内部类的对象,前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下:

  1. public class Test {
  2. public static void main(String[] args) {
  3. //第一种方式:
  4. Outter outter = new Outter();
  5. Outter.Inner inner = outter.new Inner(); //必须通过Outter对象来创建
  6. //第二种方式:
  7. Outter.Inner inner1 = outter.getInnerInstance();
  8. }
  9. }
  10. class Outter {
  11. private Inner inner = null;
  12. public Outter() {
  13. }
  14. public Inner getInnerInstance() {
  15. if(inner == null)
  16. inner = new Inner();
  17. return inner;
  18. }
  19. class Inner {
  20. public Inner() {
  21. }
  22. }
  23. }

如果成员内部类Inner用private修饰,则只能在外部类的内部访问,如果用public修饰,则任何地方都能访问;如果用protected修饰,则只能在同一个包下或者继承外部类的情况下访问;如果是默认访问权限,则只能在同一个包下访问。

1.2局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类,它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

  1. class People{
  2. public People() {
  3. }
  4. }
  5. class Man{
  6. public Man(){
  7. }
  8. public People getWoman(){
  9. class Woman extends People{ //局部内部类
  10. int age =0;
  11. }
  12. return new Woman();
  13. }
  14. }

局部内部类就像是方法里面的一个局部变量一样,是不能有public、protected、private以及static修饰符的。

1.3匿名内部类(平时用得最多)

在编写事件监听的代码时使用匿名内部类不但方便,而且使代码更加容易维护。下面这段代码是一段Android事件监听代码:

  1. scan_bt.setOnClickListener(new OnClickListener() {
  2. @Override
  3. public void onClick(View v) {
  4. // TODO Auto-generated method stub
  5. }
  6. });
  7. history_bt.setOnClickListener(new OnClickListener() {
  8. @Override
  9. public void onClick(View v) {
  10. // TODO Auto-generated method stub
  11. }
  12. });

这段代码为两个按钮设置监听器,这里面就使用了匿名内部类。这段代码中的:

  1. new OnClickListener() {
  2. @Override
  3. public void onClick(View v) {
  4. }
  5. }

就是匿名内部类的使用。代码中需要给按钮设置监听器对象,使用匿名内部类能够在实现父类或者接口中的方法情况下同时产生一个相应的对象,但是前提是这个父类或者接口必须先存在才能这样使用。当然像下面这种写法也是可以的,跟上面使用匿名内部类达到效果相同:

  1. private void setListener()
  2. {
  3. scan_bt.setOnClickListener(new Listener1());
  4. history_bt.setOnClickListener(new Listener2());
  5. }
  6. class Listener1 implements View.OnClickListener{
  7. @Override
  8. public void onClick(View v) {
  9. }
  10. }
  11. class Listener2 implements View.OnClickListener{
  12. @Override
  13. public void onClick(View v) {
  14. }
  15. }

但一般使用匿名内部类的方法来编写事件监听代码。

匿名内部类也是不能有访问修饰符和static修饰符的。
匿名内部类是唯一一种没有构造器的类。正因为其没有构造器,所以匿名内部类的使用范围非常有限,大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说,匿名内部类用于继承其他类或是实现接口,并不需要增加额外的方法,只是对继承方法的实现或是重写。

1.4静态内部类

定义在另一个类里面的类,而且在类的前面有一个关键字static。静态内部类是不需要依赖于外部类的,这点和类的静态成员属性有点类似,并且它不能使用外部类的非static成员变量或者方法,因为在没有外部类的对象的情况下,可以创建静态内部类的对象,如果允许访问外部类的非static成员就会产生矛盾,因为外部类的非static成员必须依附于具体的对象。

  1. public class Test {
  2. public static void main(String[] args) {
  3. Outter.Inner inner = new Outter.Inner();
  4. }
  5. }
  6. class Outter {
  7. public Outter() {}
  8. static class Inner {
  9. public Inner() {}
  10. }
  11. }

2.深入理解内部类

2.1为什么成员内部类可以无条件访问外部类的成员?

编译器在进行编译的时候,会将成员内部类单独编译成一个字节码文件,下面是Outter.java的代码:

  1. public class Outter {
  2. private Inner inner = null;
  3. public Outter() {}
  4. public Inner getInnerInstance() {
  5. if(inner == null)
  6. inner = new Inner();
  7. return inner;
  8. }
  9. protected class Inner {
  10. public Inner() {}
  11. }
  12. }

编译之后,出现了两个字节码文件:
字节码文件
反编译Outter$Inner.class文件得到下面信息:

  1. javap -v Outter$Inner
  2. Compiled from "Outter.java"
  3. public class com.cxh.test2.Outter$Inner extends java.lang.Object
  4. SourceFile: "Outter.java"
  5. InnerClass:
  6. #24= #1 of #22; //Inner=class com/cxh/test2/Outter$Inner of class com/cxh/tes
  7. t2/Outter
  8. minor version: 0
  9. major version: 50
  10. Constant pool:
  11. const #1 = class #2; // com/cxh/test2/Outter$Inner
  12. const #2 = Asciz com/cxh/test2/Outter$Inner;
  13. const #3 = class #4; // java/lang/Object
  14. const #4 = Asciz java/lang/Object;
  15. const #5 = Asciz this$0;
  16. const #6 = Asciz Lcom/cxh/test2/Outter;;
  17. const #7 = Asciz <init>;
  18. const #8 = Asciz (Lcom/cxh/test2/Outter;)V;
  19. const #9 = Asciz Code;
  20. const #10 = Field #1.#11; // com/cxh/test2/Outter$Inner.this$0:Lcom/cxh/t
  21. est2/Outter;
  22. const #11 = NameAndType #5:#6;// this$0:Lcom/cxh/test2/Outter;
  23. const #12 = Method #3.#13; // java/lang/Object."<init>":()V
  24. const #13 = NameAndType #7:#14;// "<init>":()V
  25. const #14 = Asciz ()V;
  26. const #15 = Asciz LineNumberTable;
  27. const #16 = Asciz LocalVariableTable;
  28. const #17 = Asciz this;
  29. const #18 = Asciz Lcom/cxh/test2/Outter$Inner;;
  30. const #19 = Asciz SourceFile;
  31. const #20 = Asciz Outter.java;
  32. const #21 = Asciz InnerClasses;
  33. const #22 = class #23; // com/cxh/test2/Outter
  34. const #23 = Asciz com/cxh/test2/Outter;
  35. const #24 = Asciz Inner;
  36. {
  37. final com.cxh.test2.Outter this$0;
  38. public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);
  39. Code:
  40. Stack=2, Locals=2, Args_size=2
  41. 0: aload_0
  42. 1: aload_1
  43. 2: putfield #10; //Field this$0:Lcom/cxh/test2/Outter;
  44. 5: aload_0
  45. 6: invokespecial #12; //Method java/lang/Object."<init>":()V
  46. 9: return
  47. LineNumberTable:
  48. line 16: 0
  49. line 18: 9
  50. LocalVariableTable:
  51. Start Length Slot Name Signature
  52. 0 10 0 this Lcom/cxh/test2/Outter$Inner;
  53. }

第11行到35行是常量池的内容,下面逐一第38行的内容:

final com.cxh.test2.Outter this$0;

这行是一个指向外部类对象的指针,看到这里想必大家豁然开朗了。也就是说编译器会默认为成员内部类添加了一个指向外部类对象的引用,那么这个引用是如何赋初值的呢?下面接着看内部类的构造器:

public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);

  从这里可以看出,虽然我们在定义的内部类的构造器是无参构造器,编译器还是会默认添加一个参数,该参数的类型为指向外部类对象的一个引用,所以成员内部类中的Outter this&0 指针便指向了外部类对象,因此可以在成员内部类中随意访问外部类的成员。从这里也间接说明了成员内部类是依赖于外部类的,如果没有创建外部类的对象,则无法对Outter this&0引用进行初始化赋值,也就无法创建成员内部类的对象了。

2.2为什么局部内部类和匿名内部类只能访问局部final变量?

先看下面这段代码:

  1. public class Test {
  2. public static void main(String[] args) {}
  3. public void test(final int b) {
  4. final int a = 10;
  5. new Thread(){
  6. public void run() {
  7. System.out.println(a);
  8. System.out.println(b);
  9. };
  10. }.start();
  11. }
  12. }

这段代码会被编译成两个class文件:Test.class和Test1.class。默认情况下,编译器会为匿名内部类和局部内部类起名为Outterx.class(x为正整数)。
此处输入图片的描述
根据上图可知,test方法中的匿名内部类的名字被起为 Test$1。

  上段代码中,如果把变量a和b前面的任一个final去掉,这段代码都编译不过。我们先考虑这样一个问题:

  当test方法执行完毕之后,变量a的生命周期就结束了,而此时Thread对象的生命周期很可能还没有结束,那么在Thread的run方法中继续访问变量a就变成不可能了,但是又要实现这样的效果,怎么办呢?Java采用了 复制 的手段来解决这个问题。将这段代码的字节码反编译可以得到下面的内容:
  此处输入图片的描述

我们看到在run方法中有一条指令:

bipush 10

这条指令表示将操作数10压栈,表示使用的是一个本地局部变量。这个过程是在编译期间由编译器默认进行,如果这个变量的值在编译期间可以确定,则编译器默认会在匿名内部类(局部内部类)的常量池中添加一个内容相等的字面量或直接将相应的字节码嵌入到执行字节码中。这样一来,匿名内部类使用的变量是另一个局部变量,只不过值和方法中局部变量的值相等,因此和方法中的局部变量完全独立开。

  下面再看一个例子:

  1. public class Test {
  2. public static void main(String[] args) {
  3. }
  4. public void test(final int a) {
  5. new Thread(){
  6. public void run() {
  7. System.out.println(a);
  8. };
  9. }.start();
  10. }
  11. }

 反编译得到:
 此处输入图片的描述

 我们看到匿名内部类Test$1的构造器含有两个参数,一个是指向外部类对象的引用,一个是int型变量,很显然,这里是将变量test方法中的形参a以参数的形式传进来对匿名内部类中的拷贝(变量a的拷贝)进行赋值初始化。

  也就说如果局部变量的值在编译期间就可以确定,则直接在匿名内部里面创建一个拷贝。如果局部变量的值无法在编译期间确定,则通过构造器传参的方式来对拷贝进行初始化赋值。

  从上面可以看出,在run方法中访问的变量a根本就不是test方法中的局部变量a。这样一来就解决了前面所说的 生命周期不一致的问题。但是新的问题又来了,既然在run方法中访问的变量a和test方法中的变量a不是同一个变量,当在run方法中改变变量a的值的话,会出现什么情况?

  对,会造成数据不一致性,这样就达不到原本的意图和要求。为了解决这个问题,java编译器就限定必须将变量a限制为final变量,不允许对变量a进行更改(对于引用类型的变量,是不允许指向新的对象),这样数据不一致性的问题就得以解决了。

  到这里,想必大家应该清楚为何 方法中的局部变量和形参都必须用final进行限定了。

3.静态内部类有特殊的地方吗?

  从前面可以知道,静态内部类是不依赖于外部类的,也就说可以在不创建外部类对象的情况下创建内部类的对象。另外,静态内部类是不持有指向外部类对象的引用的,这个读者可以自己尝试反编译class文件看一下就知道了,是没有Outter this&0引用的。
  

最后补充一点知识:

关于成员内部类的继承问题。一般来说,内部类是很少用来作为继承用的。但是当用来继承的话,要注意两点:

  1)成员内部类的引用方式必须为 Outter.Inner.

  2)构造器中必须有指向外部类对象的引用,并通过这个引用调用super()。这段代码摘自《Java编程思想》


参考资料: Java内部类详解

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注