XFCall java学习笔记（四）

内部类

• 内部类拥有外部类所有元素的访问权

• 在内部使用外部类的使用，用外部类名.this

public class DotThis {
    void f() { System.out.println("DotThis.f()"); }

    public class Inner {
        public DotThis outer() {
            return DotThis.this;
        }
    }

• 创建内部类对象，则用外部类对象创建，完成绑定，不能用外部类名。但如果你创建的是嵌套类（静态内部类），那么它就不需要对外部类对象的引用。

• 内部类可以设置private，来达成仅供内部使用，可以在任意作用域定义。它会受作用域限制.

  匿名内部类

public class Parcel7 {
    public Contents contents() {
        return new Contents() { 
            private int i = 11;
            @Override
            public int value() { return i; }
        }; 
    }

返回一个继承Contents的匿名内部类，要是使用有参数构造器，则传相应参数。匿名内部类没有构造器。

匿名内部类要是使用外部定义对象，则要求参数是final，当未显示说明，则编译器内定

public class Parcel10 {
    public Destination
    destination(final String dest, final float price) {
        return new Destination() {
            private int cost;
            {
                cost = Math.round(price);
                if(cost > 100)
                    System.out.println("Over budget!");
            }
            private String label = dest;
            @Override
            public String readLabel() { return label; }
        };
    }

嵌套类

在内部类使用static定义。

• 要创建嵌套类的对象，并不需要其外围类的对象。

• 不能从嵌套类的对象中访问非静态的外围类对象。

• 普通的内部类不能有 static 数据和 static 字段，也不能包含嵌套类。

• 在接口内的内部类都是public和static

继承内部类

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

继承的类要在构造器内生成被继承类的外部类对象.super（）

继承代码执行顺序

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

输出结果：

Egg2.Yolk()
New Egg2()
Egg2.Yolk()
BigEgg2.Yolk()
BigEgg2.Yolk.f()

• 父类的静态代码块----子类静态代码块----父类非静态----子类非静态----父类构造器------子类构造器

内部类的继承只能用外部类.名称来继承，继承父类时，但在继承中知识写了父类的内部类，是继承不了必须这样：

public class Yolk extends Egg2.Yolk {

来实现继承覆盖内部类方法

内部类编译文件名

外围类的名字加上“$"再加上内部类的名字。内部类的内部类也一样。

LocalInnerClass$1.class   匿名类为数字
LocalInnerClass$LocalCounter.class