Java内部类

1.闭包与回调：闭包：返回一个内部类对象，这个内部类对象包含外部类对象的信息。回调：返回的内部类对象可以调用外部类中的方法。

public static void main(String[] args) {
        Student s = new Student("小明");
        s.work();
        s.t().work();
    }
}

interface Teachable {
    void work();
}

class Parents {
    private String name;

    public Parents() {
    }

    public Parents(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void work() {
        System.out.println(name + "正在教孩子");
    }
}

class Student extends Parents {
    public Student() {
    }

    public Student(String name) {
        super(name);
    }

    private void study() {
        System.out.println("正在学习");
    }

    private class Closure implements Teachable {
        @Override
        public void work() {
            study();
        }
    }

    public Teachable t() {
        return new Closure();
    }

2.内部类的继承：构造内部类必须给它一个外部类对象的引用，在继承内部类的时候，需要在子类的构造器中手动加入对基类的调用。内部类需要外部类对象引用.super()；

class A {
    class B {
    }
}

public class Test18 extends A.B {
    Test18(A a) {
        a.super();
    }

    public static void main(String[] args) {
        A a = new A();
        Test18 t = new Test18(a);
    }
}

3.内部类可以被覆盖吗：覆盖内部类并不是真的覆盖，而是在新类中创建了一个新的内部类，被覆盖的内部类只是名字相同，它们是完全独立的实体。

class A1 {
    public A1() {
        System.out.println("A1()");
        new B1();
    }

    public class B1 {
        public B1() {
            System.out.println("A1.B1");
        }
    }
}

public class Test19 extends A1 {
    public class B1 {
        public B1() {
            System.out.println("Test.B1");
        }
    }

    public static void main(String[] args) {
        new Test19();
    }
}