我有心上人了，Java内部类

最新推荐文章于 2020-09-09 13:56:00 发布

掘客DIGGKR

最新推荐文章于 2020-09-09 13:56:00 发布

阅读量149

点赞数 1

分类专栏： Java 文章标签： java 内部类

本文链接：https://blog.csdn.net/sl1202/article/details/107729749

版权

Java 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

在我们日常Java编程中，内部类用到的相对比较少，但是也有必要了解下。
注：本篇测试Jdk版本为1.7

1、内部类简述

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类一般来说分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。
（1）成员内部类

class Outter {
	private double i = 1;
	public static int j = 2;

	//内部类
	class Inner {
		public void innerFunction() {
			System.out.println("innerFunction...");
			//访问外部类的private成员
			System.out.println(i);
			//访问外部类的静态成员
			System.out.println(j);
		}
	}

}

类Inner位于类Outter的内部，像是类Outter的一个成员，Outter称为外部类，Inner成为内部类。成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
注意：当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

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

虽然成员内部类可以无条件地访问外部类的成员，而外部类想访问成员内部类的成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问。
成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。
创建成员内部类对象的一般方式如下：

package com.testinner;

public class Test {
	public static void main(String[] args) {
		Outter o = new Outter();
		//第一种方式
		Outter.Inner i = o.getInnerInstance();
		//第二种方式
		Outter.Inner i2 = o.new Inner();
	}
}

class Outter {
	private double i = 1;
	public static int j = 2;

	public void outterFunction() {
		System.out.println("outterFunction...");
		getInnerInstance().innerFunction();
	}
	
	public Inner getInnerInstance() {
		return new Inner();
	}
	
	//内部类
	class Inner {
		public void innerFunction() {
			System.out.println("innerFunction...");
			//访问外部类的private成员
			System.out.println(i);
			//访问外部类的静态成员
			System.out.println(j);
		}
	}

}

内部类可以拥有private、protected、public访问权限及包访问权限。比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类Outter的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。
（2）局部内部类
局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

class People {
	
}

class Boy {
	
	public People getGirl() {
		class Girl extends People {
			int age = 18;
		}
		return new Girl();
	}
}

注意：局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。
（3）匿名内部类
匿名内部类应该是平时我们编写代码时用得最多的，比如多线程编程时：

package com.testinner;

public class Test {
	public static void main(String[] args) {
		new Thread() {
			public void run() {
				System.out.println("我是一个匿名内部类...");
			};
		}.start();
	}
}

匿名内部类不能有访问修饰符和static修饰符的。匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限。匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的重写或是实现。
（4）静态内部类
静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。
在这里插入图片描述

2、内部类剖析

（1）为什么成员内部类可以无条件访问外部类的成员？

在此之前，我们已经讨论过了成员内部类可以无条件访问外部类的成员，那具体究竟是如何实现的呢？下面通过反编译字节码文件看看究竟。事实上，编译器在进行编译的时候，会将成员内部类单独编译成一个字节码文件，看下面代码：

package com.testinner;

public class Test {
	public static void main(String[] args) {
	
	}
}

class Outter {
	private double i = 1;
	public static int j = 2;

	//内部类
	class Inner {
		public void innerFunction() {
			System.out.println("innerFunction...");
			//访问外部类的private成员
			System.out.println(i);
			//访问外部类的静态成员
			System.out.println(j);
		}
	}

}

编译后出现三个class文件：
在这里插入图片描述
反编译Outter$Inner.class文件得到下面信息：

C:\eclipseProjects\Test\bin\com\testinner>javap -v Outter$Inner
警告: 二进制文件Outter$Inner包含com.testinner.Outter$Inner
Classfile /C:/eclipseProjects/Test/bin/com/testinner/Outter$Inner.class
  Last modified 2020-8-1; size 800 bytes
  MD5 checksum d12eb937e9c95559ee107c15c92f6beb
  Compiled from "Test.java"
class com.testinner.Outter$Inner
  minor version: 0
  major version: 51
  flags: ACC_SUPER
Constant pool:
   #1 = Class              #2             // com/testinner/Outter$Inner
   #2 = Utf8               com/testinner/Outter$Inner
   #3 = Class              #4             // java/lang/Object
   #4 = Utf8               java/lang/Object
   #5 = Utf8               this$0
   #6 = Utf8               Lcom/testinner/Outter;
   #7 = Utf8               <init>
   #8 = Utf8               (Lcom/testinner/Outter;)V
   #9 = Utf8               Code
  #10 = Fieldref           #1.#11         // com/testinner/Outter$Inner.this$0:Lcom/testinner/Outter;
  #11 = NameAndType        #5:#6          // this$0:Lcom/testinner/Outter;
  #12 = Methodref          #3.#13         // java/lang/Object."<init>":()V
  #13 = NameAndType        #7:#14         // "<init>":()V
  #14 = Utf8               ()V
  #15 = Utf8               LineNumberTable
  #16 = Utf8               LocalVariableTable
  #17 = Utf8               this
  #18 = Utf8               Lcom/testinner/Outter$Inner;
  #19 = Utf8               innerFunction
  #20 = Fieldref           #21.#23        // java/lang/System.out:Ljava/io/PrintStream;
  #21 = Class              #22            // java/lang/System
  #22 = Utf8               java/lang/System
  #23 = NameAndType        #24:#25        // out:Ljava/io/PrintStream;
  #24 = Utf8               out
  #25 = Utf8               Ljava/io/PrintStream;
  #26 = String             #27            // innerFunction...
  #27 = Utf8               innerFunction...
  #28 = Methodref          #29.#31        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #29 = Class              #30            // java/io/PrintStream
  #30 = Utf8               java/io/PrintStream
  #31 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
  #34 = Methodref          #35.#37        // com/testinner/Outter.access$0:(Lcom/testinner/Outter;)D
  #35 = Class              #36            // com/testinner/Outter
  #36 = Utf8               com/testinner/Outter
  #37 = NameAndType        #38:#39        // access$0:(Lcom/testinner/Outter;)D
  #38 = Utf8               access$0
  #39 = Utf8               (Lcom/testinner/Outter;)D
  #40 = Methodref          #29.#41        // java/io/PrintStream.println:(D)V
  #41 = NameAndType        #32:#42        // println:(D)V
  #42 = Utf8               (D)V
  #43 = Fieldref           #35.#44        // com/testinner/Outter.j:I
  #44 = NameAndType        #45:#46        // j:I
  #45 = Utf8               j
  #46 = Utf8               I
  #47 = Methodref          #29.#48        // java/io/PrintStream.println:(I)V
  #48 = NameAndType        #32:#49        // println:(I)V
  #49 = Utf8               (I)V
  #50 = Utf8               SourceFile
  #51 = Utf8               Test.java
  #52 = Utf8               InnerClasses
  #53 = Utf8               Inner
{
  final com.testinner.Outter this$0;
    descriptor: Lcom/testinner/Outter;
    flags: ACC_FINAL, ACC_SYNTHETIC

  com.testinner.Outter$Inner(com.testinner.Outter);
    descriptor: (Lcom/testinner/Outter;)V
    flags:
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: aload_1
         2: putfield      #10                 // Field this$0:Lcom/testinner/Outter;
         5: aload_0
         6: invokespecial #12                 // Method java/lang/Object."<init>":()V
         9: return
      LineNumberTable:
        line 14: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      10     0  this   Lcom/testinner/Outter$Inner;

  public void innerFunction();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: getstatic     #20                 // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #26                 // String innerFunction...
         5: invokevirtual #28                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: getstatic     #20                 // Field java/lang/System.out:Ljava/io/PrintStream;
        11: aload_0
        12: getfield      #10                 // Field this$0:Lcom/testinner/Outter;
        15: invokestatic  #34                 // Method com/testinner/Outter.access$0:(Lcom/testinner/Outter;)D
        18: invokevirtual #40                 // Method java/io/PrintStream.println:(D)V
        21: getstatic     #20                 // Field java/lang/System.out:Ljava/io/PrintStream;
        24: getstatic     #43                 // Field com/testinner/Outter.j:I
        27: invokevirtual #47                 // Method java/io/PrintStream.println:(I)V
        30: return
      LineNumberTable:
        line 16: 0
        line 18: 8
        line 20: 21
        line 21: 30
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      31     0  this   Lcom/testinner/Outter$Inner;
}
SourceFile: "Test.java"
InnerClasses:
     #53= #1 of #35; //Inner=class com/testinner/Outter$Inner of class com/testinner/Outter

跳过Constant pool常量池的内容，我们看这行：

final com.testinner.Outter this$0;

这行是一个指向外部类对象的指针。也就是说编译器会默认为成员内部类添加了一个指向外部类对象的引用，那么这个引用是如何赋初值的呢？下面接着看内部类的构造器：

com.testinner.Outter$Inner(com.testinner.Outter);

从这里可以看出，我们定义的内部类没有定义构造器，默认应该提供一个无参的，但是我们看到编译器会默认添加一个参数，该参数的类型为指向外部类对象的一个引用，所以成员内部类中的Outter this&0 指针便指向了外部类对象，因此可以在成员内部类中随意访问外部类的成员。从这里也间接说明了成员内部类是依赖于外部类的，如果没有创建外部类的对象，则无法对Outter this&0引用进行初始化赋值，也就无法创建成员内部类的对象了。
（2）为什么局部内部类和匿名内部类只能访问局部final变量？
在讨论这个问题之前，先看下面这段代码：

package com.testinner;

public class Test {
	public static void main(String[] args) {
	
	}
	
	public void test(final int b) {
        final int a = 10;
        new Thread(){
            public void run() {
                System.out.println(a);
                System.out.println(b);
            };
        }.start();
    }
}

这段代码会被编译成两个class文件：Test.class和Test $ 1.class。默认情况下，编译器会为匿名内部类和局部内部类起名为Outter $ x.class（x为正整数）。
在这里插入图片描述
当test方法执行完毕之后，变量a的生命周期就结束了，而此时Thread对象的生命周期很可能还没有结束，那么在Thread的run方法中继续访问变量a就变成不可能了，但是又要实现这样的效果，怎么办呢？Java采用了复制的手段来解决这个问题。javap -v Test$1将这段代码的字节码反编译可以得到下面的内容：
在这里插入图片描述
我们看到在run方法中有一条指令：

bipush 10

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

com.testinner.Test$1(com.testinner.Test, int);

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

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

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

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

到这里，想必大家应该清楚为何方法中的局部变量和形参都必须用final进行限定了。
（3）静态内部类有特殊的地方吗？
从前面可以知道，静态内部类是不依赖于外部类的，也就说可以在不创建外部类对象的情况下创建内部类的对象。另外，静态内部类是不持有指向外部类对象的引用的。编译下面代码：

package com.testinner;

public class Test {
	public static void main(String[] args) {
	}
}

class Outter {
	public static int j = 2;

	//内部类
	static class Inner {
		public void innerFunction() {
			System.out.println("innerFunction...");
			//访问外部类的静态成员
			System.out.println(j);
		}
	}

}

反编译字节码文件Outter$Inner可以看到内部类的构造器参数是没有Outter this&0引用的，也就是说静态内部类的实例化不依赖外部类对象。
在这里插入图片描述

3、内部类的使用场景和好处

主要有四点：

① 每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整

② 方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏

③ 方便编写事件驱动程序

④ 方便编写线程代码

4、常见的与内部类相关的笔试面试题

① 根据注释填写(1)，(2)，(3)处的代码

package com.testinner;

public class Test {

	public static void main(String[] args) {
		// 初始化Bean1
		Test.Bean1 bean1 = new Test().new Bean1(); // (1)
		bean1.i++;
		// 初始化Bean2
		Test.Bean2 bean2 = new Test.Bean2(); // (2)
		bean2.j++;
		// 初始化Bean3
		Bean.Bean3 bean3 = new Bean().new Bean3(); // (3)
		bean3.k++;
	}

	class Bean1 {
		public int i = 0;
	}

	static class Bean2 {
		public int j = 0;
	}
}

class Bean {
	class Bean3 {
		public int k = 0;
	}
}

对于成员内部类，必须先产生外部类的实例化对象，才能产生内部类的实例化对象。而静态内部类不用产生外部类的实例化对象即可产生内部类的实例化对象。

创建静态内部类对象的一般形式为：外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()

创建成员内部类对象的一般形式为：外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()
　　
② 下面这段代码的输出结果是什么？

public class Test {
	public static void main(String[] args) {
		Outter outter = new Outter();
		outter.new Inner().print();
	}
}

class Outter {
	private int a = 1;

	class Inner {
		private int a = 2;

		public void print() {
			int a = 3;
			System.out.println("局部变量：" + a);
			System.out.println("内部类变量：" + this.a);
			System.out.println("外部类变量：" + Outter.this.a);
		}
	}
}

输出：

局部变量：3
内部类变量：2
外部类变量：1

5、Jdk1.8的不同

看下面代码，Jdk1.8引入了effectively final事实上的final，局部变量和形参不再强制需要声明为final了，只要不修改的变量的值是事实上的final，就可以。如果修改变量的值，则提示下图错误，编译不过去。
在这里插入图片描述
欢迎小伙伴们留言交流~~
浏览更多文章可关注微信公众号：diggkr

掘客DIGGKR

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
我有心上人了，Java内部类

在我们日常Java编程中，内部类用到的相对比较少，但是也有必要了解下。1、内部类简述在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类一般来说分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。（1）成员内部类...
复制链接

扫一扫