《Java编程思想》第四版之内部类学习之(四)——内部类进阶

时间:2021-09-22 15:31:56

  版权声明:学习内容均为本人笔记,代码均为本人依据课本所写或改编,笔记均为个人心得或书中摘抄



引言:内部类,即将一个类的定义放在另一个类的定义内部。内部类与组合是完全不同的概念。内部类看似是一种代码的隐藏机制,其实,它能够了解外部类,并且与之通信,这为我们的编程提供了极大的方便。


1.9内部类的继承

如何继承一个内部类?根据前面的内容,内部类中会有一个捕获自创建它外部类对象的引用,如果继承该内部类,这个外部类的引用也要被连接初始化,内部类中也不存在可连接的默认对象。


//212页
class WithInner{
class Inner{}
}

public class InheritInner extends WithInner.Inner{
//public InheritInner(){} 不能使用该构造器,因为没有获取父类外部类的引用
public InheritInner(WithInner wi) {
wi.super();//通过父类外部类的引用初始化继承的内部类
}
public static void main(String[] args){
WithInner wi=new WithInner();
InheritInner i1=new InheritInner(wi);
}
}

在继承内部类的类中,必须获取一个创建内部类的外部类对象的引用,通过这个引用调用内部类父类进行初始化操作。
注意:这里Inner内部类我们使用的是一个默认构造函数,是没有参数的。如果有参数又该如何呢:

class WithInner{
class Inner{
public Inner(int i) {}//带有参数的构造函数
}
}

public class InheritInner extends WithInner.Inner{
//public InheritInner(){} 不能使用该构造器,因为没有获取父类外部类的引用
public InheritInner(WithInner wi) {
wi.super(1);//调用父类构造器时,需要一个符合父类构造器的参数
}
public static void main(String[] args){
WithInner wi=new WithInner();
InheritInner i1=new InheritInner(wi);
}
}

此时内部类Inner中有一个带有参数的构造器,此时我们在继承内部类的InheritInner类中,调用父类时应该添加相应的参数


1.10内部类可以被覆盖吗

如果有一个类,并且该类有一个内部类,那么创建一个新类继承该外部类,然后在新类中重新创建此内部类会覆盖父类中的内部类吗?

//212页

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();
}
}/*Output:
New Egg()
Egg.Yolk()*/

创建自身对象时,会调用父类构造器,然后父类构造器中顶一起了内部类,然后输出的结果并不是子类中的内部类,也就是说父类并没有获取子类内部类的对象,也就不存在转型。两个内部类没有什么关系,它们各自在自己的命名空间内。
当BigEgg中的内部类明确继承了BigEgg父类Egg外部类中的内部类Yolk类。

//213页

class Egg2{
private Yolk y=new Yolk();//先与构造器前初始化,调用内部类构造器
protected class Yolk{
public Yolk(){//内部类构造函数
System.out.println("Egg2.Yolk()");
}
public void f() {//内部类f()方法
System.out.println("Egg2.Yolk().f()");
}
}
public Egg2(){//初始化之前,先初始化字段
System.out.println("New Egg2()");
}
public void insertYolk(Yolk yy){//获取一个Yolk类或子类的引用
y=yy;
}
public void g(){
y.f();//调用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());//首先初始化父类BigEgg,然后调用本类中的Yolk类的构造函数,然后调用inserYolk()方法
}
public static void main(String[] args){
Egg2 e2=new BigEgg2();//调用BigEgg2()构造器,向上转型为Egg2类
e2.g();
}
}/*Output:
Egg2.Yolk()
New Egg2()
Egg2.Yolk()
BigEgg2.Yolk()
BigEgg2.Yolk().f()
*/

BigEgg2.Yolk2明确的继承了Egg2类中的内部类Yolk,并且覆盖了f()方法。insertYolk()方法,将子类BigEgg2中的内部类对象转型为父类Egg中的内部类,当g()调用f()方法时,覆盖的f()方法被执行。
可能很多人第一次看不懂这个输出的结果,我分析了程序的执行步骤
1、main()方法中new BigEgg2()调用了BigEgg2()构造器,由于BigEgg2()继承自Egg2,所以首先初始化父类Egg2类
2、父类Egg2初始化时,首先对字段进行初始化,所以初始化了Yolk对象的y,new Yolk()时就当用了内部类Yolk的构造函数
3、执行Egg2.Yolk的构造函数,第一次输出产生“Egg2.Yolk()”
4、执行Egg2的构造函数,第二次输出产生“New Egg2()”
5、返回到子类BigEgg2中,执行insertYolk(new Yolk(),首先执行方法中的new Yolk(),调用BigEgg2.Yolk的构造函数
6、由于BigEgg2.Yolk继承自Egg2.Yolk,所以先调用Egg.Yolk中的构造函数,第三次输出产生”Egg2.Yolk()“
7、返回到子类BigEgg2.Yolk中,执行构造函数,第四次输出产生”BigEgg2.Yolk()“
8、此时BigEgg2的构造全部结束,返回到main中向上转型为Egg2
9、执行e2.g()方法,调用y.f()方法,由于Egg2中Egg2.Yolk的引用y存入的是子类BigEgg2.Yolk的引用,所以会调用BigEgg2.Yolk中的f()方法
10、执行BigEgg2.Yolk中的f()方法,第五次输出产生”BigEgg2.Yolk().f()“


1.11局部内部类

可以在类中创建匿名内部类,静态内部类,普通内部类,也可以在代码块里创建内部类,典型的方式就是在一个方法体的内部里面创建。局部内部类不能有访问说明符,因为它不是外部类的一部分,但是它可以方位当前代码块内的常量(Java8中传入到内部类的值不一定是final类型的,只要初始化后不被修改即可),以及此外围类的所有成员。
创建局部内部类和创建匿名内部类比较

//214页

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()");
}
public int next(){
System.out.print(name);
return count++;
}
}
return new LocalCounter();
}
Counter getCounter2(final String name){
return new Counter(){//匿名内部类
{
System.out.println("Counter()");
}
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");//通过外部类对象调用方法创建局部内部类
Counter 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());
}
}/*Output:
LocalCounter()
Counter()
Local inner0
Local inner1
Local inner2
Local inner3
Local inner4
Anonymous inner5
Anonymous inner6
Anonymous inner7
Anonymous inner8
Anonymous inner9*/

分别创建了局部内部类LocalCounter类和匿名内部类实现了Counter接口,该接口用于返回序列中的下一个值,这两个内部类具有了相同行为和能力。
局部内部类和匿名内部类的区别:局部内部类的名字在方法外是不可见的,局部内部类可以重载构造器,而匿名内部类只能用于实例初始化,没有构造器。
所以当我们需要不止一个内部类的对象时,应该选择局部内部类而不是匿名内部类。


1.12内部类标识符

由于每个类都会产生一个.class文件,其中包含了如何创建该类型的对象的全部信息(此信息产生一个”meta-class“,叫做Class对象),内部类也会生成一个.class文件以包含它们的Class对象信息。这些类的命名有严格的规则:外围类的名字,加上”$“,再加上内部类的名字。例如,LocalInnerClass.java生成的.class文件包括:
Counter,class
LocalInnerClass$1.class
LocalInnerClass$1LocalCounter.class
LocalInnerClass.class
如果是匿名内部类,编译器会简单的产生一个数字作为其标识符。如果内部类嵌套在别的内部类中,只需将它们的名字加在其外部类标识符与$的后面。


1.13总结

在内部类章节中,我们了解到了一个普通内部类必须要通过外部类对象来创建,并且它会获得一个外部类对象的引用,这样它就能访问外部类对象中的所有成员了。然而对于一个嵌套类也就是静态内部类来说,它不需要外部类对象就能创建对象,因为它是静态的属于类本身,不过这也限制了它的操作,静态内部类不能访问非静态的外部类对象。除此之外,普通的内部类也不能包含static的字段和数据,我把它想象成属于外部类对象的某个”方法“,显然,普通内部类只能通过外部类对象创建,static数据和字段不属于对象,所以会同类一起编译存储在静态区,那么这个静态区属于哪个类其实是未知的。
在本章中,我们也发现了,JAVA相对本书版本已经更新了,在JAVA8的版本中,内部类接收的参数已经不必必须声明为final常量了(现在你也可以这么做),但是如果不声明为final,编译器要求这个值初始化后不能被修改,否则会报错,这是因为在Java中的传值操作,如果这个值在外部类中被修改,那么内部类得到的数值可能已经发生改变,得到了不是期望的值,这会带来很大的问题。
作用域中的类与其它类共同编译,但只在作用域内可用,在其他作用于使用相同的域名不会有命名冲突。同时,如果一个类继承了一个外部类,并且创建了相同的内部类时,其实并不会被覆盖,只有当这个继承的类创建了继承自父类中内部类的一个类时,才会出现覆盖的可能。
Java内部类完美的实现了多重继承,虽然我们可以通过实现多个接口来实现多重继承,但是如果拥有的是抽象的类或者具体的类时,那只能用内部类才能实现多重继承
通过学习,我们也发现了内部类强大的功能。我们编写了控制温室的案例,用一个外部类继承控制框架,用多个内部类来继承各种事件,我们将控制与行为进行了分离,不仅利于代码的维护,还为开发提供了极大的方便。



温馨提示:如果有什么错误,或者有什么意见(对于排版、知识块内容选取、讲述方式等),烦请评论或私聊,也许您的一个建议和一点指点能使我更加完善自己,也能让您感受到帮助他人的乐趣。祝您的编程之路一帆风顺!


如有交流请加微信:备注CSDN博友

《Java编程思想》第四版之内部类学习之(四)——内部类进阶