内部类（6）：内部类的继承、内部类可以被覆盖吗、局部内部类、内部类标识符

小咪咪 2023-07-05 13:19 24阅读 0赞

### 一、内部类的继承 ###

因为内部类的构造器必须连接到指向其外围类对象的引用，所以在继承内部类的时候，事情会变得有点复杂。问题在于，那个指向外围类对象的“秘密的”引用必须被初始化，而在导出类中不再存在可连接的默认对象。要解决这个问题，必须使用特殊的语法来明确说清它们之间的关联：

class WithInner {
    	class Inner {
    	}
    }
    
    public class InheritInner extends WithInner.Inner {
    	// InheritInner(){}
    	InheritInner(WithInner wi) {
    		wi.super();
    	}
    
    	public static void main(String[] args) {
    		WithInner wi = new WithInner();
    		InheritInner ii = new InheritInner(wi);
    	}
    }

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

enclosingClassReference.super();

这样才提供必要的引用，然后程序才能编译通过。

### 二、内部类可以被覆盖吗 ###

如果创建了一个内部类，然后继承其外围类并重新定义此内部类时，会发生什么呢？也就是说，内部类可以被覆盖吗？这看起来似乎是个很有用的思想，但是“覆盖”内部类就好像它是外围类的一个方法，其实并不起什么作用：

class Egg {
    	private Yolk y;
    
    	protected class Yolk {
    		public Yolk() {
    			System.out.println("Egg.Yolk()");
    		}
    	}
    
    	public Egg() {
    		System.out.println("New Egg()");
    		y = new Yolk();
    	}
    }
    
    public class BigEgg extends Egg {
    	public class Yolk {
    		public Yolk() {
    			System.out.println("BigEgg.Yolk()");
    		}
    	}
    
    	public static void main(String[] args) {
    		new BigEgg();
    	}
    }

默认的构造器是编译器自动生成的，这里是调用基类的默认构造器。你可能认为既然创建了BigEgg的对象，那么所使用的应该是“覆盖后”的Yolk版本，但从输出中可以看到实际情况并不是这样的。

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

class Egg2 {
    	protected class Yolk {
    		public Yolk() {
    			System.out.println("Egg2.Yolk()");
    		}
    
    		public void f() {
    			System.out.println("Egg2.Yolk的f()");
    		}
    	}
    
    	private Yolk y = new Yolk();
    
    	public Egg2() {
    		System.out.println("New Egg2()");
    	}
    
    	public void insertYolk(Yolk yy) {
    		y = yy;
    	}
    
    	public void g() {
    		y.f();
    	}
    }
    
    public class BigEgg2 extends Egg2 {
    	public class Yolk extends Egg2.Yolk {
    		public Yolk() {
    			System.out.println("BigEgg2.Yolk()");
    		}
    
    		public void f() {
    			System.out.println("BigEgg2.Yolk的f()");
    		}
    	}
    
    	public BigEgg2() {
    		insertYolk(new Yolk());
    	}
    
    	public static void main(String[] args) {
    		Egg2 e2 = new BigEgg2();
    		e2.g();
    	}
    }

现在BigEgg2.Yolk通过extends Egg2.Yolk明确地继承了此内部类，并且覆盖了其中的方法。insertYolk()方法允许BigEgg2将它自己的Yolk对象向上转型为Egg2中的引用y。所以当g()调用y.f()时，覆盖后的新版的f()被执行。第二次调用Egg2.Yolk()，结果是BigEgg2.Yolk的构造器调用了其基类的构造器。可以看到在调用g()的时候，新版的f()被调用了。

### 三、局部内部类 ###

前面提到过，可以在代码块里创建内部类，典型的方法是在一个方法体的里面创建。局部内部类不能有访问说明符，因为它不是外围类的一部分；但是它可以访问当前代码块内的常量，以及此外围类的所有成员。下面的例子对局部内部类与匿名内部类的创建进行了比较。

interface Counter {
    	int next();
    }
    
    public class LocalInnerClass {
    	private int count = 0;
    
    	Counter getCounter(final String name) {
    		class LocalCounter implements Counter {
    
    			public LocalCounter() {
    				System.out.println("LocalCounter");
    			}
    
    			@Override
    			public int next() {
    				System.out.print(name);
    				return count++;
    			}
    		}
    		return new LocalCounter();
    	}
    
    	Counter getCounter2(final String name) {
    		return new Counter() {
    			{ // 内部类构造器
    				System.out.println("Counter()");
    			}
    
    			@Override
    			public int next() {
    				System.out.print(name);
    				return count++;
    			}
    		};
    	}
    
    	public static void main(String[] args) {
    		LocalInnerClass lic = new LocalInnerClass();
    		Counter c1 = lic.getCounter("Local inner"), c2 = lic.getCounter2("Anonymous inner");
    		for (int i = 0; i < 5; i++) 
    			System.out.println(c1.next());
    		for (int i = 0; i < 5; i++) 
    			System.out.println(c2.next());
    	}
    }

Counter返回的是序列中的下一个值。我们分别使用局部内部类和匿名内部类实现了这个功能，它们具有相同的行为和能力。既然局部内部类的名字在方法外是不可见的，那为什么我们仍然使用局部内部类而不是匿名内部类呢？唯一的理由是，我们需要一个已命名的构造器，或者需要重载构造器，而匿名内部类只能用于实例初始化。

所以使用局部内部类而不使用匿名内部类的另一个理由就是，需要不止一个该内部类的对象。

### 四、内部类标识符 ###

由于每个类都会产生一个.class文件，其中包含了如何创建该类型的对象的全部信息（此信息产生一个“meta-class”，叫做Class对象），你可能猜到了，内部类也必须生成一个.class文件以包含它们的Class对象信息。这些类文件的命名有严格的规则：外围类的名字，加上$，再加上内部类的名字。例如，LocalInnerClass.java生成的.class文件包括：

Counter.class
    LocalInnerClass$1.class
    LocalInnerClass$1LocalCounter.class
    LocalInnerClass.class

如果内部类是匿名的，编译器会简单的产生一个数字作为其标识符。如果内部类是嵌套在别的内部类之中，只需直接将它们的名字加在其外围类标识符与“$”的后面。

虽然这种命名格式简单而直接，但它还是很健壮的，足以应对绝大多数情况。因为这是Java的标准命名方式，所以产生的文件自动都是平台无关的。（注意，为了保证你的内部类能起作用，java编译器会尽可能地转换它们。）

**如果本文对您有很大的帮助，还请点赞关注一下。**