Java编程思想---第十章 内部类(下)

第十章 内部类(下)

10.9 内部类的继承

 

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

class WithInner {
    class Inner {}
}

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

 

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

enclosingClassReference.super();

 

10.10 内部类可以被覆盖吗

 

  如果创建了一个内部类,然后继承其外围类并重新定义此内部类时会发生什么呢?内部类可以被覆盖吗?我们看下面的例子:

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();
    }
}

 

输出结果为:

New Egg()

Egg.Yolk()

 

  默认构造器是编译器自动生成的,这里是调用基类的默认构造器。这个例子说明,当继承了摸个外围类的时候内部类并没有发生什么特别的变化,这两个内部类是完全独立的实体,各自在自己的命名空间内。

 

10.11 局部内部类

 

  在代码块里创建内部类,典型的方式是在一个方法体的里面创建,局部内部类不能有访问说明符,因为它不是外围类的一部分,但是它可以访问当前代码块内的常量以及此外围类的所有成员。

 

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 "),
                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());
    }
}

 

输出结果为:

LocalCounter()

Counter()

Local inner 0

Local inner 1

Local inner 2

Local inner 3

Local inner 4

Anonymous inner 5

Anonymous inner 6

Anonymous inner 7

Anonymous inner 8

Anonymous inner 9

 

10.12 内部类标识符

 

  由于每个类都会产生一个.class文件,其中包含了如何创建该类型的对象的全部信息。内部类也必须生成一个.class文件以包含他们的Class对象信息,这些类文件的命名有严格的规则:外围类的名字加上“$”再加上内部类的名字,例如LocalInnerClass.java生成的.class文件包括:

Counter.class

LocalInnerClass$1.class

LocalInnerClass$1LocalCounter.class

LocalInnerClass.class

 

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

猜你喜欢

转载自www.cnblogs.com/parable/p/11517671.html